Attachment #38370 for issue #63017

View | Details | Raw Unified | Return to issue 63017
Collapse All | Expand All




    const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener )
{
    fireStatusEvent( OUString(), xSingleListener );
}

void CommandDispatch::fireStatusEventForURL(
    const OUString & rURL,
    const uno::Any & rState,
    bool bEnabled,
    const Reference< frame::XStatusListener > & xSingleListener /* = 0 */ )
{
    // prepare event to send
    util::URL aURL;
    aURL.Complete = rURL;
    if( !m_xURLTransformer.is())
    {
        m_xURLTransformer.set(




        @param xSingleListener
            If set, the event is only sent to this listener rather than to all
            registered ones.  Whenever a listener adds itself, this method is
            called with this parameter set to give an initial state.
     */
    void fireStatusEventForURL(
        const ::rtl::OUString & rURL,
        const ::com::sun::star::uno::Any & rState,
        bool bEnabled,
        const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener =
            ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener >() );

    // ____ XDispatch ____
    virtual void SAL_CALL dispatch(
        const ::com::sun::star::util::URL& URL,
        const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& Arguments )
        throw (::com::sun::star::uno::RuntimeException);




#include <com/sun/star/util/XModifyBroadcaster.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XSTORABLE_HPP_
#include <com/sun/star/frame/XStorable.hpp>
#endif
#ifndef _COM_SUN_STAR_CHART2_XCHARTDOCUMENT_HPP_
#include <com/sun/star/chart2/XChartDocument.hpp>
#endif
#ifndef _COM_SUN_STAR_CHART2_XDATASERIES_HPP_
#include <com/sun/star/chart2/XDataSeries.hpp>
#endif


using namespace ::com::sun::star;

using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::rtl::OUString;

namespace chart
{

// ----------------------------------------

namespace impl
{

		/**
		 * Declaring constants for moving the series.
		 * 
		 */
		enum EnumForward{ 
				MOVE_SERIES_FORWARD = true,
				MOVE_SERIES_BACKWARD = false
		};
		
		/**
		 * Represents the current state of the controller (needed for issue
		 * 63017).
		 *
		 * You can set the state by calling update().  After this call the state
		 * is preserved in this class until the next call to update().
		 *
		 * This is useful, not to say necessary, for enabling and disabling of
		 * menu entries (format>arrangement). As the status requests are sent very
		 * frequently it would be impossible, from a performance point of view, to
		 * query the current status every time directly at the model.  So this
		 * class serves as a cache for the state.
		 *
		 */
		struct ControllerState
		{ 
				ControllerState( const Reference< frame::XController > & xController );
				
				void update( const Reference< frame::XModel > & xModel );

				// -- State variables -------
				
				bool bHasSelectedObject;
				bool bIsDraggableObject;
				
				// May the selected series be moved forward or backward (cf
				// format>arrangement).
				bool bMayMoveSeriesForward;
				bool bMayMoveSeriesBackward;

			private:
				
				::com::sun::star::uno::Reference<
						::com::sun::star::frame::XController > m_xController;

		};


		ControllerState::ControllerState(
				const Reference< frame::XController > & xController	) :
				m_xController( xController ),
				bHasSelectedObject( false ),
				bIsDraggableObject( false ),
				bMayMoveSeriesForward( false ),
				bMayMoveSeriesBackward( false )
		{
		}


		void ControllerState::update( const Reference< frame::XModel > & xModel )
		{

				OSL_TRACE( "\nControllerState Updated -------------------------" );
				
				::com::sun::star::uno::Reference<
						::com::sun::star::view::XSelectionSupplier >
						m_xSelectionSupplier( m_xController, uno::UNO_QUERY );

				::rtl::OUString aSelObjCID;
				
				// Update ControllerState variables.
				if( m_xSelectionSupplier.is())
				{
						uno::Any aSelObj( m_xSelectionSupplier->getSelection() );

						bHasSelectedObject = ((aSelObj >>= aSelObjCID) && aSelObjCID.getLength() > 0);

						bIsDraggableObject = ObjectIdentifier::isDragableObject( aSelObjCID );
						
						uno::Reference< ::com::sun::star::chart2::XDataSeries > xGivenDataSeries( 
								ObjectIdentifier::getDataSeriesForCID( 
										aSelObjCID, xModel ) );

						bMayMoveSeriesForward = DiagramHelper::isSeriesMoveable( 
								ChartModelHelper::findDiagram( xModel ),
								xGivenDataSeries,
								MOVE_SERIES_FORWARD );

						bMayMoveSeriesBackward = DiagramHelper::isSeriesMoveable( 
								ChartModelHelper::findDiagram( xModel ),
								xGivenDataSeries,
								MOVE_SERIES_BACKWARD);

						
						// TODO : debug only
						if ( bIsDraggableObject )
								OSL_TRACE( "Draggable Object");

				}

		}

		

		/** Represents the current state of the model.

    You can set the state by calling update().  After this call the state is
    preserved in this class until the next call to update().

    This is useful, not to say necessary, for enabling and disabling of menu
    entries and toolbar icons.  As the status requests are sent very frequently
    it would be impossible, from a performance point of view, to query the
    current status every time directly at the model.  So this class serves as a

    ModelState();

    void update( const Reference< frame::XModel > & xModel );

    bool HasAnyAxis() const;
    bool HasAnyGrid() const;
    bool HasAnyTitle() const;

    bool bIsReadOnly;
    bool bIsThreeD;
    bool bHasOwnData;

    bool bHasMainTitle;
    bool bHasSubTitle;
    bool bHasXAxisTitle;
    bool bHasYAxisTitle;
    bool bHasZAxisTitle;

    bool bHasXAxis;
    bool bHasYAxis;
    bool bHasZAxis;
    bool bHasAAxis;
    bool bHasBAxis;

    bool bHasMainXGrid;
    bool bHasMainYGrid;
    bool bHasMainZGrid;
    bool bHasHelpXGrid;
    bool bHasHelpYGrid;
    bool bHasHelpZGrid;

    bool bHasAutoScaledText;

    sal_Bool bHasAutoScaledText;
};

ModelState::ModelState() :
        bIsReadOnly( true ),
        bIsThreeD( false ),
        bHasOwnData( false ),
        bHasMainTitle( false ),
        bHasSubTitle( false ),
        bHasXAxisTitle( false ),
        bHasYAxisTitle( false ),
        bHasZAxisTitle( false ),
        bHasXAxis( false ),
        bHasYAxis( false ),
        bHasZAxis( false ),
        bHasAAxis( false ),
        bHasBAxis( false ),
        bHasMainXGrid( false ),
        bHasMainYGrid( false ),
        bHasMainZGrid( false ),
        bHasHelpXGrid( false ),
        bHasHelpYGrid( false ),
        bHasHelpZGrid( false ),
        bHasAutoScaledText( false )
{}

void ModelState::update( const Reference< frame::XModel > & xModel )
{
    Reference< chart2::XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
    Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( xModel ));

    bIsReadOnly = true;
    Reference< frame::XStorable > xStorable( xModel, uno::UNO_QUERY );
    if( xStorable.is())
        bIsReadOnly = xStorable->isReadonly();

    bIsThreeD = (DiagramHelper::getDimension( xDiagram ) == 3);
    bHasOwnData = (xChartDoc.is() && xChartDoc->hasInternalDataProvider());

    bHasMainTitle =  TitleHelper::getTitle( TitleHelper::MAIN_TITLE, xModel ).is();

    bHasMainZGrid = AxisHelper::isGridShown( 2, 0, true, xDiagram );
    bHasHelpXGrid = AxisHelper::isGridShown( 0, 0, false, xDiagram );
    bHasHelpYGrid = AxisHelper::isGridShown( 1, 0, false, xDiagram );
    bHasHelpZGrid = AxisHelper::isGridShown( 2, 0, false, xDiagram );

    bHasAutoScaledText =
        (ReferenceSizeProvider::getAutoResizeState( xChartDoc ) ==
         ReferenceSizeProvider::AUTO_RESIZE_YES);

}

bool ModelState::HasAnyAxis() const
{
    return bHasXAxis || bHasYAxis || bHasZAxis || bHasAAxis || bHasBAxis;
}

bool ModelState::HasAnyGrid() const


} // namespace impl

// ----------------------------------------

ControllerCommandDispatch::ControllerCommandDispatch(
    const Reference< uno::XComponentContext > & xContext,
    const Reference< frame::XController > & xController ) :
        impl::ControllerCommandDispatch_Base( xContext ),
        m_xController( xController ),
        m_xSelectionSupplier( xController, uno::UNO_QUERY ),
        m_xDispatch( xController, uno::UNO_QUERY ),
        m_apModelState( new impl::ModelState() ),
				m_apControllerState( new impl::ControllerState( xController ) )
{}

ControllerCommandDispatch::~ControllerCommandDispatch()
{}

void ControllerCommandDispatch::initialize()
{
    if( m_xController.is())
    {
        Reference< frame::XModel > xModel( m_xController->getModel());
        Reference< util::XModifyBroadcaster > xModifyBroadcaster( xModel, uno::UNO_QUERY );
        OSL_ASSERT( xModifyBroadcaster.is());
        if( xModifyBroadcaster.is())
            xModifyBroadcaster->addModifyListener( this );

				// Listen selection modifications (Arrangement feature - issue 63017).
				if( m_xSelectionSupplier.is() )
						m_xSelectionSupplier->addSelectionChangeListener( this );
				
        if( m_apModelState.get() && xModel.is())
            m_apModelState->update( xModel );

        if( m_apControllerState.get() && xModel.is())
            m_apControllerState->update( xModel );
				
    }
}

void ControllerCommandDispatch::conditionalFireStatusEventForURL(
        const OUString & rCompareURL,
        const OUString & rURL,
        const uno::Any & rState,
        bool bEnabled,
        const Reference< frame::XStatusListener > & xSingleListener )
{
    if( rCompareURL.getLength() == 0 ||
        rURL.equals( rCompareURL ))
    {
        fireStatusEventForURL( rURL, rState, bEnabled, xSingleListener );
    }
}

void ControllerCommandDispatch::fireStatusEvent(
    const OUString & rURL,
    const Reference< frame::XStatusListener > & xSingleListener /* = 0 */ )
{
    uno::Any aEmptyArg;

    // readonly
    bool bIsWritable = ! m_apModelState->bIsReadOnly;
    
		// selection
    bool bHasSelectedObject = false;
		
		// Model and controller exist.
		OSL_ASSERT( m_apModelState.get() );
		OSL_ASSERT( m_apControllerState.get() );
		
		bool bModelStateIsValid = ( m_apModelState.get() != 0 );
		bool bControllerStateIsValid = ( m_apControllerState.get() != 0 );
		
		
    // base commands (offered by all apps)
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Save"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:SaveAs"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:SaveAll"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Close"), aEmptyArg, true, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Cut"), aEmptyArg, bIsWritable && bHasSelectedObject, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Copy"), aEmptyArg, bHasSelectedObject, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Paste"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:SelectAll"), aEmptyArg, true, xSingleListener );


    // toolbar commands
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleTitle"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleLegend"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleAxisTitle"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleAxisDescr"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleGridHorizontal"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ToggleGridVertical"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DataInRows"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DataInColumns"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ContextType"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:NewArrangement"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Update"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ScaleText"),
                           uno::makeAny( m_apModelState->bHasAutoScaledText ),
                           bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DataDescriptionType"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:LegendPosition"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DefaultColors"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:BarWidth"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:NumberOfLines"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ArrangeRow"), aEmptyArg, bIsWritable, xSingleListener );

    // insert objects

    conditionalFireStatusEventForURL( rURL, C2U(".uno:InsertStatistics"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:InsertSymbol"), aEmptyArg, bIsWritable, xSingleListener );

    // format objects
//MENUCHANGE    conditionalFireStatusEventForURL( rURL, C2U(".uno:SelectSourceRanges"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramObjects"), aEmptyArg, bIsWritable && bHasSelectedObject, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramType"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:AutoFormat"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Forward"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Backward"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Legend"), aEmptyArg, bIsWritable, xSingleListener );

    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramWall"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramArea"), aEmptyArg, bIsWritable, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:TransformDialog"), aEmptyArg, bIsWritable && bHasSelectedObject && m_apControllerState->bIsDraggableObject, xSingleListener );

    
		
		// Tests requiring that the Model State is valid ("bModelStateIsValid").
		
    OSL_ASSERT( m_apModelState.get());
    if( ! m_apModelState.get())
        bIsWritable = sal_False;

    // 3d commands
		conditionalFireStatusEventForURL( rURL, C2U(".uno:View3D"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bIsThreeD, xSingleListener );
		conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramFloor"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bIsThreeD, xSingleListener );

    // depending on own data
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DataRanges"), aEmptyArg, bIsWritable && bModelStateIsValid && (! m_apModelState->bHasOwnData), xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramData"), aEmptyArg, bIsWritable && bModelStateIsValid &&  m_apModelState->bHasOwnData, xSingleListener );

    // titles
    conditionalFireStatusEventForURL( rURL, C2U(".uno:MainTitle"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasMainTitle, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:SubTitle"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasSubTitle, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:XTitle"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasXAxisTitle, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:YTitle"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasYAxisTitle, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ZTitle"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasZAxisTitle, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:AllTitles"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->HasAnyTitle(), xSingleListener );

		// text
    conditionalFireStatusEventForURL( rURL, C2U(".uno:ScaleText"), uno::makeAny( m_apModelState->bHasAutoScaledText ), bIsWritable && bModelStateIsValid , xSingleListener );

    // axes
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisX"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasXAxis, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisY"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasYAxis, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisZ"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasZAxis, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisA"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasAAxis, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisB"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasBAxis, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramAxisAll"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->HasAnyAxis(), xSingleListener );

    // grids
    // note: x and y are swapped in the commands!
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridYMain"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasMainXGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridXMain"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasMainYGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridZMain"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasMainZGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridYHelp"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasHelpXGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridXHelp"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasHelpYGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridZHelp"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->bHasHelpZGrid, xSingleListener );
    conditionalFireStatusEventForURL( rURL, C2U(".uno:DiagramGridAll"), aEmptyArg, bIsWritable && bModelStateIsValid && m_apModelState->HasAnyGrid(), xSingleListener );


		// Tests requiring that the Model State is valid ("bModelStateIsValid")
		// and that the Controller State ("bControllerStateIsValid") is valid.

    conditionalFireStatusEventForURL( rURL, C2U(".uno:Forward"), aEmptyArg, bIsWritable && bModelStateIsValid && bControllerStateIsValid && m_apControllerState->bMayMoveSeriesForward, xSingleListener );
		
    conditionalFireStatusEventForURL( rURL, C2U(".uno:Backward"), aEmptyArg, bIsWritable && bModelStateIsValid && bControllerStateIsValid && m_apControllerState->bMayMoveSeriesBackward, xSingleListener );
		
}

// ____ XDispatch ____
void SAL_CALL ControllerCommandDispatch::dispatch(
    const util::URL& URL,
    const Sequence< beans::PropertyValue >& Arguments )
    throw (uno::RuntimeException)
{

    m_xDispatch.clear();
    m_xSelectionSupplier.clear();
}

// ____ XModifyListener ____
void SAL_CALL ControllerCommandDispatch::modified( const lang::EventObject& aEvent )
    throw (uno::RuntimeException)
{
		// Update the "ModelState" Struct.
    if( m_apModelState.get() && m_xController.is())
        m_apModelState->update( m_xController->getModel());

		// Update the "ControllerState" Struct.
    if( m_apControllerState.get() && m_xController.is())
        m_apControllerState->update( m_xController->getModel());
		
    CommandDispatch::modified( aEvent );
}


// ____ XSelectionChangeListener ____
void SAL_CALL ControllerCommandDispatch::selectionChanged( const lang::EventObject& aEvent )
    throw (uno::RuntimeException)
{
		
		// TODO : remove the comment
		OSL_TRACE( "Selection Changed" );
		
		// Update the "ControllerState" Struct.
    if( m_apControllerState.get() && m_xController.is())
        m_apControllerState->update( m_xController->getModel());
		
}


} //  namespace chart




 *    MA  02111-1307  USA
 *
 ************************************************************************/
#ifndef CHART2_CONTROLLERCOMMANDDISPATCH_HXX
#define CHART2_CONTROLLERCOMMANDDISPATCH_HXX

#include "CommandDispatch.hxx"

#ifndef _CPPUHELPER_IMPLBASE1_HXX_
#include <cppuhelper/implbase1.hxx>
#endif
#ifndef _COM_SUN_STAR_FRAME_XMODEL_HPP_
#include <com/sun/star/frame/XModel.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XCONTROLLER_HPP_
#include <com/sun/star/frame/XController.hpp>
#endif
#ifndef _COM_SUN_STAR_VIEW_XSELECTIONSUPPLIER_HPP_
#include <com/sun/star/view/XSelectionSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_VIEW_XSELECTIONCHANGELISTENER_HPP_
#include <com/sun/star/view/XSelectionChangeListener.hpp>
#endif


#include <memory>

namespace chart
{

namespace impl
{
		struct ControllerState;
		struct ModelState;

		// issue 63017 : need to implement the XSelectionChangeListener in order
		// to update the ModelState when the selected series changes.
		typedef ::cppu::ImplInheritanceHelper1<
				CommandDispatch, ::com::sun::star::view::XSelectionChangeListener >
				ControllerCommandDispatch_Base;

}

/** This class is a CommandDispatch that is responsible for all commands that
    the ChartController supports.

    This class determines which commands are currently available (via the model
    state) and if an available command is called forwards it to the
		ChartController.
 */
class ControllerCommandDispatch : public impl::ControllerCommandDispatch_Base
{
public:
    explicit ControllerCommandDispatch(
        const ::com::sun::star::uno::Reference<
            ::com::sun::star::uno::XComponentContext > & xContext,
        const ::com::sun::star::uno::Reference<
            ::com::sun::star::frame::XController > & xController );
	virtual ~ControllerCommandDispatch();

        const ::rtl::OUString & rURL,
        const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );

    // ____ XModifyListener ____
    virtual void SAL_CALL modified(
        const ::com::sun::star::lang::EventObject& aEvent )
        throw (::com::sun::star::uno::RuntimeException);

    // ____ XSelectionChangeListener ____
		// This is related to the arrangement feature (issue 63017).
    virtual void SAL_CALL selectionChanged(
        const ::com::sun::star::lang::EventObject& aEvent )
        throw (::com::sun::star::uno::RuntimeException);
		


private:
    /** Simplification for doing a string compare between a given URL
        (rCompareURL) with a fixed string (rURL), and only in case of equality
        call the fireStatusEvent method at the base class.

        @param xSingleListener
            Same behaviour that in base class CommandDispatch: If set, the event
            is only sent to this listener rather than to all registered ones.
     */
    void conditionalFireStatusEventForURL(
        const ::rtl::OUString & rCompareURL,
        const ::rtl::OUString & rURL,
        const ::com::sun::star::uno::Any & rState,
        bool bEnabled,
        const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );

    ::com::sun::star::uno::Reference<
            ::com::sun::star::frame::XController > m_xController;
    ::com::sun::star::uno::Reference<
            ::com::sun::star::view::XSelectionSupplier > m_xSelectionSupplier;
    ::com::sun::star::uno::Reference<
            ::com::sun::star::frame::XDispatch > m_xDispatch;

    ::std::auto_ptr< impl::ModelState > m_apModelState;
		
    ::std::auto_ptr< impl::ControllerState > m_apControllerState;
		
};

} //  namespace chart

// CHART2_CONTROLLERCOMMANDDISPATCH_HXX
#endif




            const ::com::sun::star::uno::Reference<
                ::com::sun::star::chart2::XDiagram > & xDiagram );

    static bool areChartTypesCompatible( const ::com::sun::star::uno::Reference<
                ::com::sun::star::chart2::XChartType >& xFirstType,
                const ::com::sun::star::uno::Reference<
                ::com::sun::star::chart2::XChartType >& xSecondType );


		/**
		 * Test if the series can be moved.
		 *
		 * @param xDiagram
		 * 	Reference to the diagram that contains the selected series.
		 * 
		 * @param xGivenDataSeries
		 * 	Reference to the series that needs to be moved.
		 * 	
		 * @param bForward
		 * 	Test to move the series forward or backward.
		 * 
		 * @returns </TRUE> if the series can be moved.
		 * 
		 */
		static bool DiagramHelper::isSeriesMoveable( 
				const ::com::sun::star::uno::Reference< 
				  ::com::sun::star::chart2::XDiagram >& xDiagram,
				const ::com::sun::star::uno::Reference<
          ::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
				bool bForward );
				  
		/**
		 * Move the series forward or backward.
		 *
		 * @param xDiagram
		 * 	Reference to the diagram that contains the selected series.
		 * 
		 * @param xGivenDataSeries
		 * 	Reference to the series that needs to be moved.
		 * 	
		 * @param bForward
		 * 	Test to move the series forward or backward.
		 *
		 * @returns </TRUE> if the series was moved.
		 * 
		 */
    static bool moveSeries( 
				const ::com::sun::star::uno::Reference< 
				  ::com::sun::star::chart2::XDiagram >& xDiagram,
				const ::com::sun::star::uno::Reference<
          ::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
				bool bForward );

    static sal_Int32 getIndexOfSeriesWithinChartType( 
                const ::com::sun::star::uno::Reference<
                    ::com::sun::star::chart2::XDataSeries >& xDataSeries,
               const ::com::sun::star::uno::Reference<
                    ::com::sun::star::chart2::XChartType >& xChartType );

    enum BarConnectorState

    static BarConnectorState hasBarConnectors(
        const ::com::sun::star::uno::Reference<
            ::com::sun::star::chart2::XDiagram >& xDiagram );

    /** Set the property "ConnectDataPoints" to true for all series that are
        contained in chart types that support bar connectors (see
        ChartTypeHelper::isSupportingBarConnectors)

        @return </TRUE> if the property could be set at some data series
     */
    static bool setBarConnectors(
        const ::com::sun::star::uno::Reference<
            ::com::sun::star::chart2::XDiagram >& xDiagram,
        bool bOn );

    /** Returns the default camera geometry that is set in the Diagram CTOR.
        This is not the property default!

    static void getCameraDistanceRange( double& rfMinimumDistance, double& rfMaximumDistance );

    static bool isSupportingFloorAndWall( const ::com::sun::star::uno::Reference<
                ::com::sun::star::chart2::XDiagram > & xDiagram );

private:
    // not implemented
	DiagramHelper();

	  /** 
		 * This method implements the logic of checking if a series can be moved
		 * forward/backward. Depending on the "bDoMove" parameter the series will
		 * be moved (bDoMove = true) or the function just will just test if the
		 * series can be moved without doing the move (bDoMove = false).
		 *
		 * Note : This function should be restructured, but is kept as is for the
		 * moment.
		 *
		 * @param xDiagram
		 * 	Reference to the diagram that contains the selected series.
		 * 
		 * @param xGivenDataSeries
		 * 	Reference to the series that needs to be moved.
		 * 	
		 * @param bForward
		 * 	Move the series forward or backward.
		 * 	
		 * @param bDoMove
		 * 	Should this function really move the series (true) or just test if it is
		 * 	possible (false).
		 * 
		 *
		 * @returns
		 * 	bDoMove = true
		 * 		- True : if the move was done
		 * 		- False : the move failed
		 * 	bDoMove = false
		 * 		- True : the series can be moved
		 * 		- False : the series can not be moved
		 *
		 */
    static bool lcl_moveSeriesOrCheckIfMoveIsAllowed( 
				const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XDiagram >& xDiagram,
        const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
				bool bForward,
				bool bDoMove );
};

} //  namespace chart

// CHART2_DIAGRAMHELPER_HXX
#endif





    ::std::vector< ::rtl::OUString > aFirstRoles( ContainerHelper::SequenceToVector( xFirstType->getSupportedMandatoryRoles() ) );
    ::std::vector< ::rtl::OUString > aSecondRoles( ContainerHelper::SequenceToVector( xSecondType->getSupportedMandatoryRoles() ) );
    ::std::sort( aFirstRoles.begin(), aFirstRoles.end() );
    ::std::sort( aSecondRoles.begin(), aSecondRoles.end() );
    return ( aFirstRoles == aSecondRoles );
}



bool DiagramHelper::isSeriesMoveable( 
		const Reference< XDiagram >& xDiagram,
		const Reference< XDataSeries >& xGivenDataSeries,
		bool bForward )
{
		
		bool bIsMoveable = false;
		const bool bDoMove = false;
		
		bIsMoveable = lcl_moveSeriesOrCheckIfMoveIsAllowed( 
				xDiagram, xGivenDataSeries, bForward, bDoMove );
		
		return bIsMoveable;
}


bool DiagramHelper::moveSeries( const Reference< XDiagram >& xDiagram, const Reference< XDataSeries >& xGivenDataSeries, bool bForward )
{

		bool bMoved = false;
		const bool bDoMove = true;
		
		bMoved = lcl_moveSeriesOrCheckIfMoveIsAllowed( 
				xDiagram, xGivenDataSeries, bForward, bDoMove );

		return bMoved;
}


bool DiagramHelper::lcl_moveSeriesOrCheckIfMoveIsAllowed( 
		const Reference< XDiagram >& xDiagram, 
		const Reference< XDataSeries >& xGivenDataSeries,
		bool bForward,
		bool bDoMove )
{
		
		OSL_TRACE( "LOCAL_MOVE_SERIES" );
		
		if( bForward )
				OSL_TRACE( "move forward" );
		else
				OSL_TRACE( "move backward" );
				
		
		if( bDoMove )
				OSL_TRACE( "Really move" );
		else
				OSL_TRACE( "DO NOT move" );
			
		
    bool bMovedOrMoveAllowed = false;
		
    try
    {
        uno::Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );

        // Find position of series.
        bool bFound = false;

        if( xGivenDataSeries.is() && xCooSysContainer.is() )
        {
            uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );

						// Coordinate system(s). At the moment, there is only one
						// coordinate.
            for( sal_Int32 nCS = 0; !bFound && nCS < aCooSysList.getLength(); ++nCS )
            {
                uno::Reference< XCoordinateSystem > xCooSys( aCooSysList[nCS] );
                
                //iterate through all chart types in the current coordinate system
                uno::Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );
                OSL_ASSERT( xChartTypeContainer.is());
                if( !xChartTypeContainer.is() )
                    continue;
                uno::Sequence< uno::Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );
                uno::Reference< XChartType > xFormerChartType;
								
                for( sal_Int32 nT = 0; !bFound && nT < aChartTypeList.getLength(); ++nT )
                {
                    uno::Reference< XChartType > xCurrentChartType( aChartTypeList[nT] );
                                        
                    //iterate through all series in this chart type
                    uno::Reference< XDataSeriesContainer > xDataSeriesContainer( xCurrentChartType, uno::UNO_QUERY );
                    OSL_ASSERT( xDataSeriesContainer.is());
                    if( !xDataSeriesContainer.is() )
                        continue;
                        
                    uno::Sequence< uno::Reference< XDataSeries > > aSeriesList( xDataSeriesContainer->getDataSeries() );

										
                    for( sal_Int32 nS = 0; !bFound && nS < aSeriesList.getLength(); ++nS )
                    {

												// Aim : know at which index is the series.
												// We found the series we are interrested in !
												if( xGivenDataSeries==aSeriesList[nS] )
                        {
                            sal_Int32 nOldCooSysIndex = nCS;
                            sal_Int32 nOldChartTypeIndex = nT;
                            sal_Int32 nOldSeriesIndex = nS;
                            bFound = true;

                            try
                            {
                                sal_Int32 nNewSeriesIndex = nS;
                                
																// Should the series be moved forward or backward.
																if( bForward )
                                    nNewSeriesIndex--;
                                else
                                    nNewSeriesIndex++;

																
																// --- Moving in real the series -------------
																
																if( bDoMove )
																{
																
																
																		if( nNewSeriesIndex >= 0 && nNewSeriesIndex < aSeriesList.getLength() )
																		{
																				//move series in the same charttype
																				bMovedOrMoveAllowed = true;
																				aSeriesList[ nOldSeriesIndex ] = aSeriesList[ nNewSeriesIndex ];
																				aSeriesList[ nNewSeriesIndex ] = xGivenDataSeries;
																				xDataSeriesContainer->setDataSeries( aSeriesList );
																		}
																		else if( nNewSeriesIndex<0 )
																		{
																				//exchange series with former charttype
																				if( xFormerChartType.is() && DiagramHelper::areChartTypesCompatible( xFormerChartType, xCurrentChartType ) )
																				{
																						bMovedOrMoveAllowed = true;
																						uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xFormerChartType, uno::UNO_QUERY );
																						if( xOtherDataSeriesContainer.is() )
																						{
																								uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );
																								sal_Int32 nOtherSeriesIndex = aOtherSeriesList.getLength()-1;
																								if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )
																								{
																										uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );
																										aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;
																										xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);

                                                aSeriesList[nOldSeriesIndex]=xExchangeSeries;
                                                xDataSeriesContainer->setDataSeries(aSeriesList);
																								}
																						}
																				}
																		}
																		else if( nT+1 < aChartTypeList.getLength() )
																		{
																				//exchange series with next charttype
																				uno::Reference< XChartType > xOtherChartType( aChartTypeList[nT+1] );
																				if( xOtherChartType.is() && DiagramHelper::areChartTypesCompatible( xOtherChartType, xCurrentChartType ) )
																				{
																						bMovedOrMoveAllowed = true;
																						uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xOtherChartType, uno::UNO_QUERY );
																						if( xOtherDataSeriesContainer.is() )
																						{
																								uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );
																								sal_Int32 nOtherSeriesIndex = 0;
																								if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )
																								{
																										uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );
																										aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;
																										xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);

                                                aSeriesList[nOldSeriesIndex]=xExchangeSeries;
                                                xDataSeriesContainer->setDataSeries(aSeriesList);
																								}
																						}
																				}
																		}

																		// --- End Moving the series --------------------

																}
																
																// --- Test if the series can be moved without
																// doing the move. ---
																
																else
																{

																		if( nNewSeriesIndex >= 0 && nNewSeriesIndex < aSeriesList.getLength() )
																				bMovedOrMoveAllowed = true;

																		else if( nNewSeriesIndex<0 )
																		{
																				//exchange series with former charttype
																				if( xFormerChartType.is() && DiagramHelper::areChartTypesCompatible( xFormerChartType, xCurrentChartType ) )
																						bMovedOrMoveAllowed = true;
																		}
																		else if( nT+1 < aChartTypeList.getLength() )
																		{
																				//exchange series with next charttype
																				uno::Reference< XChartType > xOtherChartType( aChartTypeList[nT+1] );
																				if( xOtherChartType.is() && DiagramHelper::areChartTypesCompatible( xOtherChartType, xCurrentChartType ) )
																				{
																						bMovedOrMoveAllowed = true;
																				}
																		}
																}

														}
														catch( util::CloseVetoException& )
														{
														}
														catch( uno::RuntimeException& )
														{
														}
												}
										}
										xFormerChartType = xCurrentChartType;
								}
						}
				}
		}
		catch( util::CloseVetoException& )
		{
		}
		catch( uno::RuntimeException& )
		{
		}
		return bMovedOrMoveAllowed;
}

sal_Int32 DiagramHelper::getIndexOfSeriesWithinChartType( 
                const Reference< XDataSeries >& xDataSeries,
               const Reference< XChartType >& xChartType )
{
    sal_Int32 nRet = -1;


Return to issue 63017

Lines 146-162 void CommandDispatch::fireAllStatusEvent Link Here

(-)controller/main/CommandDispatch.cxx (-1 / +1 lines)
146	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener )	146	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener )
147	{	147	{
148	fireStatusEvent( OUString(), xSingleListener );	148	fireStatusEvent( OUString(), xSingleListener );
149	}	149	}
150		150
151	void CommandDispatch::fireStatusEventForURL(	151	void CommandDispatch::fireStatusEventForURL(
152	const OUString & rURL,	152	const OUString & rURL,
153	const uno::Any & rState,	153	const uno::Any & rState,
154	sal_Bool bEnabled,	154	bool bEnabled,
155	const Reference< frame::XStatusListener > & xSingleListener /* = 0 */ )	155	const Reference< frame::XStatusListener > & xSingleListener /* = 0 */ )
156	{	156	{
157	// prepare event to send	157	// prepare event to send
158	util::URL aURL;	158	util::URL aURL;
159	aURL.Complete = rURL;	159	aURL.Complete = rURL;
160	if( !m_xURLTransformer.is())	160	if( !m_xURLTransformer.is())
161	{	161	{
162	m_xURLTransformer.set(	162	m_xURLTransformer.set(

Lines 32-75 Link Here

(-)controller/main/ControllerCommandDispatch.hxx (-4 / +30 lines)
32	* MA 02111-1307 USA	32	* MA 02111-1307 USA
33	*	33	*
34	************************************************************************/	34	************************************************************************/
35	#ifndef CHART2_CONTROLLERCOMMANDDISPATCH_HXX	35	#ifndef CHART2_CONTROLLERCOMMANDDISPATCH_HXX
36	#define CHART2_CONTROLLERCOMMANDDISPATCH_HXX	36	#define CHART2_CONTROLLERCOMMANDDISPATCH_HXX
37		37
38	#include "CommandDispatch.hxx"	38	#include "CommandDispatch.hxx"
39		39
		40	#ifndef _CPPUHELPER_IMPLBASE1_HXX_
		41	#include <cppuhelper/implbase1.hxx>
		42	#endif
40	#ifndef _COM_SUN_STAR_FRAME_XMODEL_HPP_	43	#ifndef _COM_SUN_STAR_FRAME_XMODEL_HPP_
41	#include <com/sun/star/frame/XModel.hpp>	44	#include <com/sun/star/frame/XModel.hpp>
42	#endif	45	#endif
43	#ifndef _COM_SUN_STAR_FRAME_XCONTROLLER_HPP_	46	#ifndef _COM_SUN_STAR_FRAME_XCONTROLLER_HPP_
44	#include <com/sun/star/frame/XController.hpp>	47	#include <com/sun/star/frame/XController.hpp>
45	#endif	48	#endif
46	#ifndef _COM_SUN_STAR_VIEW_XSELECTIONSUPPLIER_HPP_	49	#ifndef _COM_SUN_STAR_VIEW_XSELECTIONSUPPLIER_HPP_
47	#include <com/sun/star/view/XSelectionSupplier.hpp>	50	#include <com/sun/star/view/XSelectionSupplier.hpp>
48	#endif	51	#endif
		52	#ifndef _COM_SUN_STAR_VIEW_XSELECTIONCHANGELISTENER_HPP_
		53	#include <com/sun/star/view/XSelectionChangeListener.hpp>
		54	#endif
		55
49		56
50	#include <memory>	57	#include <memory>
51		58
52	namespace chart	59	namespace chart
53	{	60	{
54		61
55	namespace impl	62	namespace impl
56	{	63	{
57	struct ModelState;	64	struct ControllerState;
		65	struct ModelState;
		66
		67	// issue 63017 : need to implement the XSelectionChangeListener in order
		68	// to update the ModelState when the selected series changes.
		69	typedef ::cppu::ImplInheritanceHelper1<
		70	CommandDispatch, ::com::sun::star::view::XSelectionChangeListener >
		71	ControllerCommandDispatch_Base;
		72
58	}	73	}
59		74
60	/** This class is a CommandDispatch that is responsible for all commands that	75	/** This class is a CommandDispatch that is responsible for all commands that
61	the ChartController supports.	76	the ChartController supports.
62		77
63	This class determines which commands are currently available (via the model	78	This class determines which commands are currently available (via the model
64	state) and if an available command is called forwards it to the	79	state) and if an available command is called forwards it to the
65	ChartController.	80	ChartController.
66	*/	81	*/
67	class ControllerCommandDispatch : public CommandDispatch	82	class ControllerCommandDispatch : public impl::ControllerCommandDispatch_Base
68	{	83	{
69	public:	84	public:
70	explicit ControllerCommandDispatch(	85	explicit ControllerCommandDispatch(
71	const ::com::sun::star::uno::Reference<	86	const ::com::sun::star::uno::Reference<
72	::com::sun::star::uno::XComponentContext > & xContext,	87	::com::sun::star::uno::XComponentContext > & xContext,
73	const ::com::sun::star::uno::Reference<	88	const ::com::sun::star::uno::Reference<
74	::com::sun::star::frame::XController > & xController );	89	::com::sun::star::frame::XController > & xController );
75	virtual ~ControllerCommandDispatch();	90	virtual ~ControllerCommandDispatch();
Lines 97-134 protected: Link Here
97	const ::rtl::OUString & rURL,	112	const ::rtl::OUString & rURL,
98	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );	113	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );
99		114
100	// ____ XModifyListener ____	115	// ____ XModifyListener ____
101	virtual void SAL_CALL modified(	116	virtual void SAL_CALL modified(
102	const ::com::sun::star::lang::EventObject& aEvent )	117	const ::com::sun::star::lang::EventObject& aEvent )
103	throw (::com::sun::star::uno::RuntimeException);	118	throw (::com::sun::star::uno::RuntimeException);
104		119
		120	// ____ XSelectionChangeListener ____
		121	// This is related to the arrangement feature (issue 63017).
		122	virtual void SAL_CALL selectionChanged(
		123	const ::com::sun::star::lang::EventObject& aEvent )
		124	throw (::com::sun::star::uno::RuntimeException);
		125
		126
		127
105	private:	128	private:
106	/** Simplification for doing a string compare between a given URL	129	/** Simplification for doing a string compare between a given URL
107	(rCompareURL) with a fixed string (rURL), and only in case of equality	130	(rCompareURL) with a fixed string (rURL), and only in case of equality
108	call the fireStatusEvent method at the base class.	131	call the fireStatusEvent method at the base class.
109		132
110	@param xSingleListener	133	@param xSingleListener
111	Same behaviour that in base class CommandDispatch: If set, the event	134	Same behaviour that in base class CommandDispatch: If set, the event
112	is only sent to this listener rather than to all registered ones.	135	is only sent to this listener rather than to all registered ones.
113	*/	136	*/
114	void conditionalFireStatusEventForURL(	137	void conditionalFireStatusEventForURL(
115	const ::rtl::OUString & rCompareURL,	138	const ::rtl::OUString & rCompareURL,
116	const ::rtl::OUString & rURL,	139	const ::rtl::OUString & rURL,
117	const ::com::sun::star::uno::Any & rState,	140	const ::com::sun::star::uno::Any & rState,
118	sal_Bool bEnabled,	141	bool bEnabled,
119	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );	142	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener );
120		143
121	::com::sun::star::uno::Reference<	144	::com::sun::star::uno::Reference<
122	::com::sun::star::frame::XController > m_xController;	145	::com::sun::star::frame::XController > m_xController;
123	::com::sun::star::uno::Reference<	146	::com::sun::star::uno::Reference<
124	::com::sun::star::view::XSelectionSupplier > m_xSelectionSupplier;	147	::com::sun::star::view::XSelectionSupplier > m_xSelectionSupplier;
125	::com::sun::star::uno::Reference<	148	::com::sun::star::uno::Reference<
126	::com::sun::star::frame::XDispatch > m_xDispatch;	149	::com::sun::star::frame::XDispatch > m_xDispatch;
127		150
128	::std::auto_ptr< impl::ModelState > m_apModelState;	151	::std::auto_ptr< impl::ModelState > m_apModelState;
		152
		153	::std::auto_ptr< impl::ControllerState > m_apControllerState;
		154
129	};	155	};
130		156
131	} // namespace chart	157	} // namespace chart
132		158
133	// CHART2_CONTROLLERCOMMANDDISPATCH_HXX	159	// CHART2_CONTROLLERCOMMANDDISPATCH_HXX
134	#endif	160	#endif

Lines 288-307 public: Link Here

(-)inc/DiagramHelper.hxx (-5 / +83 lines)
288	const ::com::sun::star::uno::Reference<	288	const ::com::sun::star::uno::Reference<
289	::com::sun::star::chart2::XDiagram > & xDiagram );	289	::com::sun::star::chart2::XDiagram > & xDiagram );
290		290
291	static bool areChartTypesCompatible( const ::com::sun::star::uno::Reference<	291	static bool areChartTypesCompatible( const ::com::sun::star::uno::Reference<
292	::com::sun::star::chart2::XChartType >& xFirstType,	292	::com::sun::star::chart2::XChartType >& xFirstType,
293	const ::com::sun::star::uno::Reference<	293	const ::com::sun::star::uno::Reference<
294	::com::sun::star::chart2::XChartType >& xSecondType );	294	::com::sun::star::chart2::XChartType >& xSecondType );
295		295
296	static bool moveSeries( const ::com::sun::star::uno::Reference<	296
297	::com::sun::star::chart2::XDiagram >& xDiagram,	297	/**
298	const ::com::sun::star::uno::Reference<	298	* Test if the series can be moved.
299	::com::sun::star::chart2::XDataSeries >& xGivenDataSeries, bool bForward );	299	*
		300	* @param xDiagram
		301	* Reference to the diagram that contains the selected series.
		302	*
		303	* @param xGivenDataSeries
		304	* Reference to the series that needs to be moved.
		305	*
		306	* @param bForward
		307	* Test to move the series forward or backward.
		308	*
		309	* @returns </TRUE> if the series can be moved.
		310	*
		311	*/
		312	static bool DiagramHelper::isSeriesMoveable(
		313	const ::com::sun::star::uno::Reference<
		314	::com::sun::star::chart2::XDiagram >& xDiagram,
		315	const ::com::sun::star::uno::Reference<
		316	::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
		317	bool bForward );
		318
		319	/**
		320	* Move the series forward or backward.
		321	*
		322	* @param xDiagram
		323	* Reference to the diagram that contains the selected series.
		324	*
		325	* @param xGivenDataSeries
		326	* Reference to the series that needs to be moved.
		327	*
		328	* @param bForward
		329	* Test to move the series forward or backward.
		330	*
		331	* @returns </TRUE> if the series was moved.
		332	*
		333	*/
		334	static bool moveSeries(
		335	const ::com::sun::star::uno::Reference<
		336	::com::sun::star::chart2::XDiagram >& xDiagram,
		337	const ::com::sun::star::uno::Reference<
		338	::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
		339	bool bForward );
300		340
301	static sal_Int32 getIndexOfSeriesWithinChartType(	341	static sal_Int32 getIndexOfSeriesWithinChartType(
302	const ::com::sun::star::uno::Reference<	342	const ::com::sun::star::uno::Reference<
303	::com::sun::star::chart2::XDataSeries >& xDataSeries,	343	::com::sun::star::chart2::XDataSeries >& xDataSeries,
304	const ::com::sun::star::uno::Reference<	344	const ::com::sun::star::uno::Reference<
305	::com::sun::star::chart2::XChartType >& xChartType );	345	::com::sun::star::chart2::XChartType >& xChartType );
306		346
307	enum BarConnectorState	347	enum BarConnectorState
Lines 319-335 public: Link Here
319	static BarConnectorState hasBarConnectors(	359	static BarConnectorState hasBarConnectors(
320	const ::com::sun::star::uno::Reference<	360	const ::com::sun::star::uno::Reference<
321	::com::sun::star::chart2::XDiagram >& xDiagram );	361	::com::sun::star::chart2::XDiagram >& xDiagram );
322		362
323	/** Set the property "ConnectDataPoints" to true for all series that are	363	/** Set the property "ConnectDataPoints" to true for all series that are
324	contained in chart types that support bar connectors (see	364	contained in chart types that support bar connectors (see
325	ChartTypeHelper::isSupportingBarConnectors)	365	ChartTypeHelper::isSupportingBarConnectors)
326		366
327	@return </TRUE> iff the property could be set at some data series	367	@return </TRUE> if the property could be set at some data series
328	*/	368	*/
329	static bool setBarConnectors(	369	static bool setBarConnectors(
330	const ::com::sun::star::uno::Reference<	370	const ::com::sun::star::uno::Reference<
331	::com::sun::star::chart2::XDiagram >& xDiagram,	371	::com::sun::star::chart2::XDiagram >& xDiagram,
332	bool bOn );	372	bool bOn );
333		373
334	/** Returns the default camera geometry that is set in the Diagram CTOR.	374	/** Returns the default camera geometry that is set in the Diagram CTOR.
335	This is not the property default!	375	This is not the property default!
Lines 359-372 public: Link Here
359	static void getCameraDistanceRange( double& rfMinimumDistance, double& rfMaximumDistance );	399	static void getCameraDistanceRange( double& rfMinimumDistance, double& rfMaximumDistance );
360		400
361	static bool isSupportingFloorAndWall( const ::com::sun::star::uno::Reference<	401	static bool isSupportingFloorAndWall( const ::com::sun::star::uno::Reference<
362	::com::sun::star::chart2::XDiagram > & xDiagram );	402	::com::sun::star::chart2::XDiagram > & xDiagram );
363		403
364	private:	404	private:
365	// not implemented	405	// not implemented
366	DiagramHelper();	406	DiagramHelper();
		407
		408	/**
		409	* This method implements the logic of checking if a series can be moved
		410	* forward/backward. Depending on the "bDoMove" parameter the series will
		411	* be moved (bDoMove = true) or the function just will just test if the
		412	* series can be moved without doing the move (bDoMove = false).
		413	*
		414	* Note : This function should be restructured, but is kept as is for the
		415	* moment.
		416	*
		417	* @param xDiagram
		418	* Reference to the diagram that contains the selected series.
		419	*
		420	* @param xGivenDataSeries
		421	* Reference to the series that needs to be moved.
		422	*
		423	* @param bForward
		424	* Move the series forward or backward.
		425	*
		426	* @param bDoMove
		427	* Should this function really move the series (true) or just test if it is
		428	* possible (false).
		429	*
		430	*
		431	* @returns
		432	* bDoMove = true
		433	* - True : if the move was done
		434	* - False : the move failed
		435	* bDoMove = false
		436	* - True : the series can be moved
		437	* - False : the series can not be moved
		438	*
		439	*/
		440	static bool lcl_moveSeriesOrCheckIfMoveIsAllowed(
		441	const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XDiagram >& xDiagram,
		442	const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XDataSeries >& xGivenDataSeries,
		443	bool bForward,
		444	bool bDoMove );
367	};	445	};
368		446
369	} // namespace chart	447	} // namespace chart
370		448
371	// CHART2_DIAGRAMHELPER_HXX	449	// CHART2_DIAGRAMHELPER_HXX
372	#endif	450	#endif

Lines 116-132 protected: Link Here

(-)controller/main/CommandDispatch.hxx (-1 / +1 lines)
116	@param xSingleListener	116	@param xSingleListener
117	If set, the event is only sent to this listener rather than to all	117	If set, the event is only sent to this listener rather than to all
118	registered ones. Whenever a listener adds itself, this method is	118	registered ones. Whenever a listener adds itself, this method is
119	called with this parameter set to give an initial state.	119	called with this parameter set to give an initial state.
120	*/	120	*/
121	void fireStatusEventForURL(	121	void fireStatusEventForURL(
122	const ::rtl::OUString & rURL,	122	const ::rtl::OUString & rURL,
123	const ::com::sun::star::uno::Any & rState,	123	const ::com::sun::star::uno::Any & rState,
124	sal_Bool bEnabled,	124	bool bEnabled,
125	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener =	125	const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener > & xSingleListener =
126	::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener >() );	126	::com::sun::star::uno::Reference< ::com::sun::star::frame::XStatusListener >() );
127		127
128	// ____ XDispatch ____	128	// ____ XDispatch ____
129	virtual void SAL_CALL dispatch(	129	virtual void SAL_CALL dispatch(
130	const ::com::sun::star::util::URL& URL,	130	const ::com::sun::star::util::URL& URL,
131	const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& Arguments )	131	const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& Arguments )
132	throw (::com::sun::star::uno::RuntimeException);	132	throw (::com::sun::star::uno::RuntimeException);

Lines 1084-1227 bool DiagramHelper::areChartTypesCompati Link Here

(-)tools/DiagramHelper.cxx (-79 / +179 lines)
1084		1084
1085	::std::vector< ::rtl::OUString > aFirstRoles( ContainerHelper::SequenceToVector( xFirstType->getSupportedMandatoryRoles() ) );	1085	::std::vector< ::rtl::OUString > aFirstRoles( ContainerHelper::SequenceToVector( xFirstType->getSupportedMandatoryRoles() ) );
1086	::std::vector< ::rtl::OUString > aSecondRoles( ContainerHelper::SequenceToVector( xSecondType->getSupportedMandatoryRoles() ) );	1086	::std::vector< ::rtl::OUString > aSecondRoles( ContainerHelper::SequenceToVector( xSecondType->getSupportedMandatoryRoles() ) );
1087	::std::sort( aFirstRoles.begin(), aFirstRoles.end() );	1087	::std::sort( aFirstRoles.begin(), aFirstRoles.end() );
1088	::std::sort( aSecondRoles.begin(), aSecondRoles.end() );	1088	::std::sort( aSecondRoles.begin(), aSecondRoles.end() );
1089	return ( aFirstRoles == aSecondRoles );	1089	return ( aFirstRoles == aSecondRoles );
1090	}	1090	}
1091		1091
		1092
		1093
		1094	bool DiagramHelper::isSeriesMoveable(
		1095	const Reference< XDiagram >& xDiagram,
		1096	const Reference< XDataSeries >& xGivenDataSeries,
		1097	bool bForward )
		1098	{
		1099
		1100	bool bIsMoveable = false;
		1101	const bool bDoMove = false;
		1102
		1103	bIsMoveable = lcl_moveSeriesOrCheckIfMoveIsAllowed(
		1104	xDiagram, xGivenDataSeries, bForward, bDoMove );
		1105
		1106	return bIsMoveable;
		1107	}
		1108
		1109
1092	bool DiagramHelper::moveSeries( const Reference< XDiagram >& xDiagram, const Reference< XDataSeries >& xGivenDataSeries, bool bForward )	1110	bool DiagramHelper::moveSeries( const Reference< XDiagram >& xDiagram, const Reference< XDataSeries >& xGivenDataSeries, bool bForward )
1093	{	1111	{
1094	bool bChanged = false;	1112
		1113	bool bMoved = false;
		1114	const bool bDoMove = true;
		1115
		1116	bMoved = lcl_moveSeriesOrCheckIfMoveIsAllowed(
		1117	xDiagram, xGivenDataSeries, bForward, bDoMove );
		1118
		1119	return bMoved;
		1120	}
		1121
		1122
		1123	bool DiagramHelper::lcl_moveSeriesOrCheckIfMoveIsAllowed(
		1124	const Reference< XDiagram >& xDiagram,
		1125	const Reference< XDataSeries >& xGivenDataSeries,
		1126	bool bForward,
		1127	bool bDoMove )
		1128	{
		1129
		1130	OSL_TRACE( "LOCAL_MOVE_SERIES" );
		1131
		1132	if( bForward )
		1133	OSL_TRACE( "move forward" );
		1134	else
		1135	OSL_TRACE( "move backward" );
		1136
		1137
		1138	if( bDoMove )
		1139	OSL_TRACE( "Really move" );
		1140	else
		1141	OSL_TRACE( "DO NOT move" );
		1142
		1143
		1144	bool bMovedOrMoveAllowed = false;
		1145
1095	try	1146	try
1096	{	1147	{
1097	uno::Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );	1148	uno::Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
1098		1149
1099	//find position of series	1150	// Find position of series.
1100	bool bFound = false;	1151	bool bFound = false;
1101		1152
1102	if( xGivenDataSeries.is() && xCooSysContainer.is() )	1153	if( xGivenDataSeries.is() && xCooSysContainer.is() )
1103	{	1154	{
1104	uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );	1155	uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );
		1156
		1157	// Coordinate system(s). At the moment, there is only one
		1158	// coordinate.
1105	for( sal_Int32 nCS = 0; !bFound && nCS < aCooSysList.getLength(); ++nCS )	1159	for( sal_Int32 nCS = 0; !bFound && nCS < aCooSysList.getLength(); ++nCS )
1106	{	1160	{
1107	uno::Reference< XCoordinateSystem > xCooSys( aCooSysList[nCS] );	1161	uno::Reference< XCoordinateSystem > xCooSys( aCooSysList[nCS] );
1108		1162
1109	//iterate through all chart types in the current coordinate system	1163	//iterate through all chart types in the current coordinate system
1110	uno::Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );	1164	uno::Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );
1111	OSL_ASSERT( xChartTypeContainer.is());	1165	OSL_ASSERT( xChartTypeContainer.is());
1112	if( !xChartTypeContainer.is() )	1166	if( !xChartTypeContainer.is() )
1113	continue;	1167	continue;
1114	uno::Sequence< uno::Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );	1168	uno::Sequence< uno::Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );
1115	uno::Reference< XChartType > xFormerChartType;	1169	uno::Reference< XChartType > xFormerChartType;
		1170
1116	for( sal_Int32 nT = 0; !bFound && nT < aChartTypeList.getLength(); ++nT )	1171	for( sal_Int32 nT = 0; !bFound && nT < aChartTypeList.getLength(); ++nT )
1117	{	1172	{
1118	uno::Reference< XChartType > xCurrentChartType( aChartTypeList[nT] );	1173	uno::Reference< XChartType > xCurrentChartType( aChartTypeList[nT] );
1119		1174
1120	//iterate through all series in this chart type	1175	//iterate through all series in this chart type
1121	uno::Reference< XDataSeriesContainer > xDataSeriesContainer( xCurrentChartType, uno::UNO_QUERY );	1176	uno::Reference< XDataSeriesContainer > xDataSeriesContainer( xCurrentChartType, uno::UNO_QUERY );
1122	OSL_ASSERT( xDataSeriesContainer.is());	1177	OSL_ASSERT( xDataSeriesContainer.is());
1123	if( !xDataSeriesContainer.is() )	1178	if( !xDataSeriesContainer.is() )
1124	continue;	1179	continue;
1125		1180
1126	uno::Sequence< uno::Reference< XDataSeries > > aSeriesList( xDataSeriesContainer->getDataSeries() );	1181	uno::Sequence< uno::Reference< XDataSeries > > aSeriesList( xDataSeriesContainer->getDataSeries() );
		1182
		1183
1127	for( sal_Int32 nS = 0; !bFound && nS < aSeriesList.getLength(); ++nS )	1184	for( sal_Int32 nS = 0; !bFound && nS < aSeriesList.getLength(); ++nS )
1128	{	1185	{
1129	if( xGivenDataSeries==aSeriesList[nS] )	1186
		1187	// Aim : know at which index is the series.
		1188	// We found the series we are interrested in !
		1189	if( xGivenDataSeries==aSeriesList[nS] )
1130	{	1190	{
1131	sal_Int32 nOldCooSysIndex=nCS;	1191	sal_Int32 nOldCooSysIndex = nCS;
1132	sal_Int32 nOldChartTypeIndex=nT;	1192	sal_Int32 nOldChartTypeIndex = nT;
1133	sal_Int32 nOldSeriesIndex=nS;	1193	sal_Int32 nOldSeriesIndex = nS;
1134	bFound = true;	1194	bFound = true;
1135		1195
1136	try	1196	try
1137	{	1197	{
1138	sal_Int32 nNewSeriesIndex=nS;	1198	sal_Int32 nNewSeriesIndex = nS;
1139	if( bForward )	1199
		1200	// Should the series be moved forward or backward.
		1201	if( bForward )
1140	nNewSeriesIndex--;	1202	nNewSeriesIndex--;
1141	else	1203	else
1142	nNewSeriesIndex++;	1204	nNewSeriesIndex++;
1143	if( nNewSeriesIndex >= 0 && nNewSeriesIndex < aSeriesList.getLength() )	1205
1144	{	1206
1145	//move series in the same charttype	1207	// --- Moving in real the series -------------
1146	bChanged = true;	1208
1147	aSeriesList[nOldSeriesIndex]=aSeriesList[nNewSeriesIndex];	1209	if( bDoMove )
1148	aSeriesList[nNewSeriesIndex]=xGivenDataSeries;	1210	{
1149	xDataSeriesContainer->setDataSeries(aSeriesList);	1211
1150	}	1212
1151	else if( nNewSeriesIndex<0 )	1213	if( nNewSeriesIndex >= 0 && nNewSeriesIndex < aSeriesList.getLength() )
1152	{	1214	{
1153	//exchange series with former charttype	1215	//move series in the same charttype
1154	if( xFormerChartType.is() && DiagramHelper::areChartTypesCompatible( xFormerChartType, xCurrentChartType ) )	1216	bMovedOrMoveAllowed = true;
1155	{	1217	aSeriesList[ nOldSeriesIndex ] = aSeriesList[ nNewSeriesIndex ];
1156	bChanged = true;	1218	aSeriesList[ nNewSeriesIndex ] = xGivenDataSeries;
1157	uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xFormerChartType, uno::UNO_QUERY );	1219	xDataSeriesContainer->setDataSeries( aSeriesList );
1158	if( xOtherDataSeriesContainer.is() )	1220	}
1159	{	1221	else if( nNewSeriesIndex<0 )
1160	uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );	1222	{
1161	sal_Int32 nOtherSeriesIndex = aOtherSeriesList.getLength()-1;	1223	//exchange series with former charttype
1162	if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )	1224	if( xFormerChartType.is() && DiagramHelper::areChartTypesCompatible( xFormerChartType, xCurrentChartType ) )
1163	{	1225	{
1164	uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );	1226	bMovedOrMoveAllowed = true;
1165	aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;	1227	uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xFormerChartType, uno::UNO_QUERY );
1166	xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);	1228	if( xOtherDataSeriesContainer.is() )
		1229	{
		1230	uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );
		1231	sal_Int32 nOtherSeriesIndex = aOtherSeriesList.getLength()-1;
		1232	if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )
		1233	{
		1234	uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );
		1235	aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;
		1236	xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);
1167		1237
1168	aSeriesList[nOldSeriesIndex]=xExchangeSeries;	1238	aSeriesList[nOldSeriesIndex]=xExchangeSeries;
1169	xDataSeriesContainer->setDataSeries(aSeriesList);	1239	xDataSeriesContainer->setDataSeries(aSeriesList);
1170	}	1240	}
1171	}	1241	}
1172	}	1242	}
1173	}	1243	}
1174	else if( nT+1 < aChartTypeList.getLength() )	1244	else if( nT+1 < aChartTypeList.getLength() )
1175	{	1245	{
1176	//exchange series with next charttype	1246	//exchange series with next charttype
1177	uno::Reference< XChartType > xOtherChartType( aChartTypeList[nT+1] );	1247	uno::Reference< XChartType > xOtherChartType( aChartTypeList[nT+1] );
1178	if( xOtherChartType.is() && DiagramHelper::areChartTypesCompatible( xOtherChartType, xCurrentChartType ) )	1248	if( xOtherChartType.is() && DiagramHelper::areChartTypesCompatible( xOtherChartType, xCurrentChartType ) )
1179	{	1249	{
1180	bChanged = true;	1250	bMovedOrMoveAllowed = true;
1181	uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xOtherChartType, uno::UNO_QUERY );	1251	uno::Reference< XDataSeriesContainer > xOtherDataSeriesContainer( xOtherChartType, uno::UNO_QUERY );
1182	if( xOtherDataSeriesContainer.is() )	1252	if( xOtherDataSeriesContainer.is() )
1183	{	1253	{
1184	uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );	1254	uno::Sequence< uno::Reference< XDataSeries > > aOtherSeriesList( xOtherDataSeriesContainer->getDataSeries() );
1185	sal_Int32 nOtherSeriesIndex = 0;	1255	sal_Int32 nOtherSeriesIndex = 0;
1186	if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )	1256	if( nOtherSeriesIndex >= 0 && nOtherSeriesIndex < aOtherSeriesList.getLength() )
1187	{	1257	{
1188	uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );	1258	uno::Reference< XDataSeries > xExchangeSeries( aOtherSeriesList[nOtherSeriesIndex] );
1189	aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;	1259	aOtherSeriesList[nOtherSeriesIndex] = xGivenDataSeries;
1190	xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);	1260	xOtherDataSeriesContainer->setDataSeries(aOtherSeriesList);
1191		1261
1192	aSeriesList[nOldSeriesIndex]=xExchangeSeries;	1262	aSeriesList[nOldSeriesIndex]=xExchangeSeries;
1193	xDataSeriesContainer->setDataSeries(aSeriesList);	1263	xDataSeriesContainer->setDataSeries(aSeriesList);
1194	}	1264	}
1195	}	1265	}
1196	}	1266	}
1197	}	1267	}
1198		1268
1199	}	1269	// --- End Moving the series --------------------
1200	catch( util::CloseVetoException& )	1270
1201	{	1271	}
1202	}	1272
1203	catch( uno::RuntimeException& )	1273	// --- Test if the series can be moved without
1204	{	1274	// doing the move. ---
1205	}	1275
1206	}	1276	else
1207	}	1277	{
1208	xFormerChartType = xCurrentChartType;	1278
1209	}	1279	if( nNewSeriesIndex >= 0 && nNewSeriesIndex < aSeriesList.getLength() )
1210	}	1280	bMovedOrMoveAllowed = true;
1211	}	1281
1212	}	1282	else if( nNewSeriesIndex<0 )
1213	catch( util::CloseVetoException& )	1283	{
1214	{	1284	//exchange series with former charttype
1215	}	1285	if( xFormerChartType.is() && DiagramHelper::areChartTypesCompatible( xFormerChartType, xCurrentChartType ) )
1216	catch( uno::RuntimeException& )	1286	bMovedOrMoveAllowed = true;
1217	{	1287	}
1218	}	1288	else if( nT+1 < aChartTypeList.getLength() )
1219	return bChanged;	1289	{
		1290	//exchange series with next charttype
		1291	uno::Reference< XChartType > xOtherChartType( aChartTypeList[nT+1] );
		1292	if( xOtherChartType.is() && DiagramHelper::areChartTypesCompatible( xOtherChartType, xCurrentChartType ) )
		1293	{
		1294	bMovedOrMoveAllowed = true;
		1295	}
		1296	}
		1297	}
		1298
		1299	}
		1300	catch( util::CloseVetoException& )
		1301	{
		1302	}
		1303	catch( uno::RuntimeException& )
		1304	{
		1305	}
		1306	}
		1307	}
		1308	xFormerChartType = xCurrentChartType;
		1309	}
		1310	}
		1311	}
		1312	}
		1313	catch( util::CloseVetoException& )
		1314	{
		1315	}
		1316	catch( uno::RuntimeException& )
		1317	{
		1318	}
		1319	return bMovedOrMoveAllowed;
1220	}	1320	}
1221		1321
1222	sal_Int32 DiagramHelper::getIndexOfSeriesWithinChartType(	1322	sal_Int32 DiagramHelper::getIndexOfSeriesWithinChartType(
1223	const Reference< XDataSeries >& xDataSeries,	1323	const Reference< XDataSeries >& xDataSeries,
1224	const Reference< XChartType >& xChartType )	1324	const Reference< XChartType >& xChartType )
1225	{	1325	{
1226	sal_Int32 nRet = -1;	1326	sal_Int32 nRet = -1;
1227		1327