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