initial import

1 files changed, 1124 insertions, 0 deletions

diff --git a/chart2/source/controller/main/ChartController.cxx b/chart2/source/controller/main/ChartController.cxx
new file mode 100644
index 000000000000..c6b5e19bac43
--- /dev/null
+++ b/chart2/source/controller/main/ChartController.cxx
@@ -0,0 +1,1124 @@
+/*************************************************************************
+ *
+ *  $RCSfile: ChartController.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: bm $ $Date: 2003-10-06 09:58:28 $
+ *
+ *  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"
+
+#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 )
+    , m_xFrame( NULL )
+    , m_aModelMutex()
+    , m_aModel( NULL, m_aModelMutex )
+    , m_bSuspended( sal_False )
+    , m_bCanClose( sal_True )
+    , m_pChartWindow( NULL )
+    , m_xViewWindow( NULL )
+    , m_pChartView( NULL )
+    , m_pDrawModelWrapper( NULL )
+    , m_pDrawViewWrapper(NULL)
+    , m_xCC(xContext) //@todo is it allowed to hold this context??
+    , 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
+        ,wrapper::ItemConverter::CreateSchItemPool());
+
+    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
+                || 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();
+        }
+        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)
+    {
+        e;
+    }
+}
+
+//.............................................................................
+} //namespace chart
+//.............................................................................