?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 6.4.0.0.beta1, tag libreoffice-6.4.0.0.beta1
[LibreOffice.git] / chart2 / source / controller / main / ChartController_Window.cxx
blob83411df39171c18a6c7156e9fdbb119c9518792d
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 <PositionAndSizeHelper.hxx>
22 #include <ObjectIdentifier.hxx>
23 #include <ChartWindow.hxx>
24 #include <ResId.hxx>
25 #include <ChartModel.hxx>
26 #include <ChartModelHelper.hxx>
27 #include <DiagramHelper.hxx>
28 #include <TitleHelper.hxx>
29 #include "UndoGuard.hxx"
30 #include <ControllerLockGuard.hxx>
31 #include <ObjectNameProvider.hxx>
32 #include <strings.hrc>
33 #include "DragMethod_PieSegment.hxx"
34 #include "DragMethod_RotateDiagram.hxx"
35 #include <ObjectHierarchy.hxx>
36 #include <chartview/ExplicitValueProvider.hxx>
37 #include <RelativePositionHelper.hxx>
38 #include <chartview/DrawModelWrapper.hxx>
39 #include <RegressionCurveHelper.hxx>
40 #include <StatisticsHelper.hxx>
41 #include <DataSeriesHelper.hxx>
42 #include <AxisHelper.hxx>
43 #include <LegendHelper.hxx>
44 #include <servicenames_charttypes.hxx>
45 #include "DrawCommandDispatch.hxx"
46 #include <PopupRequest.hxx>
47
48 #include <com/sun/star/chart2/RelativePosition.hpp>
49 #include <com/sun/star/chart2/RelativeSize.hpp>
50 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
51 #include <com/sun/star/chart2/data/XPivotTableDataProvider.hpp>
52 #include <com/sun/star/chart2/XChartDocument.hpp>
53
54 #include <com/sun/star/awt/PopupMenuDirection.hpp>
55 #include <com/sun/star/frame/DispatchHelper.hpp>
56 #include <com/sun/star/frame/FrameSearchFlag.hpp>
57 #include <com/sun/star/frame/XPopupMenuController.hpp>
58 #include <com/sun/star/util/XUpdatable.hpp>
59 #include <com/sun/star/awt/Rectangle.hpp>
60 #include <com/sun/star/qa/XDumper.hpp>
61
62 #include <comphelper/lok.hxx>
63 #include <comphelper/propertysequence.hxx>
64 #include <comphelper/propertyvalue.hxx>
65 #include <comphelper/sequence.hxx>
66
67 #include <toolkit/awt/vclxmenu.hxx>
68
69 #include <sfx2/viewsh.hxx>
70 #include <sfx2/ipclient.hxx>
71 #include <svx/ActionDescriptionProvider.hxx>
72 #include <svx/obj3d.hxx>
73 #include <svx/scene3d.hxx>
74 #include <svx/svddrgmt.hxx>
75 #include <vcl/commandevent.hxx>
76 #include <vcl/event.hxx>
77 #include <vcl/svapp.hxx>
78 #include <vcl/settings.hxx>
79 #include <vcl/weld.hxx>
80 #include <vcl/ptrstyle.hxx>
81 #include <svtools/acceleratorexecute.hxx>
82 #include <tools/diagnose_ex.h>
83 #include <sal/log.hxx>
84
85 #include <sfx2/lokhelper.hxx>
86
87 #define DRGPIX 2 // Drag MinMove in Pixel
88
89 using namespace ::com::sun::star;
90 using namespace ::com::sun::star::chart2;
91 using ::com::sun::star::uno::Reference;
92
93 namespace chart
94 {
95
96 namespace
97 {
98 bool lcl_GrowAndShiftLogic(
99 RelativePosition & rInOutRelPos,
100 RelativeSize & rInOutRelSize,
101 const awt::Size & rRefSize,
102 double fGrowLogicX,
103 double fGrowLogicY )
104 {
105 if( rRefSize.Width == 0 ||
106 rRefSize.Height == 0 )
107 return false;
108
109 double fRelativeGrowX = fGrowLogicX / rRefSize.Width;
110 double fRelativeGrowY = fGrowLogicY / rRefSize.Height;
111
112 return ::chart::RelativePositionHelper::centerGrow(
113 rInOutRelPos, rInOutRelSize,
114 fRelativeGrowX, fRelativeGrowY );
115 }
116
117 bool lcl_MoveObjectLogic(
118 RelativePosition & rInOutRelPos,
119 RelativeSize const & rObjectSize,
120 const awt::Size & rRefSize,
121 double fShiftLogicX,
122 double fShiftLogicY )
123 {
124 if( rRefSize.Width == 0 ||
125 rRefSize.Height == 0 )
126 return false;
127
128 double fRelativeShiftX = fShiftLogicX / rRefSize.Width;
129 double fRelativeShiftY = fShiftLogicY / rRefSize.Height;
130
131 return ::chart::RelativePositionHelper::moveObject(
132 rInOutRelPos, rObjectSize,
133 fRelativeShiftX, fRelativeShiftY );
134 }
135
136 void lcl_insertMenuCommand(
137 const uno::Reference< awt::XPopupMenu > & xMenu,
138 sal_Int16 nId, const OUString & rCommand )
139 {
140 xMenu->insertItem( nId, "", 0, -1 );
141 xMenu->setCommand( nId, rCommand );
142 }
143
144 OUString lcl_getFormatCommandForObjectCID( const OUString& rCID )
145 {
146 OUString aDispatchCommand( ".uno:FormatSelection" );
147
148 ObjectType eObjectType = ObjectIdentifier::getObjectType( rCID );
149
150 switch(eObjectType)
151 {
152 case OBJECTTYPE_DIAGRAM:
153 case OBJECTTYPE_DIAGRAM_WALL:
154 aDispatchCommand = ".uno:FormatWall";
155 break;
156 case OBJECTTYPE_DIAGRAM_FLOOR:
157 aDispatchCommand = ".uno:FormatFloor";
158 break;
159 case OBJECTTYPE_PAGE:
160 aDispatchCommand = ".uno:FormatChartArea";
161 break;
162 case OBJECTTYPE_LEGEND:
163 aDispatchCommand = ".uno:FormatLegend";
164 break;
165 case OBJECTTYPE_TITLE:
166 aDispatchCommand = ".uno:FormatTitle";
167 break;
168 case OBJECTTYPE_LEGEND_ENTRY:
169 aDispatchCommand = ".uno:FormatDataSeries";
170 break;
171 case OBJECTTYPE_AXIS:
172 case OBJECTTYPE_AXIS_UNITLABEL:
173 aDispatchCommand = ".uno:FormatAxis";
174 break;
175 case OBJECTTYPE_GRID:
176 aDispatchCommand = ".uno:FormatMajorGrid";
177 break;
178 case OBJECTTYPE_SUBGRID:
179 aDispatchCommand = ".uno:FormatMinorGrid";
180 break;
181 case OBJECTTYPE_DATA_LABELS:
182 aDispatchCommand = ".uno:FormatDataLabels";
183 break;
184 case OBJECTTYPE_DATA_SERIES:
185 aDispatchCommand = ".uno:FormatDataSeries";
186 break;
187 case OBJECTTYPE_DATA_LABEL:
188 aDispatchCommand = ".uno:FormatDataLabel";
189 break;
190 case OBJECTTYPE_DATA_POINT:
191 aDispatchCommand = ".uno:FormatDataPoint";
192 break;
193 case OBJECTTYPE_DATA_AVERAGE_LINE:
194 aDispatchCommand = ".uno:FormatMeanValue";
195 break;
196 case OBJECTTYPE_DATA_ERRORS_X:
197 aDispatchCommand = ".uno:FormatXErrorBars";
198 break;
199 case OBJECTTYPE_DATA_ERRORS_Y:
200 aDispatchCommand = ".uno:FormatYErrorBars";
201 break;
202 case OBJECTTYPE_DATA_ERRORS_Z:
203 aDispatchCommand = ".uno:FormatZErrorBars";
204 break;
205 case OBJECTTYPE_DATA_CURVE:
206 aDispatchCommand = ".uno:FormatTrendline";
207 break;
208 case OBJECTTYPE_DATA_CURVE_EQUATION:
209 aDispatchCommand = ".uno:FormatTrendlineEquation";
210 break;
211 case OBJECTTYPE_DATA_STOCK_RANGE:
212 aDispatchCommand = ".uno:FormatSelection";
213 break;
214 case OBJECTTYPE_DATA_STOCK_LOSS:
215 aDispatchCommand = ".uno:FormatStockLoss";
216 break;
217 case OBJECTTYPE_DATA_STOCK_GAIN:
218 aDispatchCommand = ".uno:FormatStockGain";
219 break;
220 default: //OBJECTTYPE_UNKNOWN
221 break;
222 }
223 return aDispatchCommand;
224 }
225
226 } // anonymous namespace
227
228 // awt::XWindow
229 void SAL_CALL ChartController::setPosSize(
230 sal_Int32 X,
231 sal_Int32 Y,
232 sal_Int32 Width,
233 sal_Int32 Height,
234 sal_Int16 Flags )
235 {
236 SolarMutexGuard aGuard;
237 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
238 auto pChartWindow(GetChartWindow());
239
240 if(xWindow.is() && pChartWindow)
241 {
242 Size aLogicSize = pChartWindow->PixelToLogic( Size( Width, Height ), MapMode( MapUnit::Map100thMM ) );
243
244 //todo: for standalone chart: detect whether we are standalone
245 //change map mode to fit new size
246 awt::Size aModelPageSize = ChartModelHelper::getPageSize( getModel() );
247 sal_Int32 nScaleXNumerator = aLogicSize.Width();
248 sal_Int32 nScaleXDenominator = aModelPageSize.Width;
249 sal_Int32 nScaleYNumerator = aLogicSize.Height();
250 sal_Int32 nScaleYDenominator = aModelPageSize.Height;
251 MapMode aNewMapMode(
252 MapUnit::Map100thMM,
253 Point(0,0),
254 Fraction(nScaleXNumerator, nScaleXDenominator),
255 Fraction(nScaleYNumerator, nScaleYDenominator) );
256 pChartWindow->SetMapMode(aNewMapMode);
257 pChartWindow->setPosSizePixel( X, Y, Width, Height, static_cast<PosSizeFlags>(Flags) );
258
259 //#i75867# poor quality of ole's alternative view with 3D scenes and zoomfactors besides 100%
260 uno::Reference< beans::XPropertySet > xProp( m_xChartView, uno::UNO_QUERY );
261 if( xProp.is() )
262 {
263 auto aZoomFactors(::comphelper::InitPropertySequence({
264 { "ScaleXNumerator", uno::Any( nScaleXNumerator ) },
265 { "ScaleXDenominator", uno::Any( nScaleXDenominator ) },
266 { "ScaleYNumerator", uno::Any( nScaleYNumerator ) },
267 { "ScaleYDenominator", uno::Any( nScaleYDenominator ) }
268 }));
269 xProp->setPropertyValue( "ZoomFactors", uno::Any( aZoomFactors ));
270 }
271
272 //a correct work area is at least necessary for correct values in the position and size dialog and for dragging area
273 if(m_pDrawViewWrapper)
274 {
275 tools::Rectangle aRect(Point(0,0), pChartWindow->GetOutputSize());
276 m_pDrawViewWrapper->SetWorkArea( aRect );
277 }
278 pChartWindow->Invalidate();
279 }
280 }
281
282 awt::Rectangle SAL_CALL ChartController::getPosSize()
283 {
284 //@todo
285 awt::Rectangle aRet(0, 0, 0, 0);
286
287 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
288 if(xWindow.is())
289 aRet = xWindow->getPosSize();
290
291 return aRet;
292 }
293
294 void SAL_CALL ChartController::setVisible( sal_Bool Visible )
295 {
296 //@todo
297 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
298
299 if(xWindow.is())
300 xWindow->setVisible( Visible );
301 }
302
303 void SAL_CALL ChartController::setEnable( sal_Bool Enable )
304 {
305 //@todo
306 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
307
308 if(xWindow.is())
309 xWindow->setEnable( Enable );
310 }
311
312 void SAL_CALL ChartController::setFocus()
313 {
314 //@todo
315 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
316
317 if(xWindow.is())
318 xWindow->setFocus();
319 }
320
321 void SAL_CALL ChartController::addWindowListener(
322 const uno::Reference< awt::XWindowListener >& xListener )
323 {
324 //@todo
325 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
326
327 if(xWindow.is())
328 xWindow->addWindowListener( xListener );
329 }
330
331 void SAL_CALL ChartController::removeWindowListener(
332 const uno::Reference< awt::XWindowListener >& xListener )
333 {
334 //@todo
335 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
336
337 if(xWindow.is())
338 xWindow->removeWindowListener( xListener );
339 }
340
341 void SAL_CALL ChartController::addFocusListener(
342 const uno::Reference< awt::XFocusListener >& xListener )
343 {
344 //@todo
345 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
346
347 if(xWindow.is())
348 xWindow->addFocusListener( xListener );
349 }
350
351 void SAL_CALL ChartController::removeFocusListener(
352 const uno::Reference< awt::XFocusListener >& xListener )
353 {
354 //@todo
355 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
356
357 if(xWindow.is())
358 xWindow->removeFocusListener( xListener );
359 }
360
361 void SAL_CALL ChartController::addKeyListener(
362 const uno::Reference< awt::XKeyListener >& xListener )
363 {
364 //@todo
365 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
366
367 if(xWindow.is())
368 xWindow->addKeyListener( xListener );
369 }
370
371 void SAL_CALL ChartController::removeKeyListener(
372 const uno::Reference< awt::XKeyListener >& xListener )
373 {
374 //@todo
375 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
376
377 if(xWindow.is())
378 xWindow->removeKeyListener( xListener );
379 }
380
381 void SAL_CALL ChartController::addMouseListener(
382 const uno::Reference< awt::XMouseListener >& xListener )
383 {
384 //@todo
385 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
386
387 if(xWindow.is())
388 xWindow->addMouseListener( xListener );
389 }
390
391 void SAL_CALL ChartController::removeMouseListener(
392 const uno::Reference< awt::XMouseListener >& xListener )
393 {
394 //@todo
395 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
396
397 if(xWindow.is())
398 xWindow->removeMouseListener( xListener );
399 }
400
401 void SAL_CALL ChartController::addMouseMotionListener(
402 const uno::Reference< awt::XMouseMotionListener >& xListener )
403 {
404 //@todo
405 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
406
407 if(xWindow.is())
408 xWindow->addMouseMotionListener( xListener );
409 }
410
411 void SAL_CALL ChartController::removeMouseMotionListener(
412 const uno::Reference< awt::XMouseMotionListener >& xListener )
413 {
414 //@todo
415 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
416
417 if(xWindow.is())
418 xWindow->removeMouseMotionListener( xListener );
419 }
420
421 void SAL_CALL ChartController::addPaintListener(
422 const uno::Reference< awt::XPaintListener >& xListener )
423 {
424 //@todo
425 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
426
427 if(xWindow.is())
428 xWindow->addPaintListener( xListener );
429 }
430
431 void SAL_CALL ChartController::removePaintListener(
432 const uno::Reference< awt::XPaintListener >& xListener )
433 {
434 //@todo
435 uno::Reference<awt::XWindow> xWindow = m_xViewWindow;
436
437 if(xWindow.is())
438 xWindow->removePaintListener( xListener );
439 }
440
441 // impl vcl window controller methods
442 void ChartController::PrePaint()
443 {
444 // forward VCLs PrePaint window event to DrawingLayer
445 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
446
447 if (pDrawViewWrapper)
448 {
449 pDrawViewWrapper->PrePaint();
450 }
451 }
452
453 void ChartController::execute_Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
454 {
455 try
456 {
457 uno::Reference<frame::XModel> xModel(getModel());
458 //OSL_ENSURE( xModel.is(), "ChartController::execute_Paint: have no model to paint");
459 if (!xModel.is())
460 return;
461
462 //better performance for big data
463 uno::Reference<beans::XPropertySet> xProp(m_xChartView, uno::UNO_QUERY);
464 if (xProp.is())
465 {
466 awt::Size aResolution(1000, 1000);
467 {
468 SolarMutexGuard aGuard;
469 auto pChartWindow(GetChartWindow());
470 if (pChartWindow)
471 {
472 aResolution.Width = pChartWindow->GetSizePixel().Width();
473 aResolution.Height = pChartWindow->GetSizePixel().Height();
474 }
475 }
476 xProp->setPropertyValue( "Resolution", uno::Any( aResolution ));
477 }
478
479 uno::Reference< util::XUpdatable > xUpdatable( m_xChartView, uno::UNO_QUERY );
480 if (xUpdatable.is())
481 xUpdatable->update();
482
483 {
484 SolarMutexGuard aGuard;
485 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
486 if (pDrawViewWrapper)
487 pDrawViewWrapper->CompleteRedraw(&rRenderContext, vcl::Region(rRect));
488 }
489 }
490 catch( const uno::Exception & )
491 {
492 DBG_UNHANDLED_EXCEPTION("chart2");
493 }
494 catch( ... )
495 {
496 }
497 }
498
499 static bool isDoubleClick( const MouseEvent& rMEvt )
500 {
501 return rMEvt.GetClicks() == 2 && rMEvt.IsLeft() &&
502 !rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsShift();
503 }
504
505 void ChartController::startDoubleClickWaiting()
506 {
507 SolarMutexGuard aGuard;
508
509 m_bWaitingForDoubleClick = true;
510
511 sal_uInt64 nDblClkTime = 500;
512 auto pChartWindow(GetChartWindow());
513 if( pChartWindow )
514 {
515 const MouseSettings& rMSettings = pChartWindow->GetSettings().GetMouseSettings();
516 nDblClkTime = rMSettings.GetDoubleClickTime();
517 }
518 m_aDoubleClickTimer.SetTimeout( nDblClkTime );
519 m_aDoubleClickTimer.Start();
520 }
521
522 void ChartController::stopDoubleClickWaiting()
523 {
524 m_aDoubleClickTimer.Stop();
525 m_bWaitingForDoubleClick = false;
526 }
527
528 IMPL_LINK_NOARG(ChartController, DoubleClickWaitingHdl, Timer *, void)
529 {
530 m_bWaitingForDoubleClick = false;
531
532 if( !m_bWaitingForMouseUp && m_aSelection.maybeSwitchSelectionAfterSingleClickWasEnsured() )
533 {
534 impl_selectObjectAndNotiy();
535 SolarMutexGuard aGuard;
536 auto pChartWindow(GetChartWindow());
537 if( pChartWindow )
538 {
539 vcl::Window::PointerState aPointerState( pChartWindow->GetPointerState() );
540 MouseEvent aMouseEvent(
541 aPointerState.maPos,
542 1/*nClicks*/,
543 MouseEventModifiers::NONE,
544 static_cast< sal_uInt16 >( aPointerState.mnState )/*nButtons*/,
545 0/*nModifier*/ );
546 impl_SetMousePointer( aMouseEvent );
547 }
548 }
549 }
550
551 void ChartController::execute_MouseButtonDown( const MouseEvent& rMEvt )
552 {
553 SolarMutexGuard aGuard;
554
555 m_bWaitingForMouseUp = true;
556 m_bFieldButtonDown = false;
557
558 if( isDoubleClick(rMEvt) )
559 stopDoubleClickWaiting();
560 else
561 startDoubleClickWaiting();
562
563 m_aSelection.remindSelectionBeforeMouseDown();
564
565 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
566 auto pChartWindow(GetChartWindow());
567 if(!pChartWindow || !pDrawViewWrapper )
568 return;
569
570 Point aMPos = pChartWindow->PixelToLogic(rMEvt.GetPosPixel());
571
572 // Check if button was clicked
573 SdrObject* pObject = pDrawViewWrapper->getHitObject(aMPos);
574 if (pObject)
575 {
576 OUString aCID = pObject->GetName();
577 if (aCID.startsWith("FieldButton"))
578 {
579 m_bFieldButtonDown = true;
580 return; // Don't take any action if button was clicked
581 }
582 }
583
584 if ( rMEvt.GetButtons() == MOUSE_LEFT )
585 {
586 pChartWindow->GrabFocus();
587 pChartWindow->CaptureMouse();
588 }
589
590 if( pDrawViewWrapper->IsTextEdit() )
591 {
592 SdrViewEvent aVEvt;
593 if ( pDrawViewWrapper->IsTextEditHit( aMPos ) ||
594 // #i12587# support for shapes in chart
595 ( rMEvt.IsRight() && pDrawViewWrapper->PickAnything( rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt ) == SdrHitKind::MarkedObject ) )
596 {
597 pDrawViewWrapper->MouseButtonDown(rMEvt, pChartWindow);
598 return;
599 }
600 else
601 {
602 EndTextEdit();
603 }
604 }
605
606 //abort running action
607 if( pDrawViewWrapper->IsAction() )
608 {
609 if( rMEvt.IsRight() )
610 pDrawViewWrapper->BckAction();
611 return;
612 }
613
614 if( isDoubleClick(rMEvt) ) //do not change selection if double click
615 return;//double click is handled further in mousebutton up
616
617 SdrHdl* pHitSelectionHdl = nullptr;
618 //switch from move to resize if handle is hit on a resizable object
619 if( m_aSelection.isResizeableObjectSelected() )
620 pHitSelectionHdl = pDrawViewWrapper->PickHandle( aMPos );
621 //only change selection if no selection handles are hit
622 if( !pHitSelectionHdl )
623 {
624 // #i12587# support for shapes in chart
625 if ( m_eDrawMode == CHARTDRAW_INSERT &&
626 ( !pDrawViewWrapper->IsMarkedHit( aMPos ) || !m_aSelection.isDragableObjectSelected() ) )
627 {
628 if ( m_aSelection.hasSelection() )
629 {
630 m_aSelection.clearSelection();
631 }
632 if ( !pDrawViewWrapper->IsAction() )
633 {
634 if ( pDrawViewWrapper->GetCurrentObjIdentifier() == OBJ_CAPTION )
635 {
636 Size aCaptionSize( 2268, 1134 );
637 pDrawViewWrapper->BegCreateCaptionObj( aMPos, aCaptionSize );
638 }
639 else
640 {
641 pDrawViewWrapper->BegCreateObj( aMPos);
642 }
643 SdrObject* pObj = pDrawViewWrapper->GetCreateObj();
644 DrawCommandDispatch* pDrawCommandDispatch = m_aDispatchContainer.getDrawCommandDispatch();
645 if ( pObj && m_pDrawModelWrapper && pDrawCommandDispatch )
646 {
647 SfxItemSet aSet( m_pDrawModelWrapper->GetItemPool() );
648 pDrawCommandDispatch->setAttributes( pObj );
649 pDrawCommandDispatch->setLineEnds( aSet );
650 pObj->SetMergedItemSet( aSet );
651 }
652 }
653 impl_SetMousePointer( rMEvt );
654 return;
655 }
656
657 m_aSelection.adaptSelectionToNewPos(
658 aMPos,
659 pDrawViewWrapper,
660 rMEvt.IsRight(),
661 m_bWaitingForDoubleClick );
662
663 if( !m_aSelection.isRotateableObjectSelected( getModel() ) )
664 {
665 m_eDragMode = SdrDragMode::Move;
666 pDrawViewWrapper->SetDragMode(m_eDragMode);
667 }
668
669 m_aSelection.applySelection(pDrawViewWrapper);
670 }
671 if( m_aSelection.isDragableObjectSelected()
672 && !rMEvt.IsRight() )
673 {
674 //start drag
675 sal_uInt16 nDrgLog = static_cast<sal_uInt16>(pChartWindow->PixelToLogic(Size(DRGPIX,0)).Width());
676 SdrDragMethod* pDragMethod = nullptr;
677
678 //change selection to 3D scene if rotate mode
679 SdrDragMode eDragMode = pDrawViewWrapper->GetDragMode();
680 if( eDragMode==SdrDragMode::Rotate )
681 {
682 E3dScene* pScene = SelectionHelper::getSceneToRotate( pDrawViewWrapper->getNamedSdrObject( m_aSelection.getSelectedCID() ) );
683 if( pScene )
684 {
685 DragMethod_RotateDiagram::RotationDirection eRotationDirection(DragMethod_RotateDiagram::ROTATIONDIRECTION_FREE);
686 if(pHitSelectionHdl)
687 {
688 SdrHdlKind eKind = pHitSelectionHdl->GetKind();
689 if( eKind==SdrHdlKind::Upper || eKind==SdrHdlKind::Lower )
690 eRotationDirection = DragMethod_RotateDiagram::ROTATIONDIRECTION_X;
691 else if( eKind==SdrHdlKind::Left || eKind==SdrHdlKind::Right )
692 eRotationDirection = DragMethod_RotateDiagram::ROTATIONDIRECTION_Y;
693 else if( eKind==SdrHdlKind::UpperLeft || eKind==SdrHdlKind::UpperRight || eKind==SdrHdlKind::LowerLeft || eKind==SdrHdlKind::LowerRight )
694 eRotationDirection = DragMethod_RotateDiagram::ROTATIONDIRECTION_Z;
695 }
696 pDragMethod = new DragMethod_RotateDiagram( *pDrawViewWrapper, m_aSelection.getSelectedCID(), getModel(), eRotationDirection );
697 }
698 }
699 else
700 {
701 OUString aDragMethodServiceName( ObjectIdentifier::getDragMethodServiceName( m_aSelection.getSelectedCID() ) );
702 if( aDragMethodServiceName == ObjectIdentifier::getPieSegmentDragMethodServiceName() )
703 pDragMethod = new DragMethod_PieSegment( *pDrawViewWrapper, m_aSelection.getSelectedCID(), getModel() );
704 }
705 pDrawViewWrapper->SdrView::BegDragObj(aMPos, nullptr, pHitSelectionHdl, nDrgLog, pDragMethod);
706 }
707
708 impl_SetMousePointer( rMEvt );
709 }
710
711 void ChartController::execute_MouseMove( const MouseEvent& rMEvt )
712 {
713 SolarMutexGuard aGuard;
714
715 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
716 auto pChartWindow(GetChartWindow());
717 if(!pChartWindow || !pDrawViewWrapper)
718 return;
719
720 if( m_pDrawViewWrapper->IsTextEdit() )
721 {
722 if( m_pDrawViewWrapper->MouseMove(rMEvt,pChartWindow) )
723 return;
724 }
725
726 if(pDrawViewWrapper->IsAction())
727 {
728 pDrawViewWrapper->MovAction( pChartWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
729 }
730
731 impl_SetMousePointer( rMEvt );
732 }
733
734 void ChartController::execute_MouseButtonUp( const MouseEvent& rMEvt )
735 {
736 ControllerLockGuardUNO aCLGuard( getModel() );
737 bool bMouseUpWithoutMouseDown = !m_bWaitingForMouseUp;
738 m_bWaitingForMouseUp = false;
739 bool bNotifySelectionChange = false;
740 {
741 SolarMutexGuard aGuard;
742
743 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
744 auto pChartWindow(GetChartWindow());
745 if(!pChartWindow || !pDrawViewWrapper)
746 return;
747
748 Point aMPos = pChartWindow->PixelToLogic(rMEvt.GetPosPixel());
749
750 // Check if button was clicked
751 if (m_bFieldButtonDown)
752 {
753 m_bFieldButtonDown = false;
754 SdrObject* pObject = pDrawViewWrapper->getHitObject(aMPos);
755 if (pObject)
756 {
757 OUString aCID = pObject->GetName();
758 if (aCID.startsWith("FieldButton"))
759 {
760 sendPopupRequest(aCID, pObject->GetCurrentBoundRect());
761 return;
762 }
763 }
764 }
765
766 if(pDrawViewWrapper->IsTextEdit())
767 {
768 if( pDrawViewWrapper->MouseButtonUp(rMEvt,pChartWindow) )
769 return;
770 }
771
772 // #i12587# support for shapes in chart
773 if ( m_eDrawMode == CHARTDRAW_INSERT && pDrawViewWrapper->IsCreateObj() )
774 {
775 pDrawViewWrapper->EndCreateObj( SdrCreateCmd::ForceEnd );
776 {
777 HiddenUndoContext aUndoContext( m_xUndoManager );
778 // don't want the positioning Undo action to appear in the UI
779 impl_switchDiagramPositioningToExcludingPositioning();
780 }
781 if ( pDrawViewWrapper->AreObjectsMarked() )
782 {
783 if ( pDrawViewWrapper->GetCurrentObjIdentifier() == OBJ_TEXT )
784 {
785 executeDispatch_EditText();
786 }
787 else
788 {
789 SdrObject* pObj = pDrawViewWrapper->getSelectedObject();
790 if ( pObj )
791 {
792 uno::Reference< drawing::XShape > xShape( pObj->getUnoShape(), uno::UNO_QUERY );
793 if ( xShape.is() )
794 {
795 m_aSelection.setSelection( xShape );
796 m_aSelection.applySelection( pDrawViewWrapper );
797 }
798 }
799 }
800 }
801 else
802 {
803 m_aSelection.adaptSelectionToNewPos( aMPos, pDrawViewWrapper, rMEvt.IsRight(), m_bWaitingForDoubleClick );
804 m_aSelection.applySelection( pDrawViewWrapper );
805 setDrawMode( CHARTDRAW_SELECT );
806 }
807 }
808 else if ( pDrawViewWrapper->IsDragObj() )
809 {
810 bool bDraggingDone = false;
811 SdrDragMethod* pDragMethod = pDrawViewWrapper->SdrView::GetDragMethod();
812 bool bIsMoveOnly = pDragMethod && pDragMethod->getMoveOnly();
813 DragMethod_Base* pChartDragMethod = dynamic_cast< DragMethod_Base* >(pDragMethod);
814 if( pChartDragMethod )
815 {
816 UndoGuard aUndoGuard( pChartDragMethod->getUndoDescription(),
817 m_xUndoManager );
818
819 if( pDrawViewWrapper->EndDragObj() )
820 {
821 bDraggingDone = true;
822 aUndoGuard.commit();
823 }
824 }
825
826 if( !bDraggingDone && pDrawViewWrapper->EndDragObj() )
827 {
828 try
829 {
830 //end move or size
831 SdrObject* pObj = pDrawViewWrapper->getSelectedObject();
832 if( pObj )
833 {
834 tools::Rectangle aObjectRect = pObj->GetSnapRect();
835 awt::Size aPageSize( ChartModelHelper::getPageSize( getModel() ) );
836 tools::Rectangle aPageRect( 0,0,aPageSize.Width,aPageSize.Height );
837
838 const E3dObject* pE3dObject(dynamic_cast< const E3dObject*>(pObj));
839 if(nullptr != pE3dObject)
840 {
841 E3dScene* pScene(pE3dObject->getRootE3dSceneFromE3dObject());
842 if(nullptr != pScene)
843 {
844 aObjectRect = pScene->GetSnapRect();
845 }
846 }
847
848 ActionDescriptionProvider::ActionType eActionType(ActionDescriptionProvider::ActionType::Move);
849 if( !bIsMoveOnly && m_aSelection.isResizeableObjectSelected() )
850 eActionType = ActionDescriptionProvider::ActionType::Resize;
851
852 ObjectType eObjectType = ObjectIdentifier::getObjectType( m_aSelection.getSelectedCID() );
853
854 UndoGuard aUndoGuard(
855 ActionDescriptionProvider::createDescription( eActionType, ObjectNameProvider::getName( eObjectType)),
856 m_xUndoManager );
857
858 bool bChanged = false;
859 ChartModel* pModel = dynamic_cast<ChartModel*>(getModel().get());
860 assert(pModel);
861 if ( eObjectType == OBJECTTYPE_LEGEND )
862 bChanged = DiagramHelper::switchDiagramPositioningToExcludingPositioning( *pModel, false , true );
863
864 bool bMoved = PositionAndSizeHelper::moveObject( m_aSelection.getSelectedCID()
865 , getModel()
866 , awt::Rectangle(aObjectRect.getX(),aObjectRect.getY(),aObjectRect.getWidth(),aObjectRect.getHeight())
867 , awt::Rectangle(aPageRect.getX(),aPageRect.getY(),aPageRect.getWidth(),aPageRect.getHeight()) );
868
869 if( bMoved || bChanged )
870 {
871 bDraggingDone = true;
872 aUndoGuard.commit();
873 }
874 }
875 }
876 catch( const uno::Exception & )
877 {
878 DBG_UNHANDLED_EXCEPTION("chart2");
879 }
880 //all wanted model changes will take effect
881 //and all unwanted view modifications are cleaned
882 }
883
884 if( !bDraggingDone ) //mouse wasn't moved while dragging
885 {
886 bool bClickedTwiceOnDragableObject = SelectionHelper::isDragableObjectHitTwice( aMPos, m_aSelection.getSelectedCID(), *pDrawViewWrapper );
887 bool bIsRotateable = m_aSelection.isRotateableObjectSelected( getModel() );
888
889 //toggle between move and rotate
890 if( bIsRotateable && bClickedTwiceOnDragableObject && m_eDragMode==SdrDragMode::Move )
891 m_eDragMode=SdrDragMode::Rotate;
892 else
893 m_eDragMode=SdrDragMode::Move;
894
895 pDrawViewWrapper->SetDragMode(m_eDragMode);
896
897 if( !m_bWaitingForDoubleClick && m_aSelection.maybeSwitchSelectionAfterSingleClickWasEnsured() )
898 {
899 impl_selectObjectAndNotiy();
900 }
901 }
902 else
903 m_aSelection.resetPossibleSelectionAfterSingleClickWasEnsured();
904 }
905
906 //@todo ForcePointer(&rMEvt);
907 pChartWindow->ReleaseMouse();
908
909 // In tiled rendering drag mode could be not yet over on the call
910 // that should handle the double-click, so better to perform this check
911 // always.
912 if( isDoubleClick(rMEvt) && !bMouseUpWithoutMouseDown /*#i106966#*/ )
913 {
914 Point aMousePixel = rMEvt.GetPosPixel();
915 execute_DoubleClick( &aMousePixel );
916 }
917
918 if( m_aSelection.isSelectionDifferentFromBeforeMouseDown() )
919 bNotifySelectionChange = true;
920 }
921
922 impl_SetMousePointer( rMEvt );
923
924 if(bNotifySelectionChange)
925 impl_notifySelectionChangeListeners();
926 }
927
928 void ChartController::execute_DoubleClick( const Point* pMousePixel )
929 {
930 bool isMobile = comphelper::LibreOfficeKit::isMobile(SfxLokHelper::getView());
931 if (isMobile)
932 return;
933
934 bool bEditText = false;
935 if ( m_aSelection.hasSelection() )
936 {
937 OUString aCID( m_aSelection.getSelectedCID() );
938 if ( !aCID.isEmpty() )
939 {
940 ObjectType eObjectType = ObjectIdentifier::getObjectType( aCID );
941 if ( eObjectType == OBJECTTYPE_TITLE )
942 {
943 bEditText = true;
944 }
945 }
946 else
947 {
948 // #i12587# support for shapes in chart
949 SdrObject* pObj = DrawViewWrapper::getSdrObject( m_aSelection.getSelectedAdditionalShape() );
950 if ( dynamic_cast< const SdrTextObj* >(pObj) != nullptr )
951 {
952 bEditText = true;
953 }
954 }
955 }
956
957 if ( bEditText )
958 {
959 executeDispatch_EditText( pMousePixel );
960 }
961 else
962 {
963 executeDispatch_ObjectProperties();
964 }
965 }
966
967 void ChartController::execute_Resize()
968 {
969 SolarMutexGuard aGuard;
970 auto pChartWindow(GetChartWindow());
971 if(pChartWindow)
972 pChartWindow->Invalidate();
973 }
974
975 void ChartController::execute_Command( const CommandEvent& rCEvt )
976 {
977 SolarMutexGuard aGuard;
978 auto pChartWindow(GetChartWindow());
979 bool bIsAction = false;
980 {
981 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
982 if(!pChartWindow || !pDrawViewWrapper)
983 return;
984 bIsAction = m_pDrawViewWrapper->IsAction();
985 }
986
987 // pop-up menu
988 if(rCEvt.GetCommand() == CommandEventId::ContextMenu && !bIsAction)
989 {
990 {
991 if(pChartWindow)
992 pChartWindow->ReleaseMouse();
993 }
994
995 if( m_aSelection.isSelectionDifferentFromBeforeMouseDown() )
996 impl_notifySelectionChangeListeners();
997
998 css::uno::Reference< css::awt::XPopupMenu > xPopupMenu( m_xCC->getServiceManager()->createInstanceWithContext(
999 "com.sun.star.awt.PopupMenu", m_xCC ), css::uno::UNO_QUERY );
1000
1001 Point aPos( rCEvt.GetMousePosPixel() );
1002 if( !rCEvt.IsMouseEvent() )
1003 {
1004 if(pChartWindow)
1005 aPos = pChartWindow->GetPointerState().maPos;
1006 }
1007
1008 OUString aMenuName;
1009 if ( isShapeContext() )
1010 // #i12587# support for shapes in chart
1011 aMenuName = m_pDrawViewWrapper->IsTextEdit() ? OUStringLiteral( "drawtext" ) : OUStringLiteral( "draw" );
1012 else
1013 {
1014 // todo: the context menu should be specified by an xml file in uiconfig
1015 if( xPopupMenu.is())
1016 {
1017 sal_Int16 nUniqueId = 1;
1018 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:Cut" );
1019 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:Copy" );
1020 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:Paste" );
1021 xPopupMenu->insertSeparator( -1 );
1022
1023 ObjectType eObjectType = ObjectIdentifier::getObjectType( m_aSelection.getSelectedCID() );
1024 Reference< XDiagram > xDiagram = ChartModelHelper::findDiagram( getModel() );
1025
1026 OUString aFormatCommand( lcl_getFormatCommandForObjectCID( m_aSelection.getSelectedCID() ) );
1027 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, aFormatCommand );
1028
1029 //some commands for dataseries and points:
1030
1031 if( eObjectType == OBJECTTYPE_DATA_SERIES || eObjectType == OBJECTTYPE_DATA_POINT )
1032 {
1033 bool bIsPoint = ( eObjectType == OBJECTTYPE_DATA_POINT );
1034 uno::Reference< XDataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getModel() );
1035 uno::Reference< chart2::XRegressionCurveContainer > xCurveCnt( xSeries, uno::UNO_QUERY );
1036 Reference< chart2::XRegressionCurve > xTrendline( RegressionCurveHelper::getFirstCurveNotMeanValueLine( xCurveCnt ) );
1037 bool bHasEquation = RegressionCurveHelper::hasEquation( xTrendline );
1038 Reference< chart2::XRegressionCurve > xMeanValue( RegressionCurveHelper::getMeanValueLine( xCurveCnt ) );
1039 bool bHasYErrorBars = StatisticsHelper::hasErrorBars( xSeries );
1040 bool bHasXErrorBars = StatisticsHelper::hasErrorBars( xSeries, false );
1041 bool bHasDataLabelsAtSeries = DataSeriesHelper::hasDataLabelsAtSeries( xSeries );
1042 bool bHasDataLabelsAtPoints = DataSeriesHelper::hasDataLabelsAtPoints( xSeries );
1043 bool bHasDataLabelAtPoint = false;
1044 sal_Int32 nPointIndex = -1;
1045 if( bIsPoint )
1046 {
1047 nPointIndex = ObjectIdentifier::getIndexFromParticleOrCID( m_aSelection.getSelectedCID() );
1048 bHasDataLabelAtPoint = DataSeriesHelper::hasDataLabelAtPoint( xSeries, nPointIndex );
1049 }
1050 bool bSelectedPointIsFormatted = false;
1051 bool bHasFormattedDataPointsOtherThanSelected = false;
1052
1053 Reference< beans::XPropertySet > xSeriesProperties( xSeries, uno::UNO_QUERY );
1054 if( xSeriesProperties.is() )
1055 {
1056 uno::Sequence< sal_Int32 > aAttributedDataPointIndexList;
1057 if( xSeriesProperties->getPropertyValue( "AttributedDataPoints" ) >>= aAttributedDataPointIndexList )
1058 {
1059 if( aAttributedDataPointIndexList.hasElements() )
1060 {
1061 if( bIsPoint )
1062 {
1063 auto aIndices( comphelper::sequenceToContainer<std::vector< sal_Int32 >>( aAttributedDataPointIndexList ) );
1064 std::vector< sal_Int32 >::iterator aIt = std::find( aIndices.begin(), aIndices.end(), nPointIndex );
1065 if( aIt != aIndices.end())
1066 bSelectedPointIsFormatted = true;
1067 else
1068 bHasFormattedDataPointsOtherThanSelected = true;
1069 }
1070 else
1071 bHasFormattedDataPointsOtherThanSelected = true;
1072 }
1073 }
1074 }
1075
1076 if( bIsPoint )
1077 {
1078 if( bHasDataLabelAtPoint )
1079 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatDataLabel" );
1080 if( !bHasDataLabelAtPoint )
1081 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertDataLabel" );
1082 else
1083 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteDataLabel" );
1084 if( bSelectedPointIsFormatted )
1085 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:ResetDataPoint" );
1086
1087 xPopupMenu->insertSeparator( -1 );
1088
1089 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatDataSeries" );
1090 }
1091
1092 Reference< chart2::XChartType > xChartType( DiagramHelper::getChartTypeOfSeries( xDiagram, xSeries ) );
1093 if( xChartType->getChartType() == CHART2_SERVICE_NAME_CHARTTYPE_CANDLESTICK )
1094 {
1095 try
1096 {
1097 Reference< beans::XPropertySet > xChartTypeProp( xChartType, uno::UNO_QUERY );
1098 if( xChartTypeProp.is() )
1099 {
1100 bool bJapaneseStyle = false;
1101 xChartTypeProp->getPropertyValue( "Japanese" ) >>= bJapaneseStyle;
1102
1103 if( bJapaneseStyle )
1104 {
1105 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatStockLoss" );
1106 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatStockGain" );
1107 }
1108 }
1109 }
1110 catch( const uno::Exception & )
1111 {
1112 DBG_UNHANDLED_EXCEPTION("chart2");
1113 }
1114 }
1115
1116 if( bHasDataLabelsAtSeries )
1117 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatDataLabels" );
1118 if( bHasEquation )
1119 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatTrendlineEquation" );
1120 if( xMeanValue.is() )
1121 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatMeanValue" );
1122 if( bHasXErrorBars )
1123 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatXErrorBars" );
1124 if( bHasYErrorBars )
1125 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatYErrorBars" );
1126
1127 xPopupMenu->insertSeparator( -1 );
1128
1129 if( !bHasDataLabelsAtSeries )
1130 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertDataLabels" );
1131
1132 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertTrendline" );
1133
1134 if( !xMeanValue.is() )
1135 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertMeanValue" );
1136 if( !bHasXErrorBars )
1137 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertXErrorBars" );
1138 if( !bHasYErrorBars )
1139 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertYErrorBars" );
1140 if( bHasDataLabelsAtSeries || ( bHasDataLabelsAtPoints && bHasFormattedDataPointsOtherThanSelected ) )
1141 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteDataLabels" );
1142 if( bHasEquation )
1143 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteTrendlineEquation" );
1144 if( xMeanValue.is() )
1145 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteMeanValue" );
1146 if( bHasXErrorBars )
1147 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteXErrorBars" );
1148 if( bHasYErrorBars )
1149 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteYErrorBars" );
1150
1151 if( bHasFormattedDataPointsOtherThanSelected )
1152 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:ResetAllDataPoints" );
1153
1154 xPopupMenu->insertSeparator( -1 );
1155
1156 lcl_insertMenuCommand( xPopupMenu, nUniqueId, ".uno:ArrangeRow" );
1157 uno::Reference< awt::XPopupMenu > xArrangePopupMenu(
1158 m_xCC->getServiceManager()->createInstanceWithContext(
1159 "com.sun.star.awt.PopupMenu", m_xCC ), uno::UNO_QUERY );
1160 if( xArrangePopupMenu.is() )
1161 {
1162 sal_Int16 nSubId = nUniqueId + 1;
1163 lcl_insertMenuCommand( xArrangePopupMenu, nSubId++, ".uno:Forward" );
1164 lcl_insertMenuCommand( xArrangePopupMenu, nSubId, ".uno:Backward" );
1165 xPopupMenu->setPopupMenu( nUniqueId, xArrangePopupMenu );
1166 nUniqueId = nSubId;
1167 }
1168 ++nUniqueId;
1169 }
1170 else if( eObjectType == OBJECTTYPE_DATA_CURVE )
1171 {
1172 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteTrendline" );
1173 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatTrendlineEquation" );
1174 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertTrendlineEquation" );
1175 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertTrendlineEquationAndR2" );
1176 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertR2Value" );
1177 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteTrendlineEquation" );
1178 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteR2Value" );
1179 }
1180 else if( eObjectType == OBJECTTYPE_DATA_CURVE_EQUATION )
1181 {
1182 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertR2Value" );
1183 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteR2Value" );
1184 }
1185
1186 //some commands for axes: and grids
1187
1188 else if( eObjectType == OBJECTTYPE_AXIS || eObjectType == OBJECTTYPE_GRID || eObjectType == OBJECTTYPE_SUBGRID )
1189 {
1190 Reference< XAxis > xAxis = ObjectIdentifier::getAxisForCID( m_aSelection.getSelectedCID(), getModel() );
1191 if( xAxis.is() && xDiagram.is() )
1192 {
1193 sal_Int32 nDimensionIndex = -1;
1194 sal_Int32 nCooSysIndex = -1;
1195 sal_Int32 nAxisIndex = -1;
1196 AxisHelper::getIndicesForAxis( xAxis, xDiagram, nCooSysIndex, nDimensionIndex, nAxisIndex );
1197 bool bIsSecondaryAxis = nAxisIndex!=0;
1198 bool bIsAxisVisible = AxisHelper::isAxisVisible( xAxis );
1199 bool bIsMajorGridVisible = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true /*bMainGrid*/, xDiagram );
1200 bool bIsMinorGridVisible = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false /*bMainGrid*/, xDiagram );
1201 bool bHasTitle = false;
1202 uno::Reference< XTitled > xTitled( xAxis, uno::UNO_QUERY );
1203 if( xTitled.is())
1204 bHasTitle = !TitleHelper::getCompleteString( xTitled->getTitleObject() ).isEmpty();
1205
1206 if( eObjectType != OBJECTTYPE_AXIS && bIsAxisVisible )
1207 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatAxis" );
1208 if( eObjectType != OBJECTTYPE_GRID && bIsMajorGridVisible && !bIsSecondaryAxis )
1209 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatMajorGrid" );
1210 if( eObjectType != OBJECTTYPE_SUBGRID && bIsMinorGridVisible && !bIsSecondaryAxis )
1211 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatMinorGrid" );
1212
1213 xPopupMenu->insertSeparator( -1 );
1214
1215 if( eObjectType != OBJECTTYPE_AXIS && !bIsAxisVisible )
1216 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertAxis" );
1217 if( eObjectType != OBJECTTYPE_GRID && !bIsMajorGridVisible && !bIsSecondaryAxis )
1218 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertMajorGrid" );
1219 if( eObjectType != OBJECTTYPE_SUBGRID && !bIsMinorGridVisible && !bIsSecondaryAxis )
1220 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertMinorGrid" );
1221 if( !bHasTitle )
1222 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertAxisTitle" );
1223
1224 if( bIsAxisVisible )
1225 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteAxis" );
1226 if( bIsMajorGridVisible && !bIsSecondaryAxis )
1227 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteMajorGrid" );
1228 if( bIsMinorGridVisible && !bIsSecondaryAxis )
1229 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteMinorGrid" );
1230 }
1231 }
1232
1233 if( eObjectType == OBJECTTYPE_DATA_STOCK_LOSS )
1234 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatStockGain" );
1235 else if( eObjectType == OBJECTTYPE_DATA_STOCK_GAIN )
1236 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:FormatStockLoss" );
1237
1238 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:TransformDialog" );
1239
1240 if( eObjectType == OBJECTTYPE_PAGE || eObjectType == OBJECTTYPE_DIAGRAM
1241 || eObjectType == OBJECTTYPE_DIAGRAM_WALL
1242 || eObjectType == OBJECTTYPE_DIAGRAM_FLOOR
1243 || eObjectType == OBJECTTYPE_UNKNOWN )
1244 {
1245 if( eObjectType != OBJECTTYPE_UNKNOWN )
1246 xPopupMenu->insertSeparator( -1 );
1247 bool bHasLegend = LegendHelper::hasLegend( xDiagram );
1248 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertTitles" );
1249 if( !bHasLegend )
1250 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertLegend" );
1251 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:InsertRemoveAxes" );
1252 if( bHasLegend )
1253 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DeleteLegend" );
1254 }
1255
1256 xPopupMenu->insertSeparator( -1 );
1257 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DiagramType" );
1258 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DataRanges" );
1259 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:DiagramData" );
1260 lcl_insertMenuCommand( xPopupMenu, nUniqueId++, ".uno:View3D" );
1261 }
1262 }
1263
1264 css::uno::Sequence< css::uno::Any > aArgs( 3 );
1265 aArgs[0] <<= comphelper::makePropertyValue( "IsContextMenu", true );
1266 aArgs[1] <<= comphelper::makePropertyValue( "Frame", m_xFrame );
1267 aArgs[2] <<= comphelper::makePropertyValue( "Value", aMenuName );
1268
1269 css::uno::Reference< css::frame::XPopupMenuController > xPopupController(
1270 m_xCC->getServiceManager()->createInstanceWithArgumentsAndContext(
1271 "com.sun.star.comp.framework.ResourceMenuController", aArgs, m_xCC ), css::uno::UNO_QUERY );
1272
1273 if ( !xPopupController.is() || !xPopupMenu.is() )
1274 return;
1275
1276 if (comphelper::LibreOfficeKit::isActive())
1277 {
1278 PopupMenu* pPopupMenu = static_cast<PopupMenu*>(comphelper::getUnoTunnelImplementation<VCLXMenu>(xPopupMenu)->GetMenu());
1279 pPopupMenu->SetLOKNotifier(SfxViewShell::Current());
1280
1281 // the context menu expects a position related to the document window,
1282 // not to the chart window
1283 SfxInPlaceClient* pIPClient = SfxViewShell::Current()->GetIPClient();
1284 if (pIPClient)
1285 {
1286 vcl::Window* pRootWin = pIPClient->GetEditWin();
1287 if (pRootWin)
1288 {
1289 Point aOffset = pChartWindow->GetOffsetPixelFrom(*pRootWin);
1290 aPos += aOffset;
1291 }
1292 }
1293 }
1294
1295 xPopupController->setPopupMenu( xPopupMenu );
1296 xPopupMenu->execute( css::uno::Reference< css::awt::XWindowPeer >( m_xFrame->getContainerWindow(), css::uno::UNO_QUERY ),
1297 css::awt::Rectangle( aPos.X(), aPos.Y(), 0, 0 ),
1298 css::awt::PopupMenuDirection::EXECUTE_DEFAULT );
1299
1300 css::uno::Reference< css::lang::XComponent > xComponent( xPopupController, css::uno::UNO_QUERY );
1301 if ( xComponent.is() )
1302 xComponent->dispose();
1303 }
1304 else if( ( rCEvt.GetCommand() == CommandEventId::StartExtTextInput ) ||
1305 ( rCEvt.GetCommand() == CommandEventId::ExtTextInput ) ||
1306 ( rCEvt.GetCommand() == CommandEventId::EndExtTextInput ) ||
1307 ( rCEvt.GetCommand() == CommandEventId::InputContextChange ) )
1308 {
1309 //#i84417# enable editing with IME
1310 if( m_pDrawViewWrapper )
1311 m_pDrawViewWrapper->Command( rCEvt, pChartWindow );
1312 }
1313 }
1314
1315 bool ChartController::execute_KeyInput( const KeyEvent& rKEvt )
1316 {
1317 SolarMutexGuard aGuard;
1318 bool bReturn=false;
1319
1320 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
1321 auto pChartWindow(GetChartWindow());
1322 if (!pChartWindow || !pDrawViewWrapper)
1323 return bReturn;
1324
1325 // handle accelerators
1326 if (!m_apAccelExecute && m_xFrame.is() && m_xCC.is())
1327 {
1328 m_apAccelExecute = ::svt::AcceleratorExecute::createAcceleratorHelper();
1329 OSL_ASSERT(m_apAccelExecute);
1330 if (m_apAccelExecute)
1331 m_apAccelExecute->init( m_xCC, m_xFrame );
1332 }
1333
1334 vcl::KeyCode aKeyCode( rKEvt.GetKeyCode());
1335 sal_uInt16 nCode = aKeyCode.GetCode();
1336 bool bAlternate = aKeyCode.IsMod2();
1337 bool bCtrl = aKeyCode.IsMod1();
1338
1339 if (m_apAccelExecute)
1340 bReturn = m_apAccelExecute->execute( aKeyCode );
1341 if( bReturn )
1342 return bReturn;
1343
1344 {
1345 if( pDrawViewWrapper->IsTextEdit() )
1346 {
1347 if( pDrawViewWrapper->KeyInput(rKEvt, pChartWindow) )
1348 {
1349 bReturn = true;
1350 if( nCode == KEY_ESCAPE )
1351 {
1352 EndTextEdit();
1353 }
1354 }
1355 }
1356 }
1357
1358 // keyboard accessibility
1359 ObjectType eObjectType = ObjectIdentifier::getObjectType( m_aSelection.getSelectedCID() );
1360 if( ! bReturn )
1361 {
1362 // Navigation (Tab/F3/Home/End)
1363 uno::Reference< XChartDocument > xChartDoc( getModel(), uno::UNO_QUERY );
1364 ObjectKeyNavigation aObjNav( m_aSelection.getSelectedOID(), xChartDoc, comphelper::getUnoTunnelImplementation<ExplicitValueProvider>( m_xChartView ));
1365 awt::KeyEvent aKeyEvent( ::svt::AcceleratorExecute::st_VCLKey2AWTKey( aKeyCode ));
1366 bReturn = aObjNav.handleKeyEvent( aKeyEvent );
1367 if( bReturn )
1368 {
1369 const ObjectIdentifier& aNewOID = aObjNav.getCurrentSelection();
1370 uno::Any aNewSelection;
1371 if ( aNewOID.isValid() && !ObjectHierarchy::isRootNode( aNewOID ) )
1372 {
1373 aNewSelection = aNewOID.getAny();
1374 }
1375 if ( m_eDragMode == SdrDragMode::Rotate && !SelectionHelper::isRotateableObject( aNewOID.getObjectCID(), getModel() ) )
1376 {
1377 m_eDragMode = SdrDragMode::Move;
1378 }
1379 bReturn = select( aNewSelection );
1380 }
1381 }
1382
1383 // Position and Size (+/-/arrow-keys) or pie segment dragging
1384 if( ! bReturn )
1385 {
1386 // pie segment dragging
1387 // note: could also be done for data series
1388 if( eObjectType == OBJECTTYPE_DATA_POINT &&
1389 ObjectIdentifier::getDragMethodServiceName( m_aSelection.getSelectedCID() ) ==
1390 ObjectIdentifier::getPieSegmentDragMethodServiceName())
1391 {
1392 bool bDrag = false;
1393 bool bDragInside = false;
1394 if( nCode == KEY_ADD ||
1395 nCode == KEY_SUBTRACT )
1396 {
1397 bDrag = true;
1398 bDragInside = ( nCode == KEY_SUBTRACT );
1399 }
1400 else if(
1401 nCode == KEY_LEFT ||
1402 nCode == KEY_RIGHT ||
1403 nCode == KEY_UP ||
1404 nCode == KEY_DOWN )
1405 {
1406 bDrag = true;
1407 OUString aParameter( ObjectIdentifier::getDragParameterString( m_aSelection.getSelectedCID() ));
1408 sal_Int32 nOffsetPercentDummy( 0 );
1409 awt::Point aMinimumPosition( 0, 0 );
1410 awt::Point aMaximumPosition( 0, 0 );
1411 ObjectIdentifier::parsePieSegmentDragParameterString(
1412 aParameter, nOffsetPercentDummy, aMinimumPosition, aMaximumPosition );
1413 aMaximumPosition.Y -= aMinimumPosition.Y;
1414 aMaximumPosition.X -= aMinimumPosition.X;
1415
1416 bDragInside =
1417 (nCode == KEY_RIGHT && (aMaximumPosition.X < 0)) ||
1418 (nCode == KEY_LEFT && (aMaximumPosition.X > 0)) ||
1419 (nCode == KEY_DOWN && (aMaximumPosition.Y < 0)) ||
1420 (nCode == KEY_UP && (aMaximumPosition.Y > 0));
1421 }
1422
1423 if( bDrag )
1424 {
1425 double fAmount = bAlternate ? 0.01 : 0.05;
1426 if( bDragInside )
1427 fAmount *= -1.0;
1428
1429 bReturn = impl_DragDataPoint( m_aSelection.getSelectedCID(), fAmount );
1430 }
1431 }
1432 else
1433 {
1434 // size
1435 if( nCode == KEY_ADD ||
1436 nCode == KEY_SUBTRACT )
1437 {
1438 if( eObjectType == OBJECTTYPE_DIAGRAM )
1439 {
1440 // default 1 mm in each direction
1441 double fGrowAmountX = 200.0;
1442 double fGrowAmountY = 200.0;
1443 if (bAlternate)
1444 {
1445 // together with Alt-key: 1 px in each direction
1446 Size aPixelSize = pChartWindow->PixelToLogic( Size( 2, 2 ));
1447 fGrowAmountX = static_cast< double >( aPixelSize.Width());
1448 fGrowAmountY = static_cast< double >( aPixelSize.Height());
1449 }
1450 if( nCode == KEY_SUBTRACT )
1451 {
1452 fGrowAmountX = -fGrowAmountX;
1453 fGrowAmountY = -fGrowAmountY;
1454 }
1455 bReturn = impl_moveOrResizeObject(
1456 m_aSelection.getSelectedCID(), CENTERED_RESIZE_OBJECT, fGrowAmountX, fGrowAmountY );
1457 }
1458 }
1459 // position
1460 else if( nCode == KEY_LEFT ||
1461 nCode == KEY_RIGHT ||
1462 nCode == KEY_UP ||
1463 nCode == KEY_DOWN )
1464 {
1465 if( m_aSelection.isDragableObjectSelected() )
1466 {
1467 // default 1 mm
1468 double fShiftAmountX = 100.0;
1469 double fShiftAmountY = 100.0;
1470 if (bAlternate)
1471 {
1472 // together with Alt-key: 1 px
1473 Size aPixelSize = pChartWindow->PixelToLogic( Size( 1, 1 ));
1474 fShiftAmountX = static_cast< double >( aPixelSize.Width());
1475 fShiftAmountY = static_cast< double >( aPixelSize.Height());
1476 }
1477 switch( nCode )
1478 {
1479 case KEY_LEFT:
1480 fShiftAmountX = -fShiftAmountX;
1481 fShiftAmountY = 0.0;
1482 break;
1483 case KEY_RIGHT:
1484 fShiftAmountY = 0.0;
1485 break;
1486 case KEY_UP:
1487 fShiftAmountX = 0.0;
1488 fShiftAmountY = -fShiftAmountY;
1489 break;
1490 case KEY_DOWN:
1491 fShiftAmountX = 0.0;
1492 break;
1493 }
1494 if( !m_aSelection.getSelectedCID().isEmpty() )
1495 {
1496 //move chart objects
1497 bReturn = impl_moveOrResizeObject(
1498 m_aSelection.getSelectedCID(), MOVE_OBJECT, fShiftAmountX, fShiftAmountY );
1499 }
1500 else
1501 {
1502 //move additional shapes
1503 uno::Reference< drawing::XShape > xShape( m_aSelection.getSelectedAdditionalShape() );
1504 if( xShape.is() )
1505 {
1506 awt::Point aPos( xShape->getPosition() );
1507 awt::Size aSize( xShape->getSize() );
1508 awt::Size aPageSize( ChartModelHelper::getPageSize( getModel() ) );
1509 aPos.X = static_cast< long >( static_cast< double >( aPos.X ) + fShiftAmountX );
1510 aPos.Y = static_cast< long >( static_cast< double >( aPos.Y ) + fShiftAmountY );
1511 if( aPos.X + aSize.Width > aPageSize.Width )
1512 aPos.X = aPageSize.Width - aSize.Width;
1513 if( aPos.X < 0 )
1514 aPos.X = 0;
1515 if( aPos.Y + aSize.Height > aPageSize.Height )
1516 aPos.Y = aPageSize.Height - aSize.Height;
1517 if( aPos.Y < 0 )
1518 aPos.Y = 0;
1519
1520 xShape->setPosition( aPos );
1521 }
1522 }
1523 }
1524 }
1525 }
1526 }
1527
1528 // dumping the shape
1529 if( !bReturn && bCtrl && nCode == KEY_F12)
1530 {
1531 uno::Reference< qa::XDumper > xChartModel( getModel(), uno::UNO_QUERY );
1532 if(xChartModel.is())
1533 {
1534 OUString aDump = xChartModel->dump();
1535 SAL_WARN("chart2", aDump);
1536 }
1537 }
1538
1539 // text edit
1540 if( ! bReturn &&
1541 nCode == KEY_F2 )
1542 {
1543 if( eObjectType == OBJECTTYPE_TITLE )
1544 {
1545 executeDispatch_EditText();
1546 bReturn = true;
1547 }
1548 }
1549
1550 // deactivate inplace mode (this code should be unnecessary, but
1551 // unfortunately is not)
1552 if( ! bReturn &&
1553 nCode == KEY_ESCAPE )
1554 {
1555 uno::Reference< frame::XDispatchHelper > xDispatchHelper( frame::DispatchHelper::create(m_xCC) );
1556 uno::Sequence< beans::PropertyValue > aArgs;
1557 xDispatchHelper->executeDispatch(
1558 uno::Reference< frame::XDispatchProvider >( m_xFrame, uno::UNO_QUERY ),
1559 ".uno:TerminateInplaceActivation",
1560 "_parent",
1561 frame::FrameSearchFlag::PARENT,
1562 aArgs );
1563 bReturn = true;
1564 }
1565
1566 if( ! bReturn &&
1567 (nCode == KEY_DELETE || nCode == KEY_BACKSPACE ))
1568 {
1569 bReturn = executeDispatch_Delete();
1570 if( ! bReturn )
1571 {
1572 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pChartWindow->GetFrameWeld(),
1573 VclMessageType::Info, VclButtonsType::Ok,
1574 SchResId(STR_ACTION_NOTPOSSIBLE)));
1575 xInfoBox->run();
1576 }
1577 }
1578
1579 return bReturn;
1580 }
1581
1582 bool ChartController::requestQuickHelp(
1583 ::Point aAtLogicPosition,
1584 bool bIsBalloonHelp,
1585 OUString & rOutQuickHelpText,
1586 awt::Rectangle & rOutEqualRect )
1587 {
1588 uno::Reference< frame::XModel > xChartModel;
1589 if( m_aModel.is())
1590 xChartModel.set( getModel() );
1591 if( !xChartModel.is())
1592 return false;
1593
1594 // help text
1595 OUString aCID;
1596 if( m_pDrawViewWrapper )
1597 {
1598 aCID = SelectionHelper::getHitObjectCID(
1599 aAtLogicPosition, *m_pDrawViewWrapper );
1600 }
1601 bool bResult( !aCID.isEmpty());
1602
1603 if( bResult )
1604 {
1605 // get help text
1606 rOutQuickHelpText = ObjectNameProvider::getHelpText( aCID, xChartModel, bIsBalloonHelp /* bVerbose */ );
1607
1608 // set rectangle
1609 ExplicitValueProvider * pValueProvider(
1610 comphelper::getUnoTunnelImplementation<ExplicitValueProvider>( m_xChartView ));
1611 if( pValueProvider )
1612 rOutEqualRect = pValueProvider->getRectangleOfObject( aCID, true );
1613 }
1614
1615 return bResult;
1616 }
1617
1618 // XSelectionSupplier (optional interface)
1619 sal_Bool SAL_CALL ChartController::select( const uno::Any& rSelection )
1620 {
1621 bool bSuccess = false;
1622
1623 if ( rSelection.hasValue() )
1624 {
1625 const uno::Type& rType = rSelection.getValueType();
1626 if ( rType == cppu::UnoType< OUString >::get() )
1627 {
1628 OUString aNewCID;
1629 if ( ( rSelection >>= aNewCID ) && m_aSelection.setSelection( aNewCID ) )
1630 {
1631 bSuccess = true;
1632 }
1633 }
1634 else if ( rType == cppu::UnoType<drawing::XShape>::get() )
1635 {
1636 uno::Reference< drawing::XShape > xShape;
1637 if ( ( rSelection >>= xShape ) && m_aSelection.setSelection( xShape ) )
1638 {
1639 bSuccess = true;
1640 }
1641 }
1642 }
1643 else
1644 {
1645 if ( m_aSelection.hasSelection() )
1646 {
1647 m_aSelection.clearSelection();
1648 bSuccess = true;
1649 }
1650 }
1651
1652 if ( bSuccess )
1653 {
1654 SolarMutexGuard aGuard;
1655 if ( m_pDrawViewWrapper && m_pDrawViewWrapper->IsTextEdit() )
1656 {
1657 EndTextEdit();
1658 }
1659 impl_selectObjectAndNotiy();
1660 auto pChartWindow(GetChartWindow());
1661 if ( pChartWindow )
1662 {
1663 pChartWindow->Invalidate();
1664 }
1665 return true;
1666 }
1667
1668 return false;
1669 }
1670
1671 uno::Any SAL_CALL ChartController::getSelection()
1672 {
1673 uno::Any aReturn;
1674 if ( m_aSelection.hasSelection() )
1675 {
1676 OUString aCID( m_aSelection.getSelectedCID() );
1677 if ( !aCID.isEmpty() )
1678 {
1679 if ( comphelper::LibreOfficeKit::isActive() )
1680 {
1681 sal_Int32 nPos = aCID.lastIndexOf('/');
1682 OUString sFirst = aCID.copy(0, nPos);
1683 OUString sSecond = aCID.copy(nPos);
1684 aCID = sFirst +
1685 "/Draggable=" + OUString::number(static_cast<int>(isSelectedObjectDraggable())) +
1686 ":Resizable=" + OUString::number(static_cast<int>(isSelectedObjectResizable())) +
1687 ":Rotatable=" + OUString::number(static_cast<int>(isSelectedObjectRotatable())) +
1688 sSecond;
1689 }
1690 aReturn <<= aCID;
1691 }
1692 else
1693 {
1694 // #i12587# support for shapes in chart
1695 aReturn <<= m_aSelection.getSelectedAdditionalShape();
1696 }
1697 }
1698 return aReturn;
1699 }
1700
1701 void SAL_CALL ChartController::addSelectionChangeListener( const uno::Reference<view::XSelectionChangeListener> & xListener )
1702 {
1703 SolarMutexGuard aGuard;
1704 if( impl_isDisposedOrSuspended() )//@todo? allow adding of listeners in suspend mode?
1705 return; //behave passive if already disposed or suspended
1706
1707 //--add listener
1708 m_aLifeTimeManager.m_aListenerContainer.addInterface( cppu::UnoType<view::XSelectionChangeListener>::get(), xListener );
1709 }
1710
1711 void SAL_CALL ChartController::removeSelectionChangeListener( const uno::Reference<view::XSelectionChangeListener> & xListener )
1712 {
1713 SolarMutexGuard aGuard;
1714 if( impl_isDisposedOrSuspended() ) //@todo? allow removing of listeners in suspend mode?
1715 return; //behave passive if already disposed or suspended
1716
1717 //--remove listener
1718 m_aLifeTimeManager.m_aListenerContainer.removeInterface( cppu::UnoType<view::XSelectionChangeListener>::get(), xListener );
1719 }
1720
1721 void ChartController::impl_notifySelectionChangeListeners()
1722 {
1723 ::cppu::OInterfaceContainerHelper* pIC = m_aLifeTimeManager.m_aListenerContainer
1724 .getContainer( cppu::UnoType<view::XSelectionChangeListener>::get() );
1725 if( pIC )
1726 {
1727 uno::Reference< view::XSelectionSupplier > xSelectionSupplier(this);
1728 lang::EventObject aEvent( xSelectionSupplier );
1729 ::cppu::OInterfaceIteratorHelper aIt( *pIC );
1730 while( aIt.hasMoreElements() )
1731 {
1732 uno::Reference< view::XSelectionChangeListener > xListener( aIt.next(), uno::UNO_QUERY );
1733 if( xListener.is() )
1734 xListener->selectionChanged( aEvent );
1735 }
1736 }
1737 }
1738
1739 void ChartController::impl_selectObjectAndNotiy()
1740 {
1741 {
1742 SolarMutexGuard aGuard;
1743 DrawViewWrapper* pDrawViewWrapper = m_pDrawViewWrapper.get();
1744 if( pDrawViewWrapper )
1745 {
1746 pDrawViewWrapper->SetDragMode( m_eDragMode );
1747 m_aSelection.applySelection( m_pDrawViewWrapper.get() );
1748 }
1749 }
1750 impl_notifySelectionChangeListeners();
1751 }
1752
1753 bool ChartController::impl_moveOrResizeObject(
1754 const OUString & rCID,
1755 eMoveOrResizeType eType,
1756 double fAmountLogicX,
1757 double fAmountLogicY )
1758 {
1759 bool bResult = false;
1760 bool bNeedResize = ( eType == CENTERED_RESIZE_OBJECT );
1761
1762 uno::Reference< frame::XModel > xChartModel( getModel() );
1763 uno::Reference< beans::XPropertySet > xObjProp(
1764 ObjectIdentifier::getObjectPropertySet( rCID, xChartModel ));
1765 if( xObjProp.is())
1766 {
1767 awt::Size aRefSize = ChartModelHelper::getPageSize( xChartModel );
1768
1769 chart2::RelativePosition aRelPos;
1770 chart2::RelativeSize aRelSize;
1771 bool bDeterminePos = !(xObjProp->getPropertyValue( "RelativePosition") >>= aRelPos);
1772 bool bDetermineSize = !bNeedResize || !(xObjProp->getPropertyValue( "RelativeSize") >>= aRelSize);
1773
1774 if( ( bDeterminePos || bDetermineSize ) &&
1775 ( aRefSize.Width > 0 && aRefSize.Height > 0 ) )
1776 {
1777 ExplicitValueProvider * pValueProvider(
1778 comphelper::getUnoTunnelImplementation<ExplicitValueProvider>( m_xChartView ));
1779 if( pValueProvider )
1780 {
1781 awt::Rectangle aRect( pValueProvider->getRectangleOfObject( rCID ));
1782 double fWidth = static_cast< double >( aRefSize.Width );
1783 double fHeight = static_cast< double >( aRefSize.Height );
1784 if( bDetermineSize )
1785 {
1786 aRelSize.Primary = static_cast< double >( aRect.Width ) / fWidth;
1787 aRelSize.Secondary = static_cast< double >( aRect.Height ) / fHeight;
1788 }
1789 if( bDeterminePos )
1790 {
1791 if( bNeedResize && aRelSize.Primary > 0.0 && aRelSize.Secondary > 0.0 )
1792 {
1793 aRelPos.Primary = (static_cast< double >( aRect.X ) / fWidth) +
1794 (aRelSize.Primary / 2.0);
1795 aRelPos.Secondary = (static_cast< double >( aRect.Y ) / fHeight) +
1796 (aRelSize.Secondary / 2.0);
1797 aRelPos.Anchor = drawing::Alignment_CENTER;
1798 }
1799 else
1800 {
1801 aRelPos.Primary = static_cast< double >( aRect.X ) / fWidth;
1802 aRelPos.Secondary = static_cast< double >( aRect.Y ) / fHeight;
1803 aRelPos.Anchor = drawing::Alignment_TOP_LEFT;
1804 }
1805 }
1806 }
1807 }
1808
1809 if( eType == CENTERED_RESIZE_OBJECT )
1810 bResult = lcl_GrowAndShiftLogic( aRelPos, aRelSize, aRefSize, fAmountLogicX, fAmountLogicY );
1811 else if( eType == MOVE_OBJECT )
1812 bResult = lcl_MoveObjectLogic( aRelPos, aRelSize, aRefSize, fAmountLogicX, fAmountLogicY );
1813
1814 if( bResult )
1815 {
1816 ActionDescriptionProvider::ActionType eActionType(ActionDescriptionProvider::ActionType::Move);
1817 if( bNeedResize )
1818 eActionType = ActionDescriptionProvider::ActionType::Resize;
1819
1820 ObjectType eObjectType = ObjectIdentifier::getObjectType( rCID );
1821 UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription(
1822 eActionType, ObjectNameProvider::getName( eObjectType )), m_xUndoManager );
1823 {
1824 ControllerLockGuardUNO aCLGuard( xChartModel );
1825 xObjProp->setPropertyValue( "RelativePosition", uno::Any( aRelPos ));
1826 if( bNeedResize || (eObjectType == OBJECTTYPE_DIAGRAM) )//Also set an explicit size at the diagram when an explicit position is set
1827 xObjProp->setPropertyValue( "RelativeSize", uno::Any( aRelSize ));
1828 }
1829 aUndoGuard.commit();
1830 }
1831 }
1832 return bResult;
1833 }
1834
1835 bool ChartController::impl_DragDataPoint( const OUString & rCID, double fAdditionalOffset )
1836 {
1837 bool bResult = false;
1838 if( fAdditionalOffset < -1.0 || fAdditionalOffset > 1.0 || fAdditionalOffset == 0.0 )
1839 return bResult;
1840
1841 sal_Int32 nDataPointIndex = ObjectIdentifier::getIndexFromParticleOrCID( rCID );
1842 uno::Reference< chart2::XDataSeries > xSeries(
1843 ObjectIdentifier::getDataSeriesForCID( rCID, getModel() ));
1844 if( xSeries.is())
1845 {
1846 try
1847 {
1848 uno::Reference< beans::XPropertySet > xPointProp( xSeries->getDataPointByIndex( nDataPointIndex ));
1849 double fOffset = 0.0;
1850 if( xPointProp.is() &&
1851 (xPointProp->getPropertyValue( "Offset" ) >>= fOffset ) &&
1852 (( fAdditionalOffset > 0.0 && fOffset < 1.0 ) || (fOffset > 0.0)) )
1853 {
1854 fOffset += fAdditionalOffset;
1855 if( fOffset > 1.0 )
1856 fOffset = 1.0;
1857 else if( fOffset < 0.0 )
1858 fOffset = 0.0;
1859 xPointProp->setPropertyValue( "Offset", uno::Any( fOffset ));
1860 bResult = true;
1861 }
1862 }
1863 catch( const uno::Exception & )
1864 {
1865 DBG_UNHANDLED_EXCEPTION("chart2");
1866 }
1867 }
1868
1869 return bResult;
1870 }
1871
1872 void ChartController::impl_SetMousePointer( const MouseEvent & rEvent )
1873 {
1874 SolarMutexGuard aGuard;
1875 auto pChartWindow(GetChartWindow());
1876
1877 if (!m_pDrawViewWrapper || !pChartWindow)
1878 return;
1879
1880 Point aMousePos( pChartWindow->PixelToLogic( rEvent.GetPosPixel()));
1881 sal_uInt16 nModifier = rEvent.GetModifier();
1882 bool bLeftDown = rEvent.IsLeft();
1883
1884 // Check if object is for field button and set the normal arrow pointer in this case
1885 SdrObject* pObject = m_pDrawViewWrapper->getHitObject(aMousePos);
1886 if (pObject && pObject->GetName().startsWith("FieldButton"))
1887 {
1888 pChartWindow->SetPointer(PointerStyle::Arrow);
1889 return;
1890 }
1891
1892 if ( m_pDrawViewWrapper->IsTextEdit() )
1893 {
1894 if( m_pDrawViewWrapper->IsTextEditHit( aMousePos ) )
1895 {
1896 pChartWindow->SetPointer( m_pDrawViewWrapper->GetPreferredPointer(
1897 aMousePos, pChartWindow, nModifier, bLeftDown ) );
1898 return;
1899 }
1900 }
1901 else if( m_pDrawViewWrapper->IsAction() )
1902 {
1903 return;//don't change pointer during running action
1904 }
1905
1906 SdrHdl* pHitSelectionHdl = nullptr;
1907 if( m_aSelection.isResizeableObjectSelected() )
1908 pHitSelectionHdl = m_pDrawViewWrapper->PickHandle( aMousePos );
1909
1910 if( pHitSelectionHdl )
1911 {
1912 PointerStyle aPointer = m_pDrawViewWrapper->GetPreferredPointer(
1913 aMousePos, pChartWindow, nModifier, bLeftDown );
1914 bool bForceArrowPointer = false;
1915
1916 ObjectIdentifier aOID( m_aSelection.getSelectedOID() );
1917
1918 switch( aPointer)
1919 {
1920 case PointerStyle::NSize:
1921 case PointerStyle::SSize:
1922 case PointerStyle::WSize:
1923 case PointerStyle::ESize:
1924 case PointerStyle::NWSize:
1925 case PointerStyle::NESize:
1926 case PointerStyle::SWSize:
1927 case PointerStyle::SESize:
1928 if( ! m_aSelection.isResizeableObjectSelected() )
1929 bForceArrowPointer = true;
1930 break;
1931 case PointerStyle::Move:
1932 if ( !aOID.isDragableObject() )
1933 bForceArrowPointer = true;
1934 break;
1935 case PointerStyle::MovePoint:
1936 case PointerStyle::MoveBezierWeight:
1937 // there is no point-editing in a chart
1938 // the PointerStyle::MoveBezierWeight appears in 3d data points
1939 bForceArrowPointer = true;
1940 break;
1941 default:
1942 break;
1943 }
1944
1945 if( bForceArrowPointer )
1946 pChartWindow->SetPointer( PointerStyle::Arrow );
1947 else
1948 pChartWindow->SetPointer( aPointer );
1949
1950 return;
1951 }
1952
1953 // #i12587# support for shapes in chart
1954 if ( m_eDrawMode == CHARTDRAW_INSERT &&
1955 ( !m_pDrawViewWrapper->IsMarkedHit( aMousePos ) || !m_aSelection.isDragableObjectSelected() ) )
1956 {
1957 PointerStyle ePointerStyle = PointerStyle::DrawRect;
1958 SdrObjKind eKind = static_cast< SdrObjKind >( m_pDrawViewWrapper->GetCurrentObjIdentifier() );
1959 switch ( eKind )
1960 {
1961 case OBJ_LINE:
1962 {
1963 ePointerStyle = PointerStyle::DrawLine;
1964 }
1965 break;
1966 case OBJ_RECT:
1967 case OBJ_CUSTOMSHAPE:
1968 {
1969 ePointerStyle = PointerStyle::DrawRect;
1970 }
1971 break;
1972 case OBJ_CIRC:
1973 {
1974 ePointerStyle = PointerStyle::DrawEllipse;
1975 }
1976 break;
1977 case OBJ_FREELINE:
1978 {
1979 ePointerStyle = PointerStyle::DrawPolygon;
1980 }
1981 break;
1982 case OBJ_TEXT:
1983 {
1984 ePointerStyle = PointerStyle::DrawText;
1985 }
1986 break;
1987 case OBJ_CAPTION:
1988 {
1989 ePointerStyle = PointerStyle::DrawCaption;
1990 }
1991 break;
1992 default:
1993 {
1994 ePointerStyle = PointerStyle::DrawRect;
1995 }
1996 break;
1997 }
1998 pChartWindow->SetPointer( ePointerStyle );
1999 return;
2000 }
2001
2002 OUString aHitObjectCID(
2003 SelectionHelper::getHitObjectCID(
2004 aMousePos, *m_pDrawViewWrapper, true /*bGetDiagramInsteadOf_Wall*/ ));
2005
2006 if( m_pDrawViewWrapper->IsTextEdit() )
2007 {
2008 if( aHitObjectCID == m_aSelection.getSelectedCID() )
2009 {
2010 pChartWindow->SetPointer( PointerStyle::Arrow );
2011 return;
2012 }
2013 }
2014
2015 if( aHitObjectCID.isEmpty() )
2016 {
2017 //additional shape was hit
2018 pChartWindow->SetPointer( PointerStyle::Move );
2019 }
2020 else if( ObjectIdentifier::isDragableObject( aHitObjectCID ) )
2021 {
2022 if( (m_eDragMode == SdrDragMode::Rotate)
2023 && SelectionHelper::isRotateableObject( aHitObjectCID
2024 , getModel() ) )
2025 pChartWindow->SetPointer( PointerStyle::Rotate );
2026 else
2027 {
2028 ObjectType eHitObjectType = ObjectIdentifier::getObjectType( aHitObjectCID );
2029 if( eHitObjectType == OBJECTTYPE_DATA_POINT )
2030 {
2031 if( !ObjectIdentifier::areSiblings(aHitObjectCID,m_aSelection.getSelectedCID())
2032 && !ObjectIdentifier::areIdenticalObjects(aHitObjectCID,m_aSelection.getSelectedCID()) )
2033 {
2034 pChartWindow->SetPointer( PointerStyle::Arrow );
2035 return;
2036 }
2037 }
2038 pChartWindow->SetPointer( PointerStyle::Move );
2039 }
2040 }
2041 else
2042 pChartWindow->SetPointer( PointerStyle::Arrow );
2043 }
2044
2045 css::uno::Reference<css::uno::XInterface> const & ChartController::getChartView() const
2046 {
2047 return m_xChartView;
2048 }
2049
2050 void ChartController::sendPopupRequest(OUString const & rCID, tools::Rectangle aRectangle)
2051 {
2052 ChartModel* pChartModel = dynamic_cast<ChartModel*>(m_aModel->getModel().get());
2053 if (!pChartModel)
2054 return;
2055
2056 uno::Reference<chart2::data::XPivotTableDataProvider> xPivotTableDataProvider;
2057 xPivotTableDataProvider.set(pChartModel->getDataProvider(), uno::UNO_QUERY);
2058 if (!xPivotTableDataProvider.is())
2059 return;
2060
2061 OUString sPivotTableName = xPivotTableDataProvider->getPivotTableName();
2062
2063 PopupRequest* pPopupRequest = dynamic_cast<PopupRequest*>(pChartModel->getPopupRequest().get());
2064 if (!pPopupRequest)
2065 return;
2066
2067 // Get dimension index from CID
2068 sal_Int32 nStartPos = rCID.lastIndexOf('.');
2069 nStartPos++;
2070 sal_Int32 nEndPos = rCID.getLength();
2071 OUString sDimensionIndex = rCID.copy(nStartPos, nEndPos - nStartPos);
2072 sal_Int32 nDimensionIndex = sDimensionIndex.toInt32();
2073
2074 awt::Rectangle xRectangle {
2075 sal_Int32(aRectangle.Left()),
2076 sal_Int32(aRectangle.Top()),
2077 sal_Int32(aRectangle.GetWidth()),
2078 sal_Int32(aRectangle.GetHeight())
2079 };
2080
2081 uno::Sequence<beans::PropertyValue> aCallbackData = comphelper::InitPropertySequence(
2082 {
2083 {"Rectangle", uno::makeAny<awt::Rectangle>(xRectangle)},
2084 {"DimensionIndex", uno::makeAny<sal_Int32>(nDimensionIndex)},
2085 {"PivotTableName", uno::makeAny<OUString>(sPivotTableName)},
2086 });
2087
2088 pPopupRequest->getCallback()->notify(uno::makeAny(aCallbackData));
2089 }
2090
2091 } //namespace chart
2092
2093 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE