mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
14c4c57de261341ebb6bf4f5d022295b86b5470d
libreoffice/chart2/source/controller/main/ChartController.cxx

1131 lines
37 KiB
C++
Raw Normal View History

initial import
2003-10-06 08:58:36 +00:00
/*************************************************************************
*
* $RCSfile: ChartController.cxx,v $
*
added SID_TEXTEDIT support
2003-10-28 15:06:11 +00:00
* $Revision: 1.4 $
initial import
2003-10-06 08:58:36 +00:00
*
added SID_TEXTEDIT support
2003-10-28 15:06:11 +00:00
* last change: $Author: iha $ $Date: 2003-10-28 16:06:11 $
initial import
2003-10-06 08:58:36 +00:00
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2003 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#include "ChartController.hxx"
#include "servicenames.hxx"
preparation for ItemConverter to be moved to a different module
2003-10-07 14:39:56 +00:00
#include "SchItemPool.hxx"
initial import
2003-10-06 08:58:36 +00:00
#include "InlineContainer.hxx"
#include "Chart.hrc"
#include "ResId.hxx"
#include "SchSlotIds.hxx"
#include "chartview/ChartView.hxx"
#include "ChartWindow.hxx"
#include "DrawModelWrapper.hxx"
#include "DrawViewWrapper.hxx"
#include "macros.hxx"
#include "chartview/NumberFormatterWrapper.hxx"
#include "dlg_ChartType.hxx"
#include "ChartTypeItemConverter.hxx"
//for SID_CHARMAP:
#ifndef _SVX_SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#ifndef _DRAFTS_COM_SUN_STAR_CHART2_XCHARTDOCUMENT_HPP_
#include <drafts/com/sun/star/chart2/XChartDocument.hpp>
#endif
#ifndef _DRAFTS_COM_SUN_STAR_CHART2_XSTACKABLESCALEGROUP_HPP_
#include <drafts/com/sun/star/chart2/XStackableScaleGroup.hpp>
#endif
//-------
// header for define RET_OK
#ifndef _SV_MSGBOX_HXX
#include <vcl/msgbox.hxx>
#endif
//-------
//-------
#ifndef _TOOLKIT_AWT_VCLXWINDOW_HXX_
#include <toolkit/awt/vclxwindow.hxx>
#endif
#ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
#include <toolkit/helper/vclunohelper.hxx>
#endif
#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif
//-------
#ifndef _COMPHELPER_PROCESSFACTORY_HXX_
#include <comphelper/processfactory.hxx>
#endif
#ifndef _COM_SUN_STAR_UTIL_XURLTRANSFORMER_HPP_
#include <com/sun/star/util/XURLTransformer.hpp>
#endif
//.............................................................................
namespace chart
{
//.............................................................................
using namespace ::com::sun::star;
using namespace ::drafts::com::sun::star::chart2;
//-----------------------------------------------------------------
// ChartController Constructor and Destructor
//-----------------------------------------------------------------
ChartController::ChartController(uno::Reference<uno::XComponentContext> const & xContext)
: m_aLifeTimeManager( NULL )
ItemConverter rework/compiler warnings removed (gcc Linux)
2003-10-07 16:18:46 +00:00
, m_bSuspended( sal_False )
, m_bCanClose( sal_True )
, m_xCC(xContext) //@todo is it allowed to hold this context??
initial import
2003-10-06 08:58:36 +00:00
, m_xFrame( NULL )
, m_aModelMutex()
, m_aModel( NULL, m_aModelMutex )
, m_pChartWindow( NULL )
, m_xViewWindow( NULL )
, m_pChartView( NULL )
, m_pDrawModelWrapper( NULL )
, m_pDrawViewWrapper(NULL)
, m_bViewDirty( false )
, m_pNumberFormatterWrapper(NULL)
{
//@todo
m_pNumberFormatterWrapper = new NumberFormatterWrapper();
}
ChartController::~ChartController()
{
impl_deleteView();
//m_pChartWindow is deleted via UNO by Window hierarchy or Framework
if(m_pNumberFormatterWrapper)
delete m_pNumberFormatterWrapper;
//@todo ?
}
//-----------------------------------------------------------------
ChartController::RefCountable::RefCountable() : m_nRefCount(0)
{
}
ChartController::RefCountable::~RefCountable()
{
}
void ChartController::RefCountable::acquire()
{
m_nRefCount++;
}
void ChartController::RefCountable::release()
{
m_nRefCount--;
if(!m_nRefCount)
delete this;
}
//-----------------------------------------------------------------
ChartController::TheModel::TheModel( const uno::Reference< frame::XModel > & xModel )
: m_xModel( xModel )
, m_xCloseable( NULL )
, m_bOwnership( sal_True )
, m_bOwnershipIsWellKnown( sal_False )
{
m_xCloseable =
uno::Reference< util::XCloseable >( xModel, uno::UNO_QUERY );
}
ChartController::TheModel::~TheModel()
{
}
void ChartController::TheModel::SetOwnerShip( sal_Bool bGetsOwnership )
{
m_bOwnership = bGetsOwnership;
m_bOwnershipIsWellKnown = sal_True;
}
void ChartController::TheModel::addListener( ChartController* pController )
{
if(m_xCloseable.is())
{
//if you need to be able to veto against the destruction of the model
// you must add as a close listener
//otherwise you 'can' add as closelistener or 'must' add as dispose event listener
m_xCloseable->addCloseListener(
static_cast<util::XCloseListener*>(pController) );
}
else if( m_xModel.is() )
{
//we need to add as dispose event listener
m_xModel->addEventListener(
static_cast<lang::XEventListener*>(pController) );
}
}
void ChartController::TheModel::removeListener( ChartController* pController )
{
if(m_xCloseable.is())
m_xCloseable->removeCloseListener(
static_cast<util::XCloseListener*>(pController) );
else if( m_xModel.is() )
m_xModel->removeEventListener(
static_cast<lang::XEventListener*>(pController) );
}
void ChartController::TheModel::tryTermination()
{
if(!m_bOwnership)
return;
try
{
if(m_xCloseable.is())
{
try
{
//@todo ? are we allowed to use sal_True here if we have the explicit ownership?
//I think yes, because there might be other closelistners later in the list which might be interested still
//but make sure that we do not throw the CloseVetoException here ourselfs
//so stop listening before trying to terminate or check the source of queryclosing event
m_xCloseable->close(sal_True);
m_bOwnership = false;
m_bOwnershipIsWellKnown = sal_True;
}
catch( util::CloseVetoException& )
{
//since we have indicated to give up the ownership with paramter true in close call
//the one who has thrown the CloseVetoException is the new owner
OSL_ENSURE( !m_bOwnership,
"INFO: a well known owner has catched a CloseVetoException after calling close(true)" );
m_bOwnership = false;
m_bOwnershipIsWellKnown = sal_True;
return;
}
}
else if( m_xModel.is() )
{
//@todo correct??
m_xModel->dispose();
return;
}
}
catch( uno::Exception& ex)
{
OSL_ENSURE( sal_False, ( rtl::OString("Termination of model failed: ")
+ rtl::OUStringToOString( ex.Message, RTL_TEXTENCODING_ASCII_US ) ).getStr() );
}
}
//-----------------------------------------------------------------
ChartController::TheModelRef::TheModelRef( TheModel* pTheModel, ::osl::Mutex& rMutex )
: m_pTheModel(pTheModel), m_rModelMutex(rMutex)
{
::osl::Guard< ::osl::Mutex > aGuard( m_rModelMutex );
if(m_pTheModel)
m_pTheModel->acquire();
}
ChartController::TheModelRef::TheModelRef( const TheModelRef& rTheModel, ::osl::Mutex& rMutex )
: m_rModelMutex(rMutex)
{
::osl::Guard< ::osl::Mutex > aGuard( m_rModelMutex );
m_pTheModel=rTheModel.operator->();
if(m_pTheModel)
m_pTheModel->acquire();
}
ChartController::TheModelRef& ChartController::TheModelRef::operator=(TheModel* pTheModel)
{
::osl::Guard< ::osl::Mutex > aGuard( m_rModelMutex );
if(m_pTheModel==pTheModel)
return *this;
if(m_pTheModel)
m_pTheModel->release();
m_pTheModel=pTheModel;
if(m_pTheModel)
m_pTheModel->acquire();
return *this;
}
ChartController::TheModelRef& ChartController::TheModelRef::operator=(const TheModelRef& rTheModel)
{
::osl::Guard< ::osl::Mutex > aGuard( m_rModelMutex );
TheModel* pNew=rTheModel.operator->();
if(m_pTheModel==pNew)
return *this;
if(m_pTheModel)
m_pTheModel->release();
m_pTheModel=pNew;
if(m_pTheModel)
m_pTheModel->acquire();
return *this;
}
ChartController::TheModelRef::~TheModelRef()
{
::osl::Guard< ::osl::Mutex > aGuard( m_rModelMutex );
if(m_pTheModel)
m_pTheModel->release();
}
sal_Bool ChartController::TheModelRef::is() const
{
return (m_pTheModel != 0);
}
//-----------------------------------------------------------------
// private methods
//-----------------------------------------------------------------
sal_Bool ChartController
::impl_isDisposedOrSuspended()
{
if( m_aLifeTimeManager.impl_isDisposed() )
return sal_True;
if( m_bSuspended )
{
OSL_ENSURE( sal_False, "This Controller is suspended" );
return sal_True;
}
return sal_False;
}
//-----------------------------------------------------------------
// lang::XServiceInfo
//-----------------------------------------------------------------
APPHELPER_XSERVICEINFO_IMPL(ChartController,CHART_CONTROLLER_SERVICE_IMPLEMENTATION_NAME)
uno::Sequence< rtl::OUString > ChartController
::getSupportedServiceNames_Static()
{
uno::Sequence< rtl::OUString > aSNS( 2 );
aSNS.getArray()[ 0 ] = CHART_CONTROLLER_SERVICE_NAME;
aSNS.getArray()[ 1 ] = ::rtl::OUString::createFromAscii("com.sun.star.frame.Controller");
//// @todo : add additional services if you support any further
return aSNS;
}
//-----------------------------------------------------------------
// XController
//-----------------------------------------------------------------
void SAL_CALL ChartController
::attachFrame( const uno::Reference<frame::XFrame>& xFrame )
throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() ) //@todo? allow attaching the frame while suspended?
return; //behave passive if already disposed or suspended
if(m_xFrame.is()) //what happens, if we do have a Frame already??
{
//@todo? throw exception?
OSL_ENSURE( sal_False, "there is already a frame attached to the controller" );
return;
}
//--attach frame
m_xFrame = xFrame; //the frameloader is responsible to call xFrame->setComponent
//add as disposelistener to the frame (due to persistent reference) ??...:
//the frame is considered to be owner of this controller and will live longer than we do
//the frame or the disposer of the frame has the duty to call suspend and dispose on this object
//so we do not need to add as lang::XEventListener for DisposingEvents right?
//@todo nothing right???
//--------------------------------------------------
//create view @todo is this the correct place here??
Window* pParent = NULL;
//get the window parent from the frame to use as parent for our new window
if(xFrame.is())
{
uno::Reference< awt::XWindow > xContainerWindow = xFrame->getContainerWindow();
VCLXWindow* pParentComponent = VCLXWindow::GetImplementation(xContainerWindow);
pParentComponent->setVisible(sal_True);
pParent = VCLUnoHelper::GetWindow( xContainerWindow );
}
if(m_pChartWindow)
{
//@todo delete ...
}
{
// calls to VCL
::vos::OGuard aSolarGuard( Application::GetSolarMutex());
m_pChartWindow = new ChartWindow(this,pParent,pParent?pParent->GetStyle():0);
m_xViewWindow = uno::Reference< awt::XWindow >( m_pChartWindow->GetComponentInterface(), uno::UNO_QUERY );
m_pChartWindow->Show();
}
impl_tryInitializeView();
{//create the menu
util::URL aURL( SchResId(RID_MENU).getURL() );
uno::Reference< lang::XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory();
uno::Reference< util::XURLTransformer > xTrans(
xMgr->createInstance( ::rtl::OUString::createFromAscii(
"com.sun.star.util.URLTransformer") ), uno::UNO_QUERY );
if( xTrans.is() )
{
// Datei laden
xTrans->parseStrict( aURL );
uno::Reference< frame::XDispatchProvider > xProv( xFrame, uno::UNO_QUERY );
if ( xProv.is() )
{
uno::Reference< frame::XDispatch > aDisp =
xProv->queryDispatch( aURL,
::rtl::OUString::createFromAscii("_menubar"), 12 );
if ( aDisp.is() )
aDisp->dispatch( aURL, uno::Sequence<beans::PropertyValue>() );
}
}
}
}
void SAL_CALL ChartController
::impl_rebuildView()
throw(uno::RuntimeException)
{
m_bViewDirty = false;
impl_deleteView();
impl_tryInitializeView();
if( m_aSelectedObjectCID.getLength() )
{
//@todo reselect object
m_aSelectedObjectCID = C2U("");
}
}
void SAL_CALL ChartController
::impl_deleteView()
throw(uno::RuntimeException)
{
delete m_pChartView; m_pChartView = NULL;
delete m_pDrawViewWrapper; m_pDrawViewWrapper = NULL;
delete m_pDrawModelWrapper; m_pDrawModelWrapper = NULL;
}
sal_Bool SAL_CALL ChartController
::impl_tryInitializeView()
throw(uno::RuntimeException)
{
osl::ClearableGuard< osl::Mutex > aGuard( m_aControllerMutex );
if(!m_pChartWindow || !m_aModel.is() )
return sal_False;
m_pDrawModelWrapper = new DrawModelWrapper(m_xCC
preparation for ItemConverter to be moved to a different module
2003-10-07 14:39:56 +00:00
,wrapper::SchItemPool::CreateSchItemPool());
initial import
2003-10-06 08:58:36 +00:00
uno::Reference< frame::XModel > xDrawModel = m_pDrawModelWrapper->getUnoModel();
if( xDrawModel.is())
xDrawModel->lockControllers();
m_pChartView = ChartView::createView( m_xCC, m_aModel->getModel()
, uno::Reference<drawing::XDrawPagesSupplier>::query( xDrawModel )
, m_pNumberFormatterWrapper );
//OutputDevice* pOutDev = m_pDrawViewWrapper->GetWin(0);
Size aPageSize = m_pChartWindow->GetOutputSize();
m_pChartView->create( awt::Size( aPageSize.Width(), aPageSize.Height() ) );
// m_pChartWindow->SetChartView(m_pChartView);//enable event flow from window to View (Window knows View)
//create draw view:
m_pDrawViewWrapper = new DrawViewWrapper(&m_pDrawModelWrapper->getSdrModel(),m_pChartWindow);
//test:
//Rectangle aTest = m_pDrawViewWrapper->GetWorkArea();
//m_pDrawViewWrapper->SetWorkArea(pOutDev->PixelToLogic(Rectangle(rOfs, rSize)));
if( xDrawModel.is())
{
xDrawModel->unlockControllers();
m_pChartWindow->Invalidate();
}
return sal_True;
}
sal_Bool SAL_CALL ChartController
::attachModel( const uno::Reference< frame::XModel > & xModel )
throw(uno::RuntimeException)
{
//is called to attach the controller to a new model.
//return true if attach was successfully, false otherwise (e.g. if you do not work with a model)
osl::ClearableGuard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() ) //@todo? allow attaching a new model while suspended?
return sal_False; //behave passive if already disposed or suspended
aGuard.clear();
TheModelRef aNewModelRef( new TheModel( xModel), m_aModelMutex);
TheModelRef aOldModelRef(m_aModel,m_aModelMutex);
m_aModel = aNewModelRef;
//--handle relations to the old model if any
if( aOldModelRef.is() )
{
aOldModelRef->removeListener( this );
//@todo?? termination correct?
aOldModelRef->tryTermination();
}
//--handle relations to the new model
aNewModelRef->addListener( this );
//the frameloader is responsible to call xModel->connectController
{
// Indirect calls to VCL
::vos::OGuard aSolarGuard( Application::GetSolarMutex());
impl_tryInitializeView();
}
return sal_True;
}
uno::Reference< frame::XFrame > SAL_CALL ChartController
::getFrame() throw(uno::RuntimeException)
{
//provides access to owner frame of this controller
//return the frame containing this controller
return m_xFrame;
}
uno::Reference< frame::XModel > SAL_CALL ChartController
::getModel() throw(uno::RuntimeException)
{
//provides access to currently attached model
//returns the currently attached model
//return nothing, if you do not have a model
TheModelRef aModelRef( m_aModel, m_aModelMutex);
if(aModelRef.is())
return aModelRef->getModel();
return uno::Reference< frame::XModel > ();
}
uno::Any SAL_CALL ChartController
::getViewData() throw(uno::RuntimeException)
{
//provides access to current view status
//set of data that can be used to restore the current view status at later time
// by using XController::restoreViewData()
osl::ResettableGuard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() )
return uno::Any(); //behave passive if already disposed or suspended //@todo? or throw an exception??
//-- collect current view state
uno::Any aRet;
//// @todo integrate specialized implementation
return aRet;
}
void SAL_CALL ChartController
::restoreViewData( const uno::Any& Value )
throw(uno::RuntimeException)
{
//restores the view status using the data gotten from a previous call to XController::getViewData()
osl::ResettableGuard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() )
return; //behave passive if already disposed or suspended //@todo? or throw an exception??
//// @todo integrate specialized implementation
}
sal_Bool SAL_CALL ChartController
::suspend( sal_Bool bSuspend )
throw(uno::RuntimeException)
{
//is called to prepare the controller for closing the view
//bSuspend==true: force the controller to suspend his work
//bSuspend==false try to reactivate the controller
//returns true if request was accepted and of course successfully finished, false otherwise
//we may show dialogs here to ask the user for saving changes ... @todo?
osl::ResettableGuard< osl::Mutex > aGuard( m_aControllerMutex );
if( m_aLifeTimeManager.impl_isDisposed() )
return sal_False; //behave passive if already disposed, return false because request was not accepted //@todo? correct
if(bSuspend==m_bSuspended)
{
OSL_ENSURE( sal_False, "new suspend mode equals old suspend mode" );
//@todo ??? or return true in this case?
return sal_False;
}
//change suspend mode
if(bSuspend)
{
//aGuard.clear();
//@todo ??? try to stop all what may prevent me from becoming disposed
//aGuard.reset();
m_bSuspended = bSuspend;
return sal_True;
}
else
{
//aGuard.clear();
//@todo ??? redo what was made in section bSuspend==true
//aGuard.reset();
m_bSuspended = bSuspend;
return sal_True;
}
/*
if ( bSuspend )
getFrame()->removeFrameActionListener( pImp );
else
getFrame()->addFrameActionListener( pImp );
*/
return sal_True;
}
//-----------------------------------------------------------------
// XComponent (base of XController)
//-----------------------------------------------------------------
void SAL_CALL ChartController
::dispose() throw(uno::RuntimeException)
{
//This object should release all resources and references in the
//easiest possible manner
//This object must notify all registered listeners using the method
//<member>XEventListener::disposing</member>
//hold no mutex
if( !m_aLifeTimeManager.dispose() )
return;
OSL_ENSURE( m_bSuspended, "dispose was called but controller is not suspended" );
//--release all resources and references
impl_deleteView();
m_pChartWindow = NULL;//m_pChartWindow is deleted via UNO by Window hierarchy or Framework
m_xFrame = NULL;
TheModelRef aModelRef( m_aModel, m_aModelMutex);
m_aModel = NULL;
if(aModelRef.is())
{
aModelRef->removeListener( this );
aModelRef->tryTermination();
}
//// @todo integrate specialized implementation
//e.g. release further resources and references
}
void SAL_CALL ChartController
::addEventListener( const uno::Reference<lang::XEventListener>& xListener )
throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() )//@todo? allow adding of listeners in suspend mode?
return; //behave passive if already disposed or suspended
//--add listener
m_aLifeTimeManager.m_aListenerContainer.addInterface( ::getCppuType((const uno::Reference< lang::XEventListener >*)0), xListener );
}
void SAL_CALL ChartController
::removeEventListener( const uno::Reference<
lang::XEventListener>& xListener )
throw(uno::RuntimeException)
{
osl::Guard< osl::Mutex > aGuard( m_aControllerMutex );
if( impl_isDisposedOrSuspended() ) //@todo? allow removing of listeners in suspend mode?
return; //behave passive if already disposed or suspended
//--remove listener
m_aLifeTimeManager.m_aListenerContainer.removeInterface( ::getCppuType((const uno::Reference< lang::XEventListener >*)0), xListener );
}
//-----------------------------------------------------------------
// util::XCloseListener
//-----------------------------------------------------------------
void SAL_CALL ChartController
::queryClosing( const lang::EventObject& rSource, sal_Bool bGetsOwnership )
throw(util::CloseVetoException, uno::RuntimeException)
{
//do not use the m_aControllerMutex here because this call is not allowed to block
TheModelRef aModelRef( m_aModel, m_aModelMutex);
if( !aModelRef.is() )
return;
if( !(aModelRef->getModel() == rSource.Source) )
{
OSL_ENSURE( sal_False, "queryClosing was called on a controller from an unknown source" );
return;
}
if( !m_bCanClose )//@todo tryaqcuire mutex
{
if( bGetsOwnership )
{
aModelRef->SetOwnerShip( bGetsOwnership );
}
throw util::CloseVetoException();
}
else
{
//@ todo prepare to to closing model -> don't start any further hindering actions
}
}
void SAL_CALL ChartController
::notifyClosing( const lang::EventObject& rSource )
throw(uno::RuntimeException)
{
//Listener should deregister himself and relaese all references to the closing object.
TheModelRef aModelRef( 0, m_aModelMutex);
bool bReleaseModel = sal_False;
{
::osl::Guard< ::osl::Mutex > aGuard( m_aModelMutex );
aModelRef = m_aModel;
if( aModelRef.is() && aModelRef->getModel() == rSource.Source )
{
m_aModel = NULL;
bReleaseModel = sal_True;
}
}
//@todo ?? why remove the listener??? this could be handled by the closing object
if( bReleaseModel )
{
//--stop listening to the closing model
aModelRef->removeListener( this );
}
}
//-----------------------------------------------------------------
// util::XEventListener (base of XCloseListener)
//-----------------------------------------------------------------
void SAL_CALL ChartController
::disposing( const lang::EventObject& rSource )
throw(uno::RuntimeException)
{
notifyClosing(rSource);
}
//-----------------------------------------------------------------
// XDispatchProvider (required interface)
//-----------------------------------------------------------------
bool isFormatObjectSID( sal_Int32 nSlotID )
{
if((sal_Int32)SID_DIAGRAM_TITLE_MAIN == nSlotID
|| (sal_Int32)SID_DIAGRAM_TITLE_SUB == nSlotID
|| (sal_Int32)SID_DIAGRAM_TITLE_X == nSlotID
|| (sal_Int32)SID_DIAGRAM_TITLE_Y == nSlotID
|| (sal_Int32)SID_DIAGRAM_TITLE_Z == nSlotID
|| (sal_Int32)SID_DIAGRAM_TITLE_ALL == nSlotID
|| (sal_Int32)SID_LEGEND == nSlotID
|| (sal_Int32)SID_DIAGRAM_AXIS_X == nSlotID
|| (sal_Int32)SID_DIAGRAM_AXIS_Y == nSlotID
|| (sal_Int32)SID_DIAGRAM_AXIS_Z == nSlotID
|| (sal_Int32)SID_DIAGRAM_AXIS_A == nSlotID //secondary x axis
|| (sal_Int32)SID_DIAGRAM_AXIS_B == nSlotID
|| (sal_Int32)SID_DIAGRAM_AXIS_ALL == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_X_MAIN == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_Y_MAIN == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_Z_MAIN == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_X_HELP == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_Y_HELP == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_Z_HELP == nSlotID
|| (sal_Int32)SID_DIAGRAM_GRID_ALL == nSlotID
|| (sal_Int32)SID_DIAGRAM_WALL == nSlotID
|| (sal_Int32)SID_DIAGRAM_FLOOR == nSlotID
|| (sal_Int32)SID_DIAGRAM_AREA == nSlotID
)
return true;
return false;
}
uno::Reference<frame::XDispatch> SAL_CALL ChartController
::queryDispatch( const util::URL& rURL
, const rtl::OUString& rTargetFrameName
, sal_Int32 nSearchFlags)
throw(uno::RuntimeException)
{
//// @todo integrate specialized implementation
//decide which commands you can handle
if ( !m_aLifeTimeManager.impl_isDisposed() )
{
//@todo avoid OString (see Mathias mail on bug #104387#)
rtl::OString aCommand( rtl::OUStringToOString( rURL.Path, RTL_TEXTENCODING_ASCII_US ) );
if( aCommand.equals("Save")
|| aCommand.equals("SaveAs")
|| aCommand.equals("SaveAll")
|| aCommand.equals("Undo")
|| aCommand.equals("Cut")
|| aCommand.equals("Copy")
|| aCommand.equals("Paste")
|| aCommand.equals("SelectAll")
|| aCommand.equals("Close")
|| aCommand.equals("TESTTEST")
|| aCommand.equals("slot:23")
//|| aCommand.copy(0,4).EqualsAscii("Bib/")
//|| aURL.Complete.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("slot:5503"))
)
{
//@todo create a seperate dispatcher object or implement XDispatch interface by yourself
//to return it here
return static_cast< frame::XDispatch* >( this );
}
else if(rURL.Protocol.equalsIgnoreAsciiCase( C2U("slot:") ) )
{
sal_Int32 nSlotID = rURL.Path.toInt32();
if( (sal_Int32)SID_DIAGRAM_OBJECTS == nSlotID
|| (sal_Int32)SID_DIAGRAM_TYPE == nSlotID
|| (sal_Int32)SID_INSERT_TITLE == nSlotID
|| (sal_Int32)SID_INSERT_CHART_LEGEND == nSlotID
|| (sal_Int32)SID_INSERT_DESCRIPTION == nSlotID
|| (sal_Int32)SID_INSERT_AXIS == nSlotID
|| (sal_Int32)SID_INSERT_GRIDS == nSlotID
|| (sal_Int32)SID_INSERT_STATISTICS == nSlotID
|| (sal_Int32)SID_CHARMAP == nSlotID
added SID_TEXTEDIT support
2003-10-28 15:06:11 +00:00
|| (sal_Int32)SID_TEXTEDIT == nSlotID
initial import
2003-10-06 08:58:36 +00:00
|| isFormatObjectSID(nSlotID)
)
{
return static_cast< frame::XDispatch* >( this );
}
}
}
return uno::Reference< frame::XDispatch > ();
}
/*
typedef ::std::map< sal_Int32, ::rtl::OUString > tSlotIdCommandMap;
typedef ::comphelper::MakeMap< sal_Int32, ::rtl::OUString > tMakeSlotIdCommandMap;
tMakeSlotIdCommandMap m_aSlotIdCommandMap =
tMakeSlotIdCommandMap
( (sal_Int32)SID_DIAGRAM_TITLE_MAIN, C2U( "slot:" )+=rtl::OUString::valueOf( (sal_Int32)SID_DIAGRAM_TITLE_MAIN ) )
;
*/
uno::Sequence<uno::Reference<frame::XDispatch > > ChartController
::queryDispatches( const uno::Sequence<
frame::DispatchDescriptor>& xDescripts)
throw(uno::RuntimeException)
{
sal_Int32 nCount = xDescripts.getLength();
if( !nCount )
return uno::Sequence<uno::Reference<frame::XDispatch > > ();
uno::Sequence<uno::Reference<frame::XDispatch > > aRet( nCount );
for( sal_Int32 nPos = 0; nPos<nCount; ++nPos )
{
aRet[ nPos ] = queryDispatch(
xDescripts[nPos].FeatureURL
, xDescripts[nPos].FrameName
, xDescripts[nPos].SearchFlags );
}
return aRet;
}
//-----------------------------------------------------------------
// frame::XDispatch
//-----------------------------------------------------------------
void SAL_CALL ChartController
::dispatch( const util::URL& rURL
, const uno::Sequence< beans::PropertyValue >& rArgs )
throw (uno::RuntimeException)
{
//@todo avoid OString (see Mathias mail on bug #104387#)
rtl::OString aCommand( rtl::OUStringToOString( rURL.Path, RTL_TEXTENCODING_ASCII_US ) );
//test only
if(aCommand.equals("TESTTEST")
|| aCommand.equals("Undo") )
{
Window* pWindow = m_pChartWindow;
Rectangle aRect( Point(0,0), pWindow->GetOutputSize() );
Region aRegion( aRect );
m_pDrawViewWrapper->InitRedraw(pWindow, aRegion );
/*
INVALIDATE_CHILDREN
INVALIDATE_NOCHILDREN
INVALIDATE_NOERASE
INVALIDATE_UPDATE
INVALIDATE_TRANSPARENT
INVALIDATE_NOTRANSPARENT
INVALIDATE_NOCLIPCHILDREN
*/
//Invalidate(INVALIDATE_UPDATE);
}
else if(aCommand.equals("Save"))
{
//only test:
impl_rebuildView();
}
else if(aCommand.equals("SaveAs"))
{
//only test:
this->executeDispatch_ObjectToDefault();
}
//----------------------------------
else if(rURL.Protocol.equalsIgnoreAsciiCase( C2U("slot:") ) )
{
sal_Int32 nSlotID = rURL.Path.toInt32();
if((sal_Int32)SID_DIAGRAM_OBJECTS == nSlotID)
{
this->executeDispatch_ObjectProperties();
}
else if((sal_Int32)SID_DIAGRAM_TYPE == nSlotID)
{
this->executeDispatch_ChartType();
}
else if((sal_Int32)SID_INSERT_TITLE == nSlotID)
{
this->executeDispatch_InsertTitle();
}
else if((sal_Int32)SID_INSERT_CHART_LEGEND == nSlotID)
{
this->executeDispatch_InsertLegend();
}
else if((sal_Int32)SID_INSERT_DESCRIPTION == nSlotID)
{
this->executeDispatch_InsertDataLabel();
}
else if((sal_Int32)SID_INSERT_AXIS == nSlotID)
{
this->executeDispatch_InsertAxis();
}
else if((sal_Int32)SID_INSERT_GRIDS == nSlotID)
{
this->executeDispatch_InsertGrid();
}
else if((sal_Int32)SID_INSERT_STATISTICS == nSlotID)
{
this->executeDispatch_InsertStatistic();
}
else if((sal_Int32)SID_CHARMAP == nSlotID)
{
this->executeDispatch_InsertSpecialCharacter();
}
added SID_TEXTEDIT support
2003-10-28 15:06:11 +00:00
else if((sal_Int32)SID_TEXTEDIT == nSlotID)
{
this->executeDispatch_EditText();
}
initial import
2003-10-06 08:58:36 +00:00
else if( isFormatObjectSID(nSlotID) )
{
this->executeDispatch_FormatObject(nSlotID);
}
}
else if(aCommand.equals("SaveAll"))
{
if( m_aModel.is())
{
uno::Reference< ::drafts::com::sun::star::chart2::XChartDocument > xDoc(
m_aModel->getModel(), uno::UNO_QUERY );
OSL_ASSERT( xDoc.is());
uno::Reference< ::drafts::com::sun::star::chart2::XDataProvider > xDataProvider(
m_xCC->getServiceManager()->createInstanceWithContext(
C2U( "com.sun.star.comp.chart.FileDataProvider" ),
m_xCC ), uno::UNO_QUERY );
OSL_ASSERT( xDataProvider.is());
::rtl::OUString aFileName(
#if defined WNT
RTL_CONSTASCII_USTRINGPARAM( "file:///D:/files/data.chd" )
#else
RTL_CONSTASCII_USTRINGPARAM( "file:///work/data/data.chd" )
#endif
);
xDoc->attachDataProvider( xDataProvider );
xDoc->setRangeRepresentation( aFileName );
impl_rebuildView();
}
}
}
void SAL_CALL ChartController
::addStatusListener( const uno::Reference<frame::XStatusListener >& xControl
, const util::URL& aURL )
throw (uno::RuntimeException)
{
}
void SAL_CALL ChartController
::removeStatusListener( const uno::Reference<frame::XStatusListener >& xControl
, const util::URL& aURL )
throw (uno::RuntimeException)
{
}
//-----------------------------------------------------------------
// XContextMenuInterception (optional interface)
//-----------------------------------------------------------------
void SAL_CALL ChartController
::registerContextMenuInterceptor( const uno::Reference<
ui::XContextMenuInterceptor > & xInterceptor)
throw(uno::RuntimeException)
{
//@todo
}
void SAL_CALL ChartController
::releaseContextMenuInterceptor( const uno::Reference<
ui::XContextMenuInterceptor > & xInterceptor)
throw(uno::RuntimeException)
{
//@todo
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void SAL_CALL ChartController::executeDispatch_ChartType()
{
bool bChanged = false;
//-------------------------------------------------------------
//convert properties to ItemSet
uno::Reference< beans::XPropertySet > xProp;
uno::Reference< XChartDocument > xChartDoc( m_aModel->getModel(), uno::UNO_QUERY );
if( xChartDoc.is())
xProp.set( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
DBG_ASSERT( xProp.is(), "Invalid ChartTypeManager" );
{
wrapper::ChartTypeItemConverter aItemConverter( xProp, m_pDrawModelWrapper->GetItemPool() );
SfxItemSet aItemSet = aItemConverter.CreateEmptyItemSet();//creates only an empty itemset
aItemConverter.FillItemSet( aItemSet );
//-------------------------------------------------------------
//prepare and open dialog
Window* pParent( NULL );
SchDiagramTypeDlg aDlg( pParent, aItemSet );
if( aDlg.Execute() == RET_OK )
{
SfxItemSet aOutItemSet = aItemConverter.CreateEmptyItemSet();
aDlg.GetAttr( aOutItemSet );
bChanged = aItemConverter.ApplyItemSet( aOutItemSet );//model should be changed now
}
}
try
{
//make sure that all objects using m_pDrawModelWrapper or m_pChartView are already deleted
if(bChanged &&
xChartDoc.is())
{
uno::Reference< lang::XMultiServiceFactory > xFact( xProp, uno::UNO_QUERY );
if( xFact.is() )
{
::rtl::OUString aServiceName;
if( xProp->getPropertyValue( C2U( "ChartStyleTemplateServiceName" )) >>= aServiceName )
{
uno::Reference< XChartTypeTemplate > xTemplate(
xFact->createInstance( aServiceName ), uno::UNO_QUERY );
xChartDoc->setChartTypeTemplate( xTemplate );
if( xTemplate.is())
xTemplate->changeDiagram( xChartDoc->getDiagram() );
impl_rebuildView();
}
}
}
}
catch( uno::RuntimeException& e)
{
ItemConverter rework/compiler warnings removed (gcc Linux)
2003-10-07 16:18:46 +00:00
ASSERT_EXCEPTION( e );
initial import
2003-10-06 08:58:36 +00:00
}
}
//.............................................................................
} //namespace chart
//.............................................................................
Reference in New Issue Copy Permalink