chart2/source/controller/main/ChartController.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 <sal/config.h>
  22
  23 #include <config_wasm_strip.h>
  24 #include <ChartController.hxx>
  25 #include <ChartView.hxx>
  26 #include <servicenames.hxx>
  27 #include <ResId.hxx>
  28 #include <dlg_DataSource.hxx>
  29 #include <ChartModel.hxx>
  30 #include <ChartModelHelper.hxx>
  31 #include <ChartType.hxx>
  32 #include "ControllerCommandDispatch.hxx"
  33 #include <DataSeries.hxx>
  34 #include <Diagram.hxx>
  35 #include <strings.hrc>
  36 #include <ChartViewHelper.hxx>
  37
  38 #include <ChartWindow.hxx>
  39 #include <chartview/DrawModelWrapper.hxx>
  40 #include <DrawViewWrapper.hxx>
  41 #include <ObjectIdentifier.hxx>
  42 #include <ControllerLockGuard.hxx>
  43 #include "UndoGuard.hxx"
  44 #include "ChartDropTargetHelper.hxx"
  45
  46 #include <dlg_ChartType.hxx>
  47 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
  48 #include <AccessibleChartView.hxx>
  49 #endif
  50 #include "DrawCommandDispatch.hxx"
  51 #include "ShapeController.hxx"
  52 #include "UndoActions.hxx"
  53 #include <ViewElementListProvider.hxx>
  54
  55 #include <comphelper/dispatchcommand.hxx>
  56 #include <BaseCoordinateSystem.hxx>
  57
  58 #include <com/sun/star/frame/XController2.hpp>
  59 #include <com/sun/star/util/CloseVetoException.hpp>
  60 #include <com/sun/star/frame/LayoutManagerEvents.hpp>
  61 #include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp>
  62 #include <com/sun/star/ui/XSidebar.hpp>
  63 #include <com/sun/star/chart2/XDataProviderAccess.hpp>
  64 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  65
  66 #include <sal/log.hxx>
  67 #include <tools/debug.hxx>
  68 #include <svx/sidebar/SelectionChangeHandler.hxx>
  69 #include <toolkit/helper/vclunohelper.hxx>
  70 #include <utility>
  71 #include <vcl/svapp.hxx>
  72 #include <vcl/weld.hxx>
  73 #include <osl/mutex.hxx>
  74 #include <comphelper/lok.hxx>
  75
  76 #include <sfx2/sidebar/SidebarController.hxx>
  77 #include <com/sun/star/awt/XVclWindowPeer.hpp>
  78 #include <com/sun/star/frame/XLayoutManager.hpp>
  79
  80 // this is needed to properly destroy the unique_ptr to the AcceleratorExecute
  81 // object in the DTOR
  82 #include <svtools/acceleratorexecute.hxx>
  83 #include <svx/ActionDescriptionProvider.hxx>
  84 #include <comphelper/diagnose_ex.hxx>
  85
  86 // enable the following define to let the controller listen to model changes and
  87 // react on this by rebuilding the view
  88 #define TEST_ENABLE_MODIFY_LISTENER
  89
  90 namespace chart
  91 {
  92
  93 using namespace ::com::sun::star;
  94 using namespace ::com::sun::star::accessibility;
  95 using namespace ::com::sun::star::chart2;
  96 using ::com::sun::star::uno::Reference;
  97 using ::com::sun::star::uno::Sequence;
  98
  99 ChartController::ChartController(uno::Reference<uno::XComponentContext> xContext) :
 100     m_aLifeTimeManager( nullptr ),
 101     m_bSuspended( false ),
 102     m_xCC(std::move(xContext)),
 103     m_aModel( nullptr, m_aModelMutex ),
 104     m_eDragMode(SdrDragMode::Move),
 105     m_aDoubleClickTimer("chart2 ChartController m_aDoubleClickTimer"),
 106     m_bWaitingForDoubleClick(false),
 107     m_bWaitingForMouseUp(false),
 108     m_bFieldButtonDown(false),
 109     m_bConnectingToView(false),
 110     m_bDisposed(false),
 111     m_aDispatchContainer( m_xCC ),
 112     m_eDrawMode( CHARTDRAW_SELECT ),
 113     mpSelectionChangeHandler(new svx::sidebar::SelectionChangeHandler(
 114             [this]() { return this->GetContextName(); },
 115                 this, vcl::EnumContext::Context::Cell))
 116 {
 117     m_aDoubleClickTimer.SetInvokeHandler( LINK( this, ChartController, DoubleClickWaitingHdl ) );
 118 }
 119
 120 ChartController::~ChartController()
 121 {
 122     stopDoubleClickWaiting();
 123 }
 124
 125 ChartController::TheModel::TheModel( rtl::Reference<::chart::ChartModel> xModel ) :
 126     m_xModel(std::move( xModel )),
 127     m_bOwnership( true )
 128 {
 129 }
 130
 131 ChartController::TheModel::~TheModel()
 132 {
 133 }
 134
 135 void ChartController::TheModel::addListener( ChartController* pController )
 136 {
 137     if(m_xModel)
 138     {
 139         //if you need to be able to veto against the destruction of the model
 140         // you must add as a close listener
 141
 142         //otherwise you 'can' add as closelistener or 'must' add as dispose event listener
 143
 144         m_xModel->addCloseListener(
 145             static_cast<util::XCloseListener*>(pController) );
 146     }
 147 }
 148
 149 void ChartController::TheModel::removeListener(  ChartController* pController )
 150 {
 151     if(m_xModel)
 152         m_xModel->removeCloseListener(
 153             static_cast<util::XCloseListener*>(pController) );
 154 }
 155
 156 void ChartController::TheModel::tryTermination()
 157 {
 158     if(!m_bOwnership)
 159         return;
 160
 161     try
 162     {
 163         if(m_xModel.is())
 164         {
 165             try
 166             {
 167                 //@todo ? are we allowed to use sal_True here if we have the explicit ownership?
 168                 //I think yes, because there might be other CloseListeners later in the list which might be interested still
 169                 //but make sure that we do not throw the CloseVetoException here ourselves
 170                 //so stop listening before trying to terminate or check the source of queryclosing event
 171                 m_xModel->close(true);
 172
 173                 m_bOwnership                = false;
 174             }
 175             catch( const util::CloseVetoException& )
 176             {
 177                 //since we have indicated to give up the ownership with parameter true in close call
 178                 //the one who has thrown the CloseVetoException is the new owner
 179
 180                 SAL_WARN_IF( m_bOwnership, "chart2.main", "a well known owner has caught a CloseVetoException after calling close(true)");
 181                 m_bOwnership                = false;
 182                 return;
 183             }
 184
 185         }
 186     }
 187     catch(const uno::Exception&)
 188     {
 189         DBG_UNHANDLED_EXCEPTION( "chart2", "Termination of model failed" );
 190     }
 191 }
 192
 193 ChartController::TheModelRef::TheModelRef( TheModel* pTheModel, osl::Mutex& rMutex ) :
 194     m_rModelMutex(rMutex)
 195 {
 196     osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
 197     m_xTheModel = pTheModel;
 198 }
 199 ChartController::TheModelRef::TheModelRef( const TheModelRef& rTheModel, ::osl::Mutex& rMutex ) :
 200     m_rModelMutex(rMutex)
 201 {
 202     osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
 203     m_xTheModel = rTheModel.m_xTheModel;
 204 }
 205 ChartController::TheModelRef& ChartController::TheModelRef::operator=(TheModel* pTheModel)
 206 {
 207     osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
 208     m_xTheModel = pTheModel;
 209     return *this;
 210 }
 211 ChartController::TheModelRef& ChartController::TheModelRef::operator=(const TheModelRef& rTheModel)
 212 {
 213     osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
 214     m_xTheModel = rTheModel.operator->();
 215     return *this;
 216 }
 217 ChartController::TheModelRef::~TheModelRef()
 218 {
 219     osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
 220     m_xTheModel.clear();
 221 }
 222 bool ChartController::TheModelRef::is() const
 223 {
 224     return m_xTheModel.is();
 225 }
 226
 227 namespace {
 228
 229 rtl::Reference<ChartType> getChartType(const rtl::Reference<ChartModel>& xChartDoc)
 230 {
 231     rtl::Reference<Diagram > xDiagram = xChartDoc->getFirstChartDiagram();
 232     if (!xDiagram.is())
 233         return nullptr;
 234
 235     const std::vector< rtl::Reference< BaseCoordinateSystem > > xCooSysSequence( xDiagram->getBaseCoordinateSystems());
 236     if (xCooSysSequence.empty())
 237         return nullptr;
 238
 239     return xCooSysSequence[0]->getChartTypes2()[0];
 240 }
 241
 242 }
 243
 244 OUString ChartController::GetContextName()
 245 {
 246     if (m_bDisposed)
 247         return OUString();
 248
 249     uno::Any aAny = getSelection();
 250     if (!aAny.hasValue())
 251         return u"Chart"_ustr;
 252
 253     OUString aCID;
 254     aAny >>= aCID;
 255
 256     if (aCID.isEmpty())
 257         return u"Chart"_ustr;
 258
 259     ObjectType eObjectID = ObjectIdentifier::getObjectType(aCID);
 260     switch (eObjectID)
 261     {
 262         case OBJECTTYPE_DATA_SERIES:
 263             return u"Series"_ustr;
 264         case OBJECTTYPE_DATA_ERRORS_X:
 265         case OBJECTTYPE_DATA_ERRORS_Y:
 266         case OBJECTTYPE_DATA_ERRORS_Z:
 267             return u"ErrorBar"_ustr;
 268         case OBJECTTYPE_AXIS:
 269             return u"Axis"_ustr;
 270         case OBJECTTYPE_GRID:
 271             return u"Grid"_ustr;
 272         case OBJECTTYPE_DIAGRAM:
 273             {
 274                 rtl::Reference<ChartType> xChartType = getChartType(getChartModel());
 275                 if (xChartType.is() && xChartType->getChartType() == "com.sun.star.chart2.PieChartType")
 276                     return u"ChartElements"_ustr;
 277                 break;
 278             }
 279         case OBJECTTYPE_DATA_CURVE:
 280         case OBJECTTYPE_DATA_AVERAGE_LINE:
 281             return u"Trendline"_ustr;
 282         default:
 283         break;
 284     }
 285
 286     return u"Chart"_ustr;
 287 }
 288
 289 // private methods
 290
 291 bool ChartController::impl_isDisposedOrSuspended() const
 292 {
 293     if( m_aLifeTimeManager.impl_isDisposed() )
 294         return true;
 295
 296     if( m_bSuspended )
 297     {
 298         OSL_FAIL( "This Controller is suspended" );
 299         return true;
 300     }
 301     return false;
 302 }
 303
 304 namespace {
 305
 306 uno::Reference<ui::XSidebar> getSidebarFromModel(const uno::Reference<frame::XModel>& xModel)
 307 {
 308     uno::Reference<container::XChild> xChild(xModel, uno::UNO_QUERY);
 309     if (!xChild.is())
 310         return nullptr;
 311
 312     uno::Reference<frame::XModel> xParent (xChild->getParent(), uno::UNO_QUERY);
 313     if (!xParent.is())
 314         return nullptr;
 315
 316     uno::Reference<frame::XController2> xController(xParent->getCurrentController(), uno::UNO_QUERY);
 317     if (!xController.is())
 318         return nullptr;
 319
 320     uno::Reference<ui::XSidebarProvider> xSidebarProvider  = xController->getSidebar();
 321     if (!xSidebarProvider.is())
 322         return nullptr;
 323
 324     return xSidebarProvider->getSidebar();
 325 }
 326
 327 }
 328
 329 // XController
 330
 331 void SAL_CALL ChartController::attachFrame(
 332     const uno::Reference<frame::XFrame>& xFrame )
 333 {
 334     SolarMutexGuard aGuard;
 335
 336     if( impl_isDisposedOrSuspended() ) //@todo? allow attaching the frame while suspended?
 337         return; //behave passive if already disposed or suspended
 338
 339     if(m_xFrame.is()) //what happens, if we do have a Frame already??
 340     {
 341         //@todo? throw exception?
 342         OSL_FAIL( "there is already a frame attached to the controller" );
 343         return;
 344     }
 345
 346     //--attach frame
 347     m_xFrame = xFrame; //the frameloader is responsible to call xFrame->setComponent
 348
 349     // Only notify after setting the frame, otherwise notification will fail
 350     mpSelectionChangeHandler->Connect();
 351
 352     uno::Reference<ui::XSidebar> xSidebar = getSidebarFromModel(getChartModel());
 353     if (xSidebar.is())
 354     {
 355         auto pSidebar = dynamic_cast<sfx2::sidebar::SidebarController*>(xSidebar.get());
 356         assert(pSidebar);
 357         pSidebar->registerSidebarForFrame(this);
 358         pSidebar->updateModel(getChartModel());
 359         css::lang::EventObject aEvent;
 360         mpSelectionChangeHandler->selectionChanged(aEvent);
 361     }
 362
 363     //add as disposelistener to the frame (due to persistent reference) ??...:
 364
 365     //the frame is considered to be owner of this controller and will live longer than we do
 366     //the frame or the disposer of the frame has the duty to call suspend and dispose on this object
 367     //so we do not need to add as lang::XEventListener for DisposingEvents right?
 368
 369     //@todo nothing right???
 370
 371     //create view @todo is this the correct place here??
 372
 373     vcl::Window* pParent = nullptr;
 374     //get the window parent from the frame to use as parent for our new window
 375     if(xFrame.is())
 376     {
 377         uno::Reference<awt::XWindow> xContainerWindow = xFrame->getContainerWindow();
 378         if (xContainerWindow)
 379             xContainerWindow->setVisible(true);
 380         pParent = VCLUnoHelper::GetWindow( xContainerWindow );
 381     }
 382
 383     {
 384         // calls to VCL
 385         SolarMutexGuard aSolarGuard;
 386         auto pChartWindow = VclPtr<ChartWindow>::Create(this,pParent,pParent?pParent->GetStyle():0);
 387         pChartWindow->SetBackground();//no Background
 388         m_xViewWindow.set( pChartWindow->GetComponentInterface(), uno::UNO_QUERY );
 389         pChartWindow->Show();
 390         m_apDropTargetHelper.reset(
 391             new ChartDropTargetHelper( pChartWindow->GetDropTarget(), getChartModel()));
 392
 393         impl_createDrawViewController();
 394     }
 395
 396     //create the menu
 397     {
 398         uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
 399         if( xPropSet.is() )
 400         {
 401             try
 402             {
 403                 uno::Reference< css::frame::XLayoutManager > xLayoutManager;
 404                 xPropSet->getPropertyValue( u"LayoutManager"_ustr ) >>= xLayoutManager;
 405                 if ( xLayoutManager.is() )
 406                 {
 407                     xLayoutManager->lock();
 408                     xLayoutManager->requestElement( u"private:resource/menubar/menubar"_ustr );
 409                     //@todo: createElement should become unnecessary, remove when #i79198# is fixed
 410                     xLayoutManager->createElement( u"private:resource/toolbar/standardbar"_ustr );
 411                     xLayoutManager->requestElement( u"private:resource/toolbar/standardbar"_ustr );
 412                     //@todo: createElement should become unnecessary, remove when #i79198# is fixed
 413                     xLayoutManager->createElement( u"private:resource/toolbar/toolbar"_ustr );
 414                     xLayoutManager->requestElement( u"private:resource/toolbar/toolbar"_ustr );
 415
 416                     // #i12587# support for shapes in chart
 417                     xLayoutManager->createElement( u"private:resource/toolbar/drawbar"_ustr );
 418                     xLayoutManager->requestElement( u"private:resource/toolbar/drawbar"_ustr );
 419
 420                     xLayoutManager->requestElement( u"private:resource/statusbar/statusbar"_ustr );
 421                     xLayoutManager->unlock();
 422
 423                     // add as listener to get notified when
 424                     m_xLayoutManagerEventBroadcaster.set( xLayoutManager, uno::UNO_QUERY );
 425                     if( m_xLayoutManagerEventBroadcaster.is())
 426                         m_xLayoutManagerEventBroadcaster->addLayoutManagerEventListener( this );
 427                 }
 428             }
 429             catch( const uno::Exception & )
 430             {
 431                 DBG_UNHANDLED_EXCEPTION("chart2");
 432             }
 433         }
 434     }
 435 }
 436
 437 //XModeChangeListener
 438 void SAL_CALL ChartController::modeChanged( const util::ModeChangeEvent& rEvent )
 439 {
 440     SolarMutexGuard aGuard;
 441     auto pChartWindow(GetChartWindow());
 442     //adjust controller to view status changes
 443
 444     if( rEvent.NewMode == "dirty" )
 445     {
 446         //the view has become dirty, we should repaint it if we have a window
 447         if( pChartWindow )
 448             pChartWindow->ForceInvalidate();
 449     }
 450     else if( rEvent.NewMode == "invalid" )
 451     {
 452         //the view is about to become invalid so end all actions on it
 453         impl_invalidateAccessible();
 454         if( m_pDrawViewWrapper && m_pDrawViewWrapper->IsTextEdit() )
 455             this->EndTextEdit();
 456         if( m_pDrawViewWrapper )
 457         {
 458             m_pDrawViewWrapper->UnmarkAll();
 459             m_pDrawViewWrapper->HideSdrPage();
 460         }
 461     }
 462     else
 463     {
 464         //the view was rebuild so we can start some actions on it again
 465         if( !m_bConnectingToView )
 466         {
 467             if(pChartWindow && m_aModel.is() )
 468             {
 469                 m_bConnectingToView = true;
 470
 471                 GetDrawModelWrapper();
 472                 if(m_pDrawModelWrapper)
 473                 {
 474                     {
 475                         if( m_pDrawViewWrapper )
 476                             m_pDrawViewWrapper->ReInit();
 477                     }
 478
 479                     //reselect object
 480                     if( m_aSelection.hasSelection() )
 481                         this->impl_selectObjectAndNotiy();
 482                     else
 483                         ChartModelHelper::triggerRangeHighlighting( getChartModel() );
 484
 485                     impl_initializeAccessible();
 486
 487                     pChartWindow->Invalidate();
 488                 }
 489
 490                 m_bConnectingToView = false;
 491             }
 492         }
 493     }
 494 }
 495
 496 sal_Bool SAL_CALL ChartController::attachModel( const uno::Reference< frame::XModel > & xModel )
 497 {
 498     impl_invalidateAccessible();
 499
 500     //is called to attach the controller to a new model.
 501     //return true if attach was successfully, false otherwise (e.g. if you do not work with a model)
 502
 503     SolarMutexResettableGuard aGuard;
 504     if( impl_isDisposedOrSuspended() ) //@todo? allow attaching a new model while suspended?
 505         return false; //behave passive if already disposed or suspended
 506     aGuard.clear();
 507
 508     ::chart::ChartModel* pChartModel = dynamic_cast<::chart::ChartModel*>(xModel.get());
 509     assert(!xModel || pChartModel);
 510
 511     TheModelRef aNewModelRef( new TheModel(pChartModel), m_aModelMutex);
 512     TheModelRef aOldModelRef(m_aModel,m_aModelMutex);
 513     m_aModel = aNewModelRef;
 514
 515     //--handle relations to the old model if any
 516     if( aOldModelRef.is() )
 517     {
 518         if( m_xChartView.is() )
 519             m_xChartView->removeModeChangeListener(this);
 520         m_pDrawModelWrapper.reset();
 521
 522         aOldModelRef->removeListener( this );
 523  #ifdef TEST_ENABLE_MODIFY_LISTENER
 524         if( aOldModelRef->getModel().is())
 525             aOldModelRef->getModel()->removeModifyListener( this );
 526 #endif
 527     }
 528
 529     //--handle relations to the new model
 530     aNewModelRef->addListener( this );
 531
 532     aGuard.reset(); // lock for m_aDispatchContainer access
 533     // set new model at dispatchers
 534     m_aDispatchContainer.setModel( aNewModelRef->getModel());
 535     rtl::Reference<ControllerCommandDispatch> pDispatch = new ControllerCommandDispatch( m_xCC, this, &m_aDispatchContainer );
 536     pDispatch->initialize();
 537
 538     // the dispatch container will return "this" for all commands returned by
 539     // impl_getAvailableCommands().  That means, for those commands dispatch()
 540     // is called here at the ChartController.
 541     m_aDispatchContainer.setChartDispatch( pDispatch, impl_getAvailableCommands() );
 542
 543     rtl::Reference<DrawCommandDispatch> pDrawDispatch = new DrawCommandDispatch( m_xCC, this );
 544     pDrawDispatch->initialize();
 545     m_aDispatchContainer.setDrawCommandDispatch( pDrawDispatch.get() );
 546
 547     rtl::Reference<ShapeController> pShapeController = new ShapeController( m_xCC, this );
 548     pShapeController->initialize();
 549     m_aDispatchContainer.setShapeController( pShapeController.get() );
 550     aGuard.clear();
 551
 552 #ifdef TEST_ENABLE_MODIFY_LISTENER
 553     if( aNewModelRef->getModel().is())
 554         aNewModelRef->getModel()->addModifyListener( this );
 555 #endif
 556
 557     // #i119999# Do not do this per default to allow the user to deselect the chart OLE with a single press to ESC
 558     // select chart area per default:
 559     // select( uno::Any( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_PAGE, OUString() ) ) );
 560
 561     rtl::Reference< ChartModel > xFact = getChartModel();
 562     if( xFact.is())
 563     {
 564         m_xChartView = dynamic_cast<::chart::ChartView*>(xFact->createInstance( CHART_VIEW_SERVICE_NAME ).get());
 565         GetDrawModelWrapper();
 566         m_xChartView->addModeChangeListener(this);
 567     }
 568
 569     //the frameloader is responsible to call xModel->connectController
 570     {
 571         SolarMutexGuard aGuard2;
 572         auto pChartWindow(GetChartWindow());
 573         if( pChartWindow )
 574             pChartWindow->Invalidate();
 575     }
 576
 577     m_xUndoManager.set( getChartModel()->getUndoManager(), uno::UNO_SET_THROW );
 578
 579     return true;
 580 }
 581
 582 uno::Reference< frame::XFrame > SAL_CALL ChartController::getFrame()
 583 {
 584     //provides access to owner frame of this controller
 585     //return the frame containing this controller
 586
 587     return m_xFrame;
 588 }
 589
 590 uno::Reference< frame::XModel > SAL_CALL ChartController::getModel()
 591 {
 592     return getChartModel();
 593 }
 594
 595 rtl::Reference<::chart::ChartModel> ChartController::getChartModel()
 596 {
 597     //provides access to currently attached model
 598     //returns the currently attached model
 599
 600     //return nothing, if you do not have a model
 601     TheModelRef aModelRef( m_aModel, m_aModelMutex);
 602     if(aModelRef.is())
 603         return aModelRef->getModel();
 604
 605     return nullptr;
 606 }
 607
 608 rtl::Reference<::chart::Diagram> ChartController::getFirstDiagram()
 609 {
 610     return getChartModel()->getFirstChartDiagram();
 611 }
 612
 613 uno::Any SAL_CALL ChartController::getViewData()
 614 {
 615     //provides access to current view status
 616     //set of data that can be used to restore the current view status at later time
 617     //  by using XController::restoreViewData()
 618
 619     SolarMutexGuard aGuard;
 620     if( impl_isDisposedOrSuspended() )
 621         return uno::Any(); //behave passive if already disposed or suspended //@todo? or throw an exception??
 622
 623     //-- collect current view state
 624     uno::Any aRet;
 625     //// @todo integrate specialized implementation
 626
 627     return aRet;
 628 }
 629
 630 void SAL_CALL ChartController::restoreViewData(
 631     const uno::Any& /* Value */ )
 632 {
 633     //restores the view status using the data gotten from a previous call to XController::getViewData()
 634
 635     SolarMutexGuard aGuard;
 636     if( impl_isDisposedOrSuspended() )
 637         return; //behave passive if already disposed or suspended //@todo? or throw an exception??
 638
 639     //// @todo integrate specialized implementation
 640 }
 641
 642 sal_Bool SAL_CALL ChartController::suspend( sal_Bool bSuspend )
 643 {
 644     //is called to prepare the controller for closing the view
 645     //bSuspend==true: force the controller to suspend his work
 646     //bSuspend==false try to reactivate the controller
 647     //returns true if request was accepted and of course successfully finished, false otherwise
 648
 649     //we may show dialogs here to ask the user for saving changes ... @todo?
 650
 651     SolarMutexGuard aGuard;
 652     if( m_aLifeTimeManager.impl_isDisposed() )
 653         return false; //behave passive if already disposed, return false because request was not accepted //@todo? correct
 654
 655     if(bool(bSuspend) == m_bSuspended)
 656     {
 657         OSL_FAIL( "new suspend mode equals old suspend mode" );
 658         return true;
 659     }
 660
 661     //change suspend mode
 662     m_bSuspended = bSuspend;
 663     return true;
 664 }
 665
 666 // css::frame::XController2
 667
 668 css::uno::Reference<css::awt::XWindow> SAL_CALL ChartController::getComponentWindow()
 669 {
 670     // it is a special characteristic of ChartController
 671     // that it simultaneously provides the XWindow functionality
 672     return this;
 673 }
 674
 675 OUString SAL_CALL ChartController::getViewControllerName() { return {}; }
 676
 677 css::uno::Sequence<css::beans::PropertyValue> SAL_CALL ChartController::getCreationArguments()
 678 {
 679     return {};
 680 }
 681
 682 css::uno::Reference<css::ui::XSidebarProvider> SAL_CALL ChartController::getSidebar() { return {}; }
 683
 684 void ChartController::impl_createDrawViewController()
 685 {
 686     SolarMutexGuard aGuard;
 687     if(!m_pDrawViewWrapper)
 688     {
 689         if( m_pDrawModelWrapper )
 690         {
 691             bool bLokCalcGlobalRTL = false;
 692             if(comphelper::LibreOfficeKit::isActive() && AllSettings::GetLayoutRTL())
 693             {
 694                 rtl::Reference< ChartModel > xChartModel = getChartModel();
 695                 if (xChartModel.is())
 696                 {
 697                     uno::Reference<css::sheet::XSpreadsheetDocument> xSSDoc(xChartModel->getParent(), uno::UNO_QUERY);
 698                     if (xSSDoc.is())
 699                         bLokCalcGlobalRTL = true;
 700                 }
 701             }
 702
 703             m_pDrawViewWrapper.reset( new DrawViewWrapper(m_pDrawModelWrapper->getSdrModel(),GetChartWindow()->GetOutDev()) );
 704             m_pDrawViewWrapper->SetNegativeX(bLokCalcGlobalRTL);
 705             m_pDrawViewWrapper->attachParentReferenceDevice( getChartModel() );
 706         }
 707     }
 708 }
 709
 710 void ChartController::impl_deleteDrawViewController()
 711 {
 712     if( m_pDrawViewWrapper )
 713     {
 714         SolarMutexGuard aGuard;
 715         if( m_pDrawViewWrapper->IsTextEdit() )
 716             this->EndTextEdit();
 717         m_pDrawViewWrapper.reset();
 718     }
 719 }
 720
 721 // XComponent (base of XController)
 722
 723 void SAL_CALL ChartController::dispose()
 724 {
 725     m_bDisposed = true;
 726
 727     mpSelectionChangeHandler->selectionChanged(css::lang::EventObject());
 728     mpSelectionChangeHandler->Disconnect();
 729
 730     if (getModel().is())
 731     {
 732         uno::Reference<ui::XSidebar> xSidebar = getSidebarFromModel(getChartModel());
 733         if (sfx2::sidebar::SidebarController* pSidebar = dynamic_cast<sfx2::sidebar::SidebarController*>(xSidebar.get()))
 734         {
 735             pSidebar->unregisterSidebarForFrame(this);
 736         }
 737     }
 738
 739     try
 740     {
 741         //This object should release all resources and references in the
 742         //easiest possible manner
 743         //This object must notify all registered listeners using the method
 744         //<member>XEventListener::disposing</member>
 745
 746         //hold no mutex
 747         if( !m_aLifeTimeManager.dispose() )
 748             return;
 749
 750 //  OSL_ENSURE( m_bSuspended, "dispose was called but controller is not suspended" );
 751
 752         this->stopDoubleClickWaiting();
 753
 754         //end range highlighting
 755         if( m_aModel.is())
 756         {
 757             uno::Reference< view::XSelectionChangeListener > xSelectionChangeListener;
 758             rtl::Reference< ChartModel > xDataReceiver = getChartModel();
 759             if( xDataReceiver.is() )
 760                 xSelectionChangeListener.set( xDataReceiver->getRangeHighlighter(), uno::UNO_QUERY );
 761             if( xSelectionChangeListener.is() )
 762             {
 763                 uno::Reference< frame::XController > xController( this );
 764                 lang::EventObject aEvent( xController );
 765                 xSelectionChangeListener->disposing( aEvent );
 766             }
 767         }
 768
 769         //--release all resources and references
 770         {
 771             if( m_xChartView.is() )
 772                 m_xChartView->removeModeChangeListener(this);
 773
 774             impl_invalidateAccessible();
 775             SolarMutexGuard aSolarGuard;
 776             impl_deleteDrawViewController();
 777             m_pDrawModelWrapper.reset();
 778
 779             m_apDropTargetHelper.reset();
 780
 781             //the accessible view is disposed within window destructor of m_pChartWindow
 782             if(m_xViewWindow.is())
 783                 m_xViewWindow->dispose(); //ChartWindow is deleted via UNO due to dispose of m_xViewWindow (triggered by Framework (Controller pretends to be XWindow also))
 784             m_xChartView.clear();
 785         }
 786
 787         // remove as listener to layout manager events
 788         if( m_xLayoutManagerEventBroadcaster.is())
 789         {
 790             m_xLayoutManagerEventBroadcaster->removeLayoutManagerEventListener( this );
 791             m_xLayoutManagerEventBroadcaster.clear();
 792         }
 793
 794         m_xFrame.clear();
 795         m_xUndoManager.clear();
 796
 797         TheModelRef aModelRef( m_aModel, m_aModelMutex);
 798         m_aModel = nullptr;
 799
 800         if( aModelRef.is())
 801         {
 802             uno::Reference< frame::XModel > xModel( aModelRef->getModel() );
 803             if(xModel.is())
 804                 xModel->disconnectController( uno::Reference< frame::XController >( this ));
 805
 806             aModelRef->removeListener( this );
 807 #ifdef TEST_ENABLE_MODIFY_LISTENER
 808             try
 809             {
 810                 if( aModelRef->getModel().is())
 811                     aModelRef->getModel()->removeModifyListener( this );
 812             }
 813             catch( const uno::Exception & )
 814             {
 815                 DBG_UNHANDLED_EXCEPTION("chart2");
 816             }
 817 #endif
 818             aModelRef->tryTermination();
 819         }
 820
 821         //// @todo integrate specialized implementation
 822         //e.g. release further resources and references
 823
 824         SolarMutexGuard g;
 825         m_aDispatchContainer.DisposeAndClear();
 826     }
 827     catch( const uno::Exception & )
 828     {
 829         DBG_UNHANDLED_EXCEPTION("chart2");
 830         assert(!m_xChartView.is());
 831     }
 832  }
 833
 834 void SAL_CALL ChartController::addEventListener(
 835     const uno::Reference<lang::XEventListener>& xListener )
 836 {
 837     if( impl_isDisposedOrSuspended() )//@todo? allow adding of listeners in suspend mode?
 838         return; //behave passive if already disposed or suspended
 839
 840     //--add listener
 841     std::unique_lock aGuard2(m_aLifeTimeManager.m_aAccessMutex);
 842     m_aLifeTimeManager.m_aEventListeners.addInterface( aGuard2, xListener );
 843 }
 844
 845 void SAL_CALL ChartController::removeEventListener(
 846     const uno::Reference<lang::XEventListener>& xListener )
 847 {
 848     SolarMutexGuard aGuard;
 849     if( m_aLifeTimeManager.impl_isDisposed(false) )
 850         return; //behave passive if already disposed or suspended
 851
 852     //--remove listener
 853     std::unique_lock aGuard2(m_aLifeTimeManager.m_aAccessMutex);
 854     m_aLifeTimeManager.m_aEventListeners.removeInterface( aGuard2, xListener );
 855 }
 856
 857 // util::XCloseListener
 858 void SAL_CALL ChartController::queryClosing(
 859     const lang::EventObject& rSource,
 860     sal_Bool /*bGetsOwnership*/ )
 861 {
 862     //do not use the m_aControllerMutex here because this call is not allowed to block
 863
 864     TheModelRef aModelRef( m_aModel, m_aModelMutex);
 865
 866     if( !aModelRef.is() )
 867         return;
 868
 869     if( uno::Reference<XInterface>(static_cast<cppu::OWeakObject*>(aModelRef->getModel().get())) != rSource.Source )
 870     {
 871         OSL_FAIL( "queryClosing was called on a controller from an unknown source" );
 872         return;
 873     }
 874
 875     //@ todo prepare to closing model -> don't start any further hindering actions
 876 }
 877
 878 void SAL_CALL ChartController::notifyClosing(
 879     const lang::EventObject& rSource )
 880 {
 881     //Listener should deregister himself and release all references to the closing object.
 882
 883     TheModelRef aModelRef( m_aModel, m_aModelMutex);
 884     if( !impl_releaseThisModel( rSource.Source ) )
 885         return;
 886
 887     //--stop listening to the closing model
 888     aModelRef->removeListener( this );
 889
 890     // #i79087# If the model using this controller is closed, the frame is
 891     // expected to be closed as well
 892     Reference< util::XCloseable > xFrameCloseable( m_xFrame, uno::UNO_QUERY );
 893     if( xFrameCloseable.is())
 894     {
 895         try
 896         {
 897             xFrameCloseable->close( false /* DeliverOwnership */ );
 898             m_xFrame.clear();
 899         }
 900         catch( const util::CloseVetoException & )
 901         {
 902             // closing was vetoed
 903         }
 904     }
 905 }
 906
 907 bool ChartController::impl_releaseThisModel(
 908     const uno::Reference< uno::XInterface > & xModel )
 909 {
 910     bool bReleaseModel = false;
 911     {
 912         ::osl::Guard< ::osl::Mutex > aGuard( m_aModelMutex );
 913         if( m_aModel.is() && uno::Reference< uno::XInterface >(static_cast<cppu::OWeakObject*>(m_aModel->getModel().get())) == xModel )
 914         {
 915             m_aModel = nullptr;
 916             m_xUndoManager.clear();
 917             bReleaseModel = true;
 918         }
 919     }
 920     if( bReleaseModel )
 921     {
 922         SolarMutexGuard g;
 923         m_aDispatchContainer.setModel( nullptr );
 924     }
 925     return bReleaseModel;
 926 }
 927
 928 // util::XEventListener (base of XCloseListener)
 929 void SAL_CALL ChartController::disposing(
 930     const lang::EventObject& rSource )
 931 {
 932     if( !impl_releaseThisModel( rSource.Source ))
 933     {
 934         if( rSource.Source == m_xLayoutManagerEventBroadcaster )
 935             m_xLayoutManagerEventBroadcaster.clear();
 936     }
 937 }
 938
 939 void SAL_CALL ChartController::layoutEvent(
 940     const lang::EventObject& aSource,
 941     sal_Int16 eLayoutEvent,
 942     const uno::Any& /* aInfo */ )
 943 {
 944     if( eLayoutEvent == frame::LayoutManagerEvents::MERGEDMENUBAR )
 945     {
 946         Reference< frame::XLayoutManager > xLM( aSource.Source, uno::UNO_QUERY );
 947         if( xLM.is())
 948         {
 949             xLM->createElement(  u"private:resource/statusbar/statusbar"_ustr );
 950             xLM->requestElement( u"private:resource/statusbar/statusbar"_ustr );
 951         }
 952     }
 953 }
 954
 955 // XDispatchProvider (required interface)
 956
 957 namespace
 958 {
 959
 960 bool lcl_isFormatObjectCommand( std::u16string_view aCommand )
 961 {
 962     return aCommand == u"MainTitle"
 963         || aCommand == u"SubTitle"
 964         || aCommand == u"XTitle"
 965         || aCommand == u"YTitle"
 966         || aCommand == u"ZTitle"
 967         || aCommand == u"SecondaryXTitle"
 968         || aCommand == u"SecondaryYTitle"
 969         || aCommand == u"AllTitles"
 970         || aCommand == u"DiagramAxisX"
 971         || aCommand == u"DiagramAxisY"
 972         || aCommand == u"DiagramAxisZ"
 973         || aCommand == u"DiagramAxisA"
 974         || aCommand == u"DiagramAxisB"
 975         || aCommand == u"DiagramAxisAll"
 976         || aCommand == u"DiagramGridXMain"
 977         || aCommand == u"DiagramGridYMain"
 978         || aCommand == u"DiagramGridZMain"
 979         || aCommand == u"DiagramGridXHelp"
 980         || aCommand == u"DiagramGridYHelp"
 981         || aCommand == u"DiagramGridZHelp"
 982         || aCommand == u"DiagramGridAll"
 983
 984         || aCommand == u"DiagramWall"
 985         || aCommand == u"DiagramFloor"
 986         || aCommand == u"DiagramArea"
 987         || aCommand == u"Legend"
 988
 989         || aCommand == u"FormatWall"
 990         || aCommand == u"FormatFloor"
 991         || aCommand == u"FormatChartArea"
 992         || aCommand == u"FormatLegend"
 993
 994         || aCommand == u"FormatTitle"
 995         || aCommand == u"FormatAxis"
 996         || aCommand == u"FormatDataSeries"
 997         || aCommand == u"FormatDataPoint"
 998         || aCommand == u"FormatDataLabels"
 999         || aCommand == u"FormatDataLabel"
1000         || aCommand == u"FormatXErrorBars"
1001         || aCommand == u"FormatYErrorBars"
1002         || aCommand == u"FormatMeanValue"
1003         || aCommand == u"FormatTrendline"
1004         || aCommand == u"FormatTrendlineEquation"
1005         || aCommand == u"FormatStockLoss"
1006         || aCommand == u"FormatStockGain"
1007         || aCommand == u"FormatMajorGrid"
1008         || aCommand == u"FormatMinorGrid";
1009 }
1010
1011 } // anonymous namespace
1012
1013 uno::Reference<frame::XDispatch> SAL_CALL
1014     ChartController::queryDispatch(
1015         const util::URL& rURL,
1016         const OUString& rTargetFrameName,
1017         sal_Int32 /* nSearchFlags */)
1018 {
1019     SolarMutexGuard aGuard;
1020
1021     if ( !m_aLifeTimeManager.impl_isDisposed() && getModel().is() )
1022     {
1023         if( !rTargetFrameName.isEmpty() && rTargetFrameName == "_self" )
1024             return m_aDispatchContainer.getDispatchForURL( rURL );
1025     }
1026     return uno::Reference< frame::XDispatch > ();
1027 }
1028
1029 uno::Sequence<uno::Reference<frame::XDispatch > >
1030     ChartController::queryDispatches(
1031         const uno::Sequence<frame::DispatchDescriptor>& xDescripts )
1032 {
1033     SolarMutexGuard g;
1034
1035     if ( !m_aLifeTimeManager.impl_isDisposed() )
1036     {
1037         return m_aDispatchContainer.getDispatchesForURLs( xDescripts );
1038     }
1039     return uno::Sequence<uno::Reference<frame::XDispatch > > ();
1040 }
1041
1042 // frame::XDispatch
1043
1044 void SAL_CALL ChartController::dispatch(
1045     const util::URL& rURL,
1046     const uno::Sequence< beans::PropertyValue >& rArgs )
1047 {
1048     OUString aCommand = rURL.Path;
1049
1050     if(aCommand == "LOKSetTextSelection")
1051     {
1052         if (rArgs.getLength() == 3)
1053         {
1054             sal_Int32 nType = -1;
1055             rArgs[0].Value >>= nType;
1056             sal_Int32 nX = 0;
1057             rArgs[1].Value >>= nX;
1058             sal_Int32 nY = 0;
1059             rArgs[2].Value >>= nY;
1060             executeDispatch_LOKSetTextSelection(nType, nX, nY);
1061         }
1062     }
1063     else if (aCommand == "LOKTransform")
1064     {
1065         if (rArgs[0].Name == "Action")
1066         {
1067             OUString sAction;
1068             if ((rArgs[0].Value >>= sAction) && sAction == "PieSegmentDragging")
1069             {
1070                 if (rArgs[1].Name == "Offset")
1071                 {
1072                     sal_Int32 nOffset;
1073                     if (rArgs[1].Value >>= nOffset)
1074                     {
1075                         this->executeDispatch_LOKPieSegmentDragging(nOffset);
1076                     }
1077                 }
1078             }
1079         }
1080         else
1081         {
1082             this->executeDispatch_PositionAndSize(&rArgs);
1083         }
1084     }
1085     else if(aCommand == "FillColor")
1086     {
1087         if (rArgs.getLength() > 0)
1088         {
1089             sal_uInt32 nColor;
1090             if (rArgs[0].Value >>= nColor)
1091                 this->executeDispatch_FillColor(nColor);
1092         }
1093     }
1094     else if(aCommand == "XLineColor")
1095     {
1096         if (rArgs.getLength() > 0)
1097         {
1098             sal_Int32 nColor = -1;
1099             rArgs[0].Value >>= nColor;
1100             this->executeDispatch_LineColor(nColor);
1101         }
1102     }
1103     else if(aCommand == "LineWidth")
1104     {
1105         if (rArgs.getLength() > 0)
1106         {
1107             sal_Int32 nWidth = -1;
1108             rArgs[0].Value >>= nWidth;
1109             this->executeDispatch_LineWidth(nWidth);
1110         }
1111     }
1112     else if(aCommand.startsWith("FillGradient"))
1113     {
1114         this->executeDispatch_FillGradient(aCommand.subView(aCommand.indexOf('=') + 1));
1115     }
1116     else if(aCommand == "Paste")
1117         this->executeDispatch_Paste();
1118     else if(aCommand == "Copy" )
1119         this->executeDispatch_Copy();
1120     else if(aCommand == "Cut" )
1121         this->executeDispatch_Cut();
1122     else if(aCommand == "DataRanges" )
1123         this->executeDispatch_SourceData();
1124     else if(aCommand == "Update" ) //Update Chart
1125     {
1126         ChartViewHelper::setViewToDirtyState( getChartModel() );
1127         SolarMutexGuard aGuard;
1128         auto pChartWindow(GetChartWindow());
1129         if( pChartWindow )
1130             pChartWindow->Invalidate();
1131     }
1132     else if(aCommand == "DiagramData" )
1133         this->executeDispatch_EditData();
1134     //insert objects
1135     else if( aCommand == "InsertTitles"
1136         || aCommand == "InsertMenuTitles")
1137         this->executeDispatch_InsertTitles();
1138     else if( aCommand == "InsertMenuLegend" )
1139         this->executeDispatch_OpenLegendDialog();
1140     else if( aCommand == "InsertLegend" )
1141         this->executeDispatch_InsertLegend();
1142     else if( aCommand == "DeleteLegend" )
1143         this->executeDispatch_DeleteLegend();
1144     else if( aCommand == "InsertMenuDataLabels" )
1145         this->executeDispatch_InsertMenu_DataLabels();
1146     else if( aCommand == "InsertMenuAxes"
1147         || aCommand == "InsertRemoveAxes" )
1148         this->executeDispatch_InsertAxes();
1149     else if( aCommand == "InsertMenuGrids" )
1150         this->executeDispatch_InsertGrid();
1151     else if( aCommand == "InsertMenuTrendlines" )
1152         this->executeDispatch_InsertMenu_Trendlines();
1153     else if( aCommand == "InsertMenuMeanValues" )
1154         this->executeDispatch_InsertMenu_MeanValues();
1155     else if( aCommand == "InsertMenuXErrorBars" )
1156         this->executeDispatch_InsertErrorBars(false);
1157     else if( aCommand == "InsertMenuYErrorBars" )
1158         this->executeDispatch_InsertErrorBars(true);
1159     else if( aCommand == "InsertMenuDataTable" )
1160         this->executeDispatch_OpenInsertDataTableDialog();
1161     else if( aCommand == "InsertSymbol" )
1162          this->executeDispatch_InsertSpecialCharacter();
1163     else if( aCommand == "InsertTrendline" )
1164          this->executeDispatch_InsertTrendline();
1165     else if( aCommand == "DeleteTrendline" )
1166          this->executeDispatch_DeleteTrendline();
1167     else if( aCommand == "InsertMeanValue" )
1168         this->executeDispatch_InsertMeanValue();
1169     else if( aCommand == "DeleteMeanValue" )
1170         this->executeDispatch_DeleteMeanValue();
1171     else if( aCommand == "InsertXErrorBars" )
1172         this->executeDispatch_InsertErrorBars(false);
1173     else if( aCommand == "InsertYErrorBars" )
1174         this->executeDispatch_InsertErrorBars(true);
1175     else if( aCommand == "DeleteXErrorBars" )
1176         this->executeDispatch_DeleteErrorBars(false);
1177     else if( aCommand == "DeleteYErrorBars" )
1178         this->executeDispatch_DeleteErrorBars(true);
1179     else if( aCommand == "InsertTrendlineEquation" )
1180          this->executeDispatch_InsertTrendlineEquation();
1181     else if( aCommand == "DeleteTrendlineEquation" )
1182          this->executeDispatch_DeleteTrendlineEquation();
1183     else if( aCommand == "InsertTrendlineEquationAndR2" )
1184          this->executeDispatch_InsertTrendlineEquation( true );
1185     else if( aCommand == "InsertR2Value" )
1186          this->executeDispatch_InsertR2Value();
1187     else if( aCommand == "DeleteR2Value")
1188          this->executeDispatch_DeleteR2Value();
1189     else if( aCommand == "InsertDataLabels" )
1190         this->executeDispatch_InsertDataLabels();
1191     else if( aCommand == "InsertDataLabel" )
1192         this->executeDispatch_InsertDataLabel();
1193     else if( aCommand == "DeleteDataLabels")
1194         this->executeDispatch_DeleteDataLabels();
1195     else if( aCommand == "DeleteDataLabel" )
1196         this->executeDispatch_DeleteDataLabel();
1197     else if( aCommand == "ResetAllDataPoints" )
1198         this->executeDispatch_ResetAllDataPoints();
1199     else if( aCommand == "ResetDataPoint" )
1200         this->executeDispatch_ResetDataPoint();
1201     else if( aCommand == "InsertAxis" )
1202         this->executeDispatch_InsertAxis();
1203     else if( aCommand == "InsertMajorGrid" )
1204         this->executeDispatch_InsertMajorGrid();
1205     else if( aCommand == "InsertMinorGrid" )
1206         this->executeDispatch_InsertMinorGrid();
1207     else if( aCommand == "InsertAxisTitle" )
1208         this->executeDispatch_InsertAxisTitle();
1209     else if( aCommand == "DeleteAxis" )
1210         this->executeDispatch_DeleteAxis();
1211     else if( aCommand == "DeleteMajorGrid")
1212         this->executeDispatch_DeleteMajorGrid();
1213     else if( aCommand == "DeleteMinorGrid" )
1214         this->executeDispatch_DeleteMinorGrid();
1215     else if( aCommand == "InsertDataTable" )
1216          this->executeDispatch_InsertDataTable();
1217     else if( aCommand == "DeleteDataTable" )
1218          this->executeDispatch_DeleteDataTable();
1219     //format objects
1220     else if( aCommand == "FormatSelection" )
1221         this->executeDispatch_ObjectProperties();
1222     else if( aCommand == "TransformDialog" )
1223     {
1224         if ( isShapeContext() )
1225         {
1226             this->impl_ShapeControllerDispatch( rURL, rArgs );
1227         }
1228         else
1229         {
1230             this->executeDispatch_PositionAndSize();
1231         }
1232     }
1233     else if ( aCommand == "FontDialog" )
1234         this->impl_ShapeControllerDispatch(rURL, rArgs);
1235     else if (lcl_isFormatObjectCommand(aCommand))
1236         this->executeDispatch_FormatObject(rURL.Path);
1237     //more format
1238     else if( aCommand == "DiagramType" )
1239         this->executeDispatch_ChartType();
1240     else if( aCommand == "View3D" )
1241         this->executeDispatch_View3D();
1242     else if ( aCommand == "Forward" )
1243     {
1244         if ( isShapeContext() )
1245         {
1246             this->impl_ShapeControllerDispatch( rURL, rArgs );
1247         }
1248         else
1249         {
1250             this->executeDispatch_MoveSeries( true );
1251         }
1252     }
1253     else if ( aCommand == "Backward" )
1254     {
1255         if ( isShapeContext() )
1256         {
1257             this->impl_ShapeControllerDispatch( rURL, rArgs );
1258         }
1259         else
1260         {
1261             this->executeDispatch_MoveSeries( false );
1262         }
1263     }
1264     else if( aCommand == "NewArrangement")
1265         this->executeDispatch_NewArrangement();
1266     else if( aCommand == "ToggleLegend" )
1267         this->executeDispatch_ToggleLegend();
1268     else if( aCommand == "ToggleGridHorizontal" )
1269         this->executeDispatch_ToggleGridHorizontal();
1270     else if( aCommand == "ToggleGridVertical" )
1271         this->executeDispatch_ToggleGridVertical();
1272     else if( aCommand == "ScaleText" )
1273         this->executeDispatch_ScaleText();
1274     else if( aCommand == "StatusBarVisible" )
1275     {
1276         // workaround: this should not be necessary.
1277         uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY );
1278         if( xPropSet.is() )
1279         {
1280             uno::Reference< css::frame::XLayoutManager > xLayoutManager;
1281             xPropSet->getPropertyValue( u"LayoutManager"_ustr ) >>= xLayoutManager;
1282             if ( xLayoutManager.is() )
1283             {
1284                 bool bIsVisible( xLayoutManager->isElementVisible( u"private:resource/statusbar/statusbar"_ustr ));
1285                 if( bIsVisible )
1286                 {
1287                     xLayoutManager->hideElement( u"private:resource/statusbar/statusbar"_ustr );
1288                     xLayoutManager->destroyElement( u"private:resource/statusbar/statusbar"_ustr );
1289                 }
1290                 else
1291                 {
1292                     xLayoutManager->createElement( u"private:resource/statusbar/statusbar"_ustr );
1293                     xLayoutManager->showElement( u"private:resource/statusbar/statusbar"_ustr );
1294                 }
1295                 // @todo: update menu state (checkmark next to "Statusbar").
1296             }
1297         }
1298     }
1299     else if( aCommand == "ChangeTheme" )
1300         comphelper::dispatchCommand(u".uno:ChangeTheme"_ustr, getFrame(), rArgs);
1301 }
1302
1303 void SAL_CALL ChartController::addStatusListener(
1304     const uno::Reference<frame::XStatusListener >& /* xControl */,
1305     const util::URL& /* aURL */ )
1306 {
1307     //@todo
1308 }
1309
1310 void SAL_CALL ChartController::removeStatusListener(
1311     const uno::Reference<frame::XStatusListener >& /* xControl */,
1312     const util::URL& /* aURL */ )
1313 {
1314     //@todo
1315 }
1316
1317 // XContextMenuInterception (optional interface)
1318 void SAL_CALL ChartController::registerContextMenuInterceptor(
1319     const uno::Reference< ui::XContextMenuInterceptor >& /* xInterceptor */)
1320 {
1321     //@todo
1322 }
1323
1324 void SAL_CALL ChartController::releaseContextMenuInterceptor(
1325     const uno::Reference< ui::XContextMenuInterceptor > & /* xInterceptor */)
1326 {
1327     //@todo
1328 }
1329
1330 // ____ XEmbeddedClient ____
1331 // implementation see: ChartController_EditData.cxx
1332
1333 void ChartController::executeDispatch_ChartType()
1334 {
1335     auto xUndoGuard = std::make_shared<UndoLiveUpdateGuard>(SchResId(STR_ACTION_EDIT_CHARTTYPE),
1336                                                             m_xUndoManager);
1337
1338     SolarMutexGuard aSolarGuard;
1339     //prepare and open dialog
1340     auto aDlg =  std::make_shared<ChartTypeDialog>(GetChartFrame(), getChartModel());
1341     weld::DialogController::runAsync(aDlg, [this, xUndoGuard=std::move(xUndoGuard)](int nResult) {
1342         if (nResult == RET_OK)
1343         {
1344             impl_adaptDataSeriesAutoResize();
1345             xUndoGuard->commit();
1346         }
1347     });
1348 }
1349
1350 void ChartController::executeDispatch_SourceData()
1351 {
1352     //convert properties to ItemSet
1353     rtl::Reference< ::chart::ChartModel >  xChartDoc = getChartModel();
1354     OSL_ENSURE( xChartDoc.is(), "Invalid XChartDocument" );
1355     if( !xChartDoc.is() )
1356         return;
1357
1358     // If there is a data table we should ask user if we really want to destroy it
1359     // and switch to data ranges.
1360     ChartModel& rModel = *xChartDoc;
1361     if ( rModel.hasInternalDataProvider() )
1362     {
1363         // Check if we will able to create data provider later
1364         css::uno::Reference< css::chart2::XDataProviderAccess > xCreatorDoc(
1365             rModel.getParent(), uno::UNO_QUERY);
1366         if (!xCreatorDoc.is())
1367             return;
1368
1369         SolarMutexGuard aSolarGuard;
1370
1371         std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(GetChartFrame(),
1372                                                        VclMessageType::Question, VclButtonsType::YesNo, SchResId(STR_DLG_REMOVE_DATA_TABLE)));
1373         // If "No" then just return
1374         if (xQueryBox->run() == RET_NO)
1375             return;
1376
1377         // Remove data table
1378         rModel.removeDataProviders();
1379
1380         // Ask parent document to create new data provider
1381
1382         uno::Reference< data::XDataProvider > xDataProvider = xCreatorDoc->createDataProvider();
1383         SAL_WARN_IF( !xDataProvider.is(), "chart2.main", "Data provider was not created" );
1384         if (xDataProvider.is())
1385         {
1386             rModel.attachDataProvider(xDataProvider);
1387         }
1388     }
1389     auto xUndoGuard = std::make_shared<UndoLiveUpdateGuard>(SchResId(STR_ACTION_EDIT_DATA_RANGES),
1390                                                             m_xUndoManager);
1391     SolarMutexGuard aSolarGuard;
1392     auto aDlg = std::make_shared<DataSourceDialog>(GetChartFrame(), xChartDoc);
1393     weld::DialogController::runAsync(aDlg, [this, xUndoGuard=std::move(xUndoGuard)](int nResult) {
1394         if (nResult == RET_OK)
1395         {
1396             impl_adaptDataSeriesAutoResize();
1397             xUndoGuard->commit();
1398         }
1399     });
1400 }
1401
1402 void ChartController::executeDispatch_MoveSeries( bool bForward )
1403 {
1404     ControllerLockGuardUNO aCLGuard( getChartModel() );
1405
1406     //get selected series
1407     OUString aObjectCID(m_aSelection.getSelectedCID());
1408     rtl::Reference< DataSeries > xGivenDataSeries = ObjectIdentifier::getDataSeriesForCID( //yyy todo also legend entries and labels?
1409             aObjectCID, getChartModel() );
1410
1411     UndoGuardWithSelection aUndoGuard(
1412         ActionDescriptionProvider::createDescription(
1413             (bForward ? ActionDescriptionProvider::ActionType::MoveToTop : ActionDescriptionProvider::ActionType::MoveToBottom),
1414             SchResId(STR_OBJECT_DATASERIES)),
1415         m_xUndoManager );
1416
1417     bool bChanged = getFirstDiagram()->moveSeries( xGivenDataSeries, bForward );
1418     if( bChanged )
1419     {
1420         m_aSelection.setSelection( ObjectIdentifier::getMovedSeriesCID( aObjectCID, bForward ) );
1421         aUndoGuard.commit();
1422     }
1423 }
1424
1425 // ____ XModifyListener ____
1426 void SAL_CALL ChartController::modified(
1427     const lang::EventObject& /* aEvent */ )
1428 {
1429     // the source can also be a subobject of the ChartModel
1430     // @todo: change the source in ChartModel to always be the model itself ?
1431     //todo? update menu states ?
1432 }
1433
1434 void ChartController::NotifyUndoActionHdl( std::unique_ptr<SdrUndoAction> pUndoAction )
1435 {
1436     ENSURE_OR_RETURN_VOID( pUndoAction, "invalid Undo action" );
1437
1438     OUString aObjectCID = m_aSelection.getSelectedCID();
1439     if ( !aObjectCID.isEmpty() )
1440         return;
1441
1442     try
1443     {
1444         rtl::Reference< ChartModel > xSuppUndo = getChartModel();
1445         const Reference< document::XUndoManager > xUndoManager( xSuppUndo->getUndoManager(), uno::UNO_SET_THROW );
1446         const Reference< document::XUndoAction > xAction( new impl::ShapeUndoElement( std::move(pUndoAction) ) );
1447         xUndoManager->addUndoAction( xAction );
1448     }
1449     catch( const uno::Exception& )
1450     {
1451         DBG_UNHANDLED_EXCEPTION("chart2");
1452     }
1453 }
1454
1455 DrawModelWrapper* ChartController::GetDrawModelWrapper()
1456 {
1457     if( !m_pDrawModelWrapper )
1458     {
1459         if( m_xChartView )
1460             m_pDrawModelWrapper = m_xChartView->getDrawModelWrapper();
1461         if ( m_pDrawModelWrapper )
1462         {
1463             m_pDrawModelWrapper->getSdrModel().SetNotifyUndoActionHdl(
1464                 std::bind(&ChartController::NotifyUndoActionHdl, this, std::placeholders::_1) );
1465         }
1466     }
1467     return m_pDrawModelWrapper.get();
1468 }
1469
1470 DrawViewWrapper* ChartController::GetDrawViewWrapper()
1471 {
1472     if ( !m_pDrawViewWrapper )
1473     {
1474         impl_createDrawViewController();
1475     }
1476     return m_pDrawViewWrapper.get();
1477 }
1478
1479
1480 ChartWindow* ChartController::GetChartWindow() const
1481 {
1482     // clients getting the naked VCL Window from UNO should always have the
1483     // solar mutex (and keep it over the lifetime of this ptr), as VCL might
1484     // might deinit otherwise
1485     DBG_TESTSOLARMUTEX();
1486     if(!m_xViewWindow.is())
1487         return nullptr;
1488     return dynamic_cast<ChartWindow*>(VCLUnoHelper::GetWindow(m_xViewWindow));
1489 }
1490
1491 weld::Window* ChartController::GetChartFrame()
1492 {
1493     // clients getting the naked VCL Window from UNO should always have the
1494     // solar mutex (and keep it over the lifetime of this ptr), as VCL might
1495     // might deinit otherwise
1496     DBG_TESTSOLARMUTEX();
1497     return Application::GetFrameWeld(m_xViewWindow);
1498 }
1499
1500 bool ChartController::isAdditionalShapeSelected() const
1501 {
1502     return m_aSelection.isAdditionalShapeSelected();
1503 }
1504
1505 void ChartController::SetAndApplySelection(const Reference<drawing::XShape>& rxShape)
1506 {
1507     if(rxShape.is())
1508     {
1509         m_aSelection.setSelection(rxShape);
1510         m_aSelection.applySelection(GetDrawViewWrapper());
1511     }
1512 }
1513
1514
1515
1516 uno::Reference< XAccessible > ChartController::CreateAccessible()
1517 {
1518 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1519     rtl::Reference< AccessibleChartView > xResult = new AccessibleChartView( GetDrawViewWrapper() );
1520     impl_initializeAccessible( *xResult );
1521     return xResult;
1522 #else
1523     return uno::Reference< XAccessible >();
1524 #endif
1525 }
1526
1527 void ChartController::impl_invalidateAccessible()
1528 {
1529 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1530     SolarMutexGuard aGuard;
1531     auto pChartWindow(GetChartWindow());
1532     if( pChartWindow )
1533     {
1534         Reference< XInterface > xInit( pChartWindow->GetAccessible(false) );
1535         if(xInit.is())
1536         {
1537             //empty arguments -> invalid accessible
1538             dynamic_cast<AccessibleChartView&>(*xInit).initialize();
1539         }
1540     }
1541 #endif
1542 }
1543 void ChartController::impl_initializeAccessible()
1544 {
1545 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1546     SolarMutexGuard aGuard;
1547     auto pChartWindow(GetChartWindow());
1548     if( !pChartWindow )
1549         return;
1550     Reference<XAccessible> xInit = pChartWindow->GetAccessible(false);
1551     if(xInit.is())
1552         impl_initializeAccessible( dynamic_cast<AccessibleChartView&>(*xInit) );
1553 #endif
1554 }
1555 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1556 void ChartController::impl_initializeAccessible( AccessibleChartView& rAccChartView )
1557 {
1558     uno::Reference< XAccessible > xParent;
1559     {
1560         SolarMutexGuard aGuard;
1561         auto pChartWindow(GetChartWindow());
1562         if( pChartWindow )
1563         {
1564             vcl::Window* pParentWin( pChartWindow->GetAccessibleParentWindow());
1565             if( pParentWin )
1566                 xParent.set( pParentWin->GetAccessible());
1567         }
1568     }
1569
1570     rAccChartView.initialize(*this, getChartModel(), m_xChartView, xParent, m_xViewWindow);
1571 }
1572 #else
1573 void ChartController::impl_initializeAccessible( AccessibleChartView& /* rAccChartView */) {}
1574 #endif
1575
1576 const o3tl::sorted_vector< std::u16string_view >& ChartController::impl_getAvailableCommands()
1577 {
1578     static const o3tl::sorted_vector< std::u16string_view > s_AvailableCommands {
1579         // commands for container forward
1580         u"AddDirect",           u"NewDoc",                u"Open",
1581         u"Save",                u"SaveAs",                u"SendMail",
1582         u"EditDoc",             u"ExportDirectToPDF",     u"PrintDefault",
1583
1584         // own commands
1585         u"Cut",                u"Copy",                 u"Paste",
1586         u"DataRanges",         u"DiagramData",
1587         // insert objects
1588         u"InsertMenuTitles",   u"InsertTitles",
1589         u"InsertMenuLegend",   u"InsertLegend",         u"DeleteLegend",
1590         u"InsertMenuDataLabels",
1591         u"InsertMenuAxes",     u"InsertRemoveAxes",         u"InsertMenuGrids",
1592         u"InsertSymbol",
1593         u"InsertTrendlineEquation",  u"InsertTrendlineEquationAndR2",
1594         u"InsertR2Value",      u"DeleteR2Value",
1595         u"InsertMenuTrendlines",  u"InsertTrendline",
1596         u"InsertMenuMeanValues", u"InsertMeanValue",
1597         u"InsertMenuXErrorBars",  u"InsertXErrorBars",
1598         u"InsertMenuYErrorBars",   u"InsertYErrorBars",
1599         u"InsertDataLabels",   u"InsertDataLabel",
1600         u"DeleteTrendline",    u"DeleteMeanValue",      u"DeleteTrendlineEquation",
1601         u"DeleteXErrorBars",   u"DeleteYErrorBars",
1602         u"DeleteDataLabels",   u"DeleteDataLabel",
1603         u"InsertMenuDataTable",
1604         u"InsertDataTable", u"DeleteDataTable",
1605         //format objects
1606         u"FormatSelection",    u"FontDialog",           u"TransformDialog",
1607         u"DiagramType",        u"View3D",
1608         u"Forward",            u"Backward",
1609         u"MainTitle",          u"SubTitle",
1610         u"XTitle",             u"YTitle",               u"ZTitle",
1611         u"SecondaryXTitle",    u"SecondaryYTitle",
1612         u"AllTitles",          u"Legend",
1613         u"DiagramAxisX",       u"DiagramAxisY",         u"DiagramAxisZ",
1614         u"DiagramAxisA",       u"DiagramAxisB",         u"DiagramAxisAll",
1615         u"DiagramGridXMain",   u"DiagramGridYMain",     u"DiagramGridZMain",
1616         u"DiagramGridXHelp",   u"DiagramGridYHelp",     u"DiagramGridZHelp",
1617         u"DiagramGridAll",
1618         u"DiagramWall",        u"DiagramFloor",         u"DiagramArea",
1619
1620         //context menu - format objects entries
1621         u"FormatWall",        u"FormatFloor",         u"FormatChartArea",
1622         u"FormatLegend",
1623
1624         u"FormatAxis",           u"FormatTitle",
1625         u"FormatDataSeries",     u"FormatDataPoint",
1626         u"ResetAllDataPoints",   u"ResetDataPoint",
1627         u"FormatDataLabels",     u"FormatDataLabel",
1628         u"FormatMeanValue",      u"FormatTrendline",      u"FormatTrendlineEquation",
1629         u"FormatXErrorBars",     u"FormatYErrorBars",
1630         u"FormatStockLoss",      u"FormatStockGain",
1631
1632         u"FormatMajorGrid",      u"InsertMajorGrid",      u"DeleteMajorGrid",
1633         u"FormatMinorGrid",      u"InsertMinorGrid",      u"DeleteMinorGrid",
1634         u"InsertAxis",           u"DeleteAxis",           u"InsertAxisTitle",
1635
1636         // toolbar commands
1637         u"ToggleGridHorizontal", u"ToggleGridVertical", u"ToggleLegend",         u"ScaleText",
1638         u"NewArrangement",     u"Update",
1639         u"DefaultColors",      u"BarWidth",             u"NumberOfLines",
1640         u"ArrangeRow",
1641         u"StatusBarVisible",
1642         u"ChartElementSelector"};
1643     return s_AvailableCommands;
1644 }
1645
1646 ViewElementListProvider ChartController::getViewElementListProvider()
1647 {
1648     return ViewElementListProvider(m_pDrawModelWrapper.get());
1649 }
1650
1651 } //namespace chart
1652
1653 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */