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