LCOV - code coverage report
Current view: top level - chart2/source/controller/main - ChartController_Tools.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 10 443 2.3 %
Date: 2014-11-03 Functions: 4 23 17.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "ChartController.hxx"
      21             : #include "ChartWindow.hxx"
      22             : #include "ChartModelHelper.hxx"
      23             : #include "TitleHelper.hxx"
      24             : #include "ThreeDHelper.hxx"
      25             : #include "DataSeriesHelper.hxx"
      26             : #include "UndoGuard.hxx"
      27             : #include "ControllerLockGuard.hxx"
      28             : #include "macros.hxx"
      29             : #include "ResId.hxx"
      30             : #include "Strings.hrc"
      31             : #include "ObjectIdentifier.hxx"
      32             : #include "ReferenceSizeProvider.hxx"
      33             : #include "chartview/ExplicitValueProvider.hxx"
      34             : #include "chartview/DrawModelWrapper.hxx"
      35             : #include "ChartTransferable.hxx"
      36             : #include "DrawViewWrapper.hxx"
      37             : #include "LegendHelper.hxx"
      38             : #include "AxisHelper.hxx"
      39             : #include "RegressionCurveHelper.hxx"
      40             : #include "ShapeController.hxx"
      41             : #include "DiagramHelper.hxx"
      42             : #include "ObjectNameProvider.hxx"
      43             : #include <unonames.hxx>
      44             : 
      45             : #include <com/sun/star/chart2/DataPointLabel.hpp>
      46             : #include <com/sun/star/beans/XPropertyState.hpp>
      47             : #include <com/sun/star/drawing/CameraGeometry.hpp>
      48             : #include <com/sun/star/graphic/XGraphic.hpp>
      49             : #include <com/sun/star/io/XInputStream.hpp>
      50             : #include <com/sun/star/text/XTextRange.hpp>
      51             : #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
      52             : #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
      53             : #include <com/sun/star/chart/ErrorBarStyle.hpp>
      54             : 
      55             : #include <svx/ActionDescriptionProvider.hxx>
      56             : #include <svtools/transfer.hxx>
      57             : #include <sot/storage.hxx>
      58             : #include <vcl/graph.hxx>
      59             : #include <svx/unomodel.hxx>
      60             : #include <svx/svdmodel.hxx>
      61             : #include <unotools/streamwrap.hxx>
      62             : #include <vcl/svapp.hxx>
      63             : #include <osl/mutex.hxx>
      64             : #include <svx/dialmgr.hxx>
      65             : #include <svx/dialogs.hrc>
      66             : #include <editeng/outliner.hxx>
      67             : #include <svx/svditer.hxx>
      68             : #include <svx/svdpage.hxx>
      69             : #include <svx/svdundo.hxx>
      70             : #include <svx/unoapi.hxx>
      71             : #include <svx/unopage.hxx>
      72             : 
      73             : #include <boost/scoped_ptr.hpp>
      74             : 
      75             : using namespace ::com::sun::star;
      76             : 
      77             : using ::com::sun::star::uno::Reference;
      78             : using ::com::sun::star::uno::Sequence;
      79             : 
      80             : namespace chart
      81             : {
      82             : 
      83             : namespace
      84             : {
      85             : 
      86           0 : bool lcl_deleteDataSeries(
      87             :     const OUString & rCID,
      88             :     const Reference< frame::XModel > & xModel,
      89             :     const Reference< document::XUndoManager > & xUndoManager )
      90             : {
      91           0 :     bool bResult = false;
      92           0 :     uno::Reference< chart2::XDataSeries > xSeries( ObjectIdentifier::getDataSeriesForCID( rCID, xModel ));
      93           0 :     uno::Reference< chart2::XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
      94           0 :     if( xSeries.is() && xChartDoc.is())
      95             :     {
      96             :         uno::Reference< chart2::XChartType > xChartType(
      97           0 :             DataSeriesHelper::getChartTypeOfSeries( xSeries, xChartDoc->getFirstDiagram()));
      98           0 :         if( xChartType.is())
      99             :         {
     100             :             UndoGuard aUndoGuard(
     101             :                 ActionDescriptionProvider::createDescription(
     102             :                     ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_DATASERIES )),
     103           0 :                 xUndoManager );
     104             : 
     105           0 :             Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( xModel ) );
     106           0 :             uno::Reference< chart2::XAxis > xAxis( DiagramHelper::getAttachedAxis( xSeries, xDiagram ) );
     107             : 
     108           0 :             DataSeriesHelper::deleteSeries( xSeries, xChartType );
     109             : 
     110           0 :             AxisHelper::hideAxisIfNoDataIsAttached( xAxis, xDiagram );
     111             : 
     112           0 :             bResult = true;
     113           0 :             aUndoGuard.commit();
     114           0 :         }
     115             :     }
     116           0 :     return bResult;
     117             : }
     118             : 
     119           0 : bool lcl_deleteDataCurve(
     120             :     const OUString & rCID,
     121             :     const Reference< frame::XModel > & xModel,
     122             :     const Reference< document::XUndoManager > & xUndoManager )
     123             : {
     124           0 :     bool bResult = false;
     125             : 
     126             :     uno::Reference< beans::XPropertySet > xProperties(
     127           0 :         ObjectIdentifier::getObjectPropertySet( rCID, xModel));
     128             : 
     129           0 :     uno::Reference< chart2::XRegressionCurve > xRegressionCurve( xProperties, uno::UNO_QUERY );
     130             : 
     131           0 :     if( xRegressionCurve.is())
     132             :     {
     133             :         uno::Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer(
     134             :             ObjectIdentifier::getObjectPropertySet(
     135           0 :                 ObjectIdentifier::getFullParentParticle( rCID ), xModel), uno::UNO_QUERY );
     136             : 
     137           0 :         if( xRegressionCurveContainer.is())
     138             :         {
     139             :             UndoGuard aUndoGuard = UndoGuard(
     140             :                 ActionDescriptionProvider::createDescription(
     141             :                     ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_CURVE )),
     142           0 :                 xUndoManager );
     143             : 
     144           0 :             xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );
     145             : 
     146           0 :             bResult = true;
     147           0 :             aUndoGuard.commit();
     148           0 :         }
     149             :     }
     150           0 :     return bResult;
     151             : }
     152             : 
     153             : } // anonymous namespace
     154             : 
     155           0 : ReferenceSizeProvider* ChartController::impl_createReferenceSizeProvider()
     156             : {
     157           0 :     awt::Size aPageSize( ChartModelHelper::getPageSize( getModel() ) );
     158             : 
     159             :     return new ReferenceSizeProvider(
     160           0 :         aPageSize, Reference<chart2::XChartDocument>(getModel(), uno::UNO_QUERY));
     161             : }
     162             : 
     163           0 : void ChartController::impl_adaptDataSeriesAutoResize()
     164             : {
     165           0 :     boost::scoped_ptr<ReferenceSizeProvider> pRefSizeProvider(impl_createReferenceSizeProvider());
     166           0 :     if (pRefSizeProvider)
     167           0 :         pRefSizeProvider->setValuesAtAllDataSeries();
     168           0 : }
     169             : 
     170           0 : void ChartController::executeDispatch_NewArrangement()
     171             : {
     172             :     // remove manual positions at titles, legend and the diagram, remove manual
     173             :     // size at the diagram
     174             : 
     175             :     try
     176             :     {
     177           0 :         Reference< frame::XModel > xModel( getModel() );
     178           0 :         Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( xModel ));
     179           0 :         if( xDiagram.is())
     180             :         {
     181             :             // using assignment for broken gcc 3.3
     182             :             UndoGuard aUndoGuard = UndoGuard(
     183             :                 SCH_RESSTR( STR_ACTION_REARRANGE_CHART ),
     184           0 :                 m_xUndoManager );
     185           0 :             ControllerLockGuardUNO aCtlLockGuard( xModel );
     186             : 
     187             :             // diagram
     188           0 :             Reference< beans::XPropertyState > xState( xDiagram, uno::UNO_QUERY_THROW );
     189           0 :             xState->setPropertyToDefault( "RelativeSize");
     190           0 :             xState->setPropertyToDefault( "RelativePosition");
     191           0 :             xState->setPropertyToDefault( "PosSizeExcludeAxes");
     192             : 
     193             :             // 3d rotation
     194           0 :             ThreeDHelper::set3DSettingsToDefault( uno::Reference< beans::XPropertySet >( xDiagram, uno::UNO_QUERY ) );
     195             : 
     196             :             // legend
     197           0 :             Reference< beans::XPropertyState > xLegendState( xDiagram->getLegend(), uno::UNO_QUERY );
     198           0 :             if( xLegendState.is())
     199             :             {
     200           0 :                 xLegendState->setPropertyToDefault( "RelativePosition");
     201           0 :                 xLegendState->setPropertyToDefault( "RelativeSize");
     202           0 :                 xLegendState->setPropertyToDefault( "AnchorPosition");
     203             :             }
     204             : 
     205             :             // titles
     206           0 :             for( sal_Int32 eType = TitleHelper::TITLE_BEGIN;
     207             :                  eType < TitleHelper::NORMAL_TITLE_END;
     208             :                  ++eType )
     209             :             {
     210             :                 Reference< beans::XPropertyState > xTitleState(
     211             :                     TitleHelper::getTitle(
     212           0 :                         static_cast< TitleHelper::eTitleType >( eType ), xModel ), uno::UNO_QUERY );
     213           0 :                 if( xTitleState.is())
     214           0 :                     xTitleState->setPropertyToDefault( "RelativePosition");
     215           0 :             }
     216             : 
     217             :             // regression curve equations
     218             :             ::std::vector< Reference< chart2::XRegressionCurve > > aRegressionCurves(
     219           0 :                 RegressionCurveHelper::getAllRegressionCurvesNotMeanValueLine( xDiagram ));
     220             :             ::std::for_each( aRegressionCurves.begin(), aRegressionCurves.end(),
     221           0 :                       RegressionCurveHelper::resetEquationPosition );
     222             : 
     223           0 :             aUndoGuard.commit();
     224           0 :         }
     225             :     }
     226           0 :     catch( const uno::RuntimeException & ex )
     227             :     {
     228             :         ASSERT_EXCEPTION( ex );
     229             :     }
     230           0 : }
     231             : 
     232           0 : void ChartController::executeDispatch_ScaleText()
     233             : {
     234           0 :     SolarMutexGuard aSolarGuard;
     235             :     // using assignment for broken gcc 3.3
     236             :     UndoGuard aUndoGuard = UndoGuard(
     237             :         SCH_RESSTR( STR_ACTION_SCALE_TEXT ),
     238           0 :         m_xUndoManager );
     239           0 :     ControllerLockGuardUNO aCtlLockGuard( getModel() );
     240             : 
     241           0 :     boost::scoped_ptr<ReferenceSizeProvider> pRefSizeProv(impl_createReferenceSizeProvider());
     242             :     OSL_ASSERT( pRefSizeProv.get());
     243           0 :     if (pRefSizeProv)
     244           0 :         pRefSizeProv->toggleAutoResizeState();
     245             : 
     246           0 :     aUndoGuard.commit();
     247           0 : }
     248             : 
     249           0 : void ChartController::executeDispatch_Paste()
     250             : {
     251           0 :     SolarMutexGuard aGuard;
     252           0 :     if( m_pChartWindow )
     253             :     {
     254           0 :         Graphic aGraphic;
     255             :         // paste location: center of window
     256           0 :         Point aPos;
     257           0 :         aPos = m_pChartWindow->PixelToLogic( Rectangle( aPos, m_pChartWindow->GetSizePixel()).Center());
     258             : 
     259             :         // handle different formats
     260           0 :         TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( m_pChartWindow ));
     261           0 :         if( aDataHelper.GetTransferable().is())
     262             :         {
     263           0 :             if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ) )
     264             :             {
     265           0 :                 SotStorageStreamRef xStm;
     266           0 :                 if ( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xStm ) )
     267             :                 {
     268           0 :                     xStm->Seek( 0 );
     269           0 :                     Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );
     270           0 :                     ::boost::scoped_ptr< SdrModel > spModel( new SdrModel() );
     271           0 :                     if ( SvxDrawingLayerImport( spModel.get(), xInputStream ) )
     272             :                     {
     273           0 :                         impl_PasteShapes( spModel.get() );
     274           0 :                     }
     275           0 :                 }
     276             :             }
     277           0 :             else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) )
     278             :             {
     279             :                 // graphic exchange format (graphic manager bitmap format?)
     280           0 :                 SotStorageStreamRef xStm;
     281           0 :                 if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_SVXB, xStm ))
     282           0 :                     ReadGraphic( *xStm, aGraphic );
     283             :             }
     284           0 :             else if( aDataHelper.HasFormat( FORMAT_GDIMETAFILE ))
     285             :             {
     286             :                 // meta file
     287           0 :                 GDIMetaFile aMetafile;
     288           0 :                 if( aDataHelper.GetGDIMetaFile( FORMAT_GDIMETAFILE, aMetafile ))
     289           0 :                     aGraphic = Graphic( aMetafile );
     290             :             }
     291           0 :             else if( aDataHelper.HasFormat( FORMAT_BITMAP ))
     292             :             {
     293             :                 // bitmap (non-graphic-manager)
     294           0 :                 BitmapEx aBmpEx;
     295           0 :                 if( aDataHelper.GetBitmapEx( FORMAT_BITMAP, aBmpEx ))
     296           0 :                     aGraphic = Graphic( aBmpEx );
     297             :             }
     298           0 :             else if( aDataHelper.HasFormat( FORMAT_STRING ))
     299             :             {
     300           0 :                 OUString aString;
     301           0 :                 if( aDataHelper.GetString( FORMAT_STRING, aString ) && m_pDrawModelWrapper )
     302             :                 {
     303           0 :                     if( m_pDrawViewWrapper )
     304             :                     {
     305           0 :                         OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
     306           0 :                         if( pOutlinerView )//in case of edit mode insert into edited string
     307           0 :                             pOutlinerView->InsertText( aString );
     308             :                         else
     309             :                         {
     310           0 :                             impl_PasteStringAsTextShape( aString, awt::Point( 0, 0 ) );
     311             :                         }
     312             :                     }
     313           0 :                 }
     314             :             }
     315             :         }
     316             : 
     317           0 :         if( aGraphic.GetType() != GRAPHIC_NONE )
     318             :         {
     319           0 :             Reference< graphic::XGraphic > xGraphic( aGraphic.GetXGraphic());
     320           0 :             if( xGraphic.is())
     321           0 :                 impl_PasteGraphic( xGraphic, aPos );
     322           0 :         }
     323           0 :     }
     324           0 : }
     325             : 
     326             : // note: aPosition is ignored for now. The object is always pasted centered to
     327             : // the page
     328           0 : void ChartController::impl_PasteGraphic(
     329             :     uno::Reference< graphic::XGraphic > & xGraphic,
     330             :     const ::Point & /* aPosition */ )
     331             : {
     332             :     // note: the XPropertySet of the model is the old API. Also the property
     333             :     // "AdditionalShapes" that is used there.
     334           0 :     uno::Reference< beans::XPropertySet > xModelProp( getModel(), uno::UNO_QUERY );
     335           0 :     DrawModelWrapper * pDrawModelWrapper( this->GetDrawModelWrapper());
     336           0 :     if( ! (xGraphic.is() && xModelProp.is()))
     337           0 :         return;
     338           0 :     uno::Reference< lang::XMultiServiceFactory > xFact( pDrawModelWrapper->getShapeFactory());
     339             :     uno::Reference< drawing::XShape > xGraphicShape(
     340           0 :         xFact->createInstance( "com.sun.star.drawing.GraphicObjectShape" ), uno::UNO_QUERY );
     341           0 :     uno::Reference< beans::XPropertySet > xGraphicShapeProp( xGraphicShape, uno::UNO_QUERY );
     342           0 :     if( xGraphicShapeProp.is() && xGraphicShape.is())
     343             :     {
     344           0 :         uno::Reference< drawing::XShapes > xPage( pDrawModelWrapper->getMainDrawPage(), uno::UNO_QUERY );
     345           0 :         if( xPage.is())
     346             :         {
     347           0 :             xPage->add( xGraphicShape );
     348             :             //need to change the model state manually
     349             :             {
     350           0 :                 uno::Reference< util::XModifiable > xModifiable( getModel(), uno::UNO_QUERY );
     351           0 :                 if( xModifiable.is() )
     352           0 :                     xModifiable->setModified( true );
     353             :             }
     354             :             //select new shape
     355           0 :             m_aSelection.setSelection( xGraphicShape );
     356           0 :             m_aSelection.applySelection( m_pDrawViewWrapper );
     357             :         }
     358           0 :         xGraphicShapeProp->setPropertyValue( "Graphic", uno::makeAny( xGraphic ));
     359           0 :         uno::Reference< beans::XPropertySet > xGraphicProp( xGraphic, uno::UNO_QUERY );
     360             : 
     361           0 :         awt::Size aGraphicSize( 1000, 1000 );
     362             :         // first try size in 100th mm, then pixel size
     363           0 :         if( ! ( xGraphicProp->getPropertyValue( "Size100thMM") >>= aGraphicSize ) &&
     364           0 :             ( ( xGraphicProp->getPropertyValue( "SizePixel") >>= aGraphicSize ) && m_pChartWindow ))
     365             :         {
     366           0 :             ::Size aVCLSize( m_pChartWindow->PixelToLogic( Size( aGraphicSize.Width, aGraphicSize.Height )));
     367           0 :             aGraphicSize.Width = aVCLSize.getWidth();
     368           0 :             aGraphicSize.Height = aVCLSize.getHeight();
     369             :         }
     370           0 :         xGraphicShape->setSize( aGraphicSize );
     371           0 :         xGraphicShape->setPosition( awt::Point( 0, 0 ) );
     372           0 :     }
     373             : }
     374             : 
     375           0 : void ChartController::impl_PasteShapes( SdrModel* pModel )
     376             : {
     377           0 :     DrawModelWrapper* pDrawModelWrapper( this->GetDrawModelWrapper() );
     378           0 :     if ( pDrawModelWrapper && m_pDrawViewWrapper )
     379             :     {
     380           0 :         Reference< drawing::XDrawPage > xDestPage( pDrawModelWrapper->getMainDrawPage() );
     381           0 :         SdrPage* pDestPage = GetSdrPageFromXDrawPage( xDestPage );
     382           0 :         if ( pDestPage )
     383             :         {
     384           0 :             Reference< drawing::XShape > xSelShape;
     385           0 :             m_pDrawViewWrapper->BegUndo( SVX_RESSTR( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
     386           0 :             sal_uInt16 nCount = pModel->GetPageCount();
     387           0 :             for ( sal_uInt16 i = 0; i < nCount; ++i )
     388             :             {
     389           0 :                 const SdrPage* pPage = pModel->GetPage( i );
     390           0 :                 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
     391           0 :                 while ( aIter.IsMore() )
     392             :                 {
     393           0 :                     SdrObject* pObj = aIter.Next();
     394           0 :                     SdrObject* pNewObj = ( pObj ? pObj->Clone() : NULL );
     395           0 :                     if ( pNewObj )
     396             :                     {
     397           0 :                         pNewObj->SetModel( &pDrawModelWrapper->getSdrModel() );
     398           0 :                         pNewObj->SetPage( pDestPage );
     399             : 
     400             :                         // set position
     401           0 :                         Reference< drawing::XShape > xShape( pNewObj->getUnoShape(), uno::UNO_QUERY );
     402           0 :                         if ( xShape.is() )
     403             :                         {
     404           0 :                             xShape->setPosition( awt::Point( 0, 0 ) );
     405             :                         }
     406             : 
     407           0 :                         pDestPage->InsertObject( pNewObj );
     408           0 :                         m_pDrawViewWrapper->AddUndo( new SdrUndoInsertObj( *pNewObj ) );
     409           0 :                         xSelShape = xShape;
     410             :                     }
     411             :                 }
     412           0 :             }
     413             : 
     414           0 :             Reference< util::XModifiable > xModifiable( getModel(), uno::UNO_QUERY );
     415           0 :             if ( xModifiable.is() )
     416             :             {
     417           0 :                 xModifiable->setModified( true );
     418             :             }
     419             : 
     420             :             // select last inserted shape
     421           0 :             m_aSelection.setSelection( xSelShape );
     422           0 :             m_aSelection.applySelection( m_pDrawViewWrapper );
     423             : 
     424           0 :             m_pDrawViewWrapper->EndUndo();
     425             : 
     426           0 :             impl_switchDiagramPositioningToExcludingPositioning();
     427           0 :         }
     428             :     }
     429           0 : }
     430             : 
     431           0 : void ChartController::impl_PasteStringAsTextShape( const OUString& rString, const awt::Point& rPosition )
     432             : {
     433           0 :     DrawModelWrapper* pDrawModelWrapper( this->GetDrawModelWrapper() );
     434           0 :     if ( pDrawModelWrapper && m_pDrawViewWrapper )
     435             :     {
     436           0 :         const Reference< lang::XMultiServiceFactory >& xShapeFactory( pDrawModelWrapper->getShapeFactory() );
     437           0 :         const Reference< drawing::XDrawPage >& xDrawPage( pDrawModelWrapper->getMainDrawPage() );
     438             :         OSL_ASSERT( xShapeFactory.is() && xDrawPage.is() );
     439             : 
     440           0 :         if ( xShapeFactory.is() && xDrawPage.is() )
     441             :         {
     442             :             try
     443             :             {
     444             :                 Reference< drawing::XShape > xTextShape(
     445           0 :                     xShapeFactory->createInstance( "com.sun.star.drawing.TextShape" ), uno::UNO_QUERY_THROW );
     446           0 :                 xDrawPage->add( xTextShape );
     447             : 
     448           0 :                 Reference< text::XTextRange > xRange( xTextShape, uno::UNO_QUERY_THROW );
     449           0 :                 xRange->setString( rString );
     450             : 
     451           0 :                 float fCharHeight = 10.0;
     452           0 :                 Reference< beans::XPropertySet > xProperties( xTextShape, uno::UNO_QUERY_THROW );
     453           0 :                 xProperties->setPropertyValue( "TextAutoGrowHeight", uno::makeAny( true ) );
     454           0 :                 xProperties->setPropertyValue( "TextAutoGrowWidth", uno::makeAny( true ) );
     455           0 :                 xProperties->setPropertyValue( "CharHeight", uno::makeAny( fCharHeight ) );
     456           0 :                 xProperties->setPropertyValue( "CharHeightAsian", uno::makeAny( fCharHeight ) );
     457           0 :                 xProperties->setPropertyValue( "CharHeightComplex", uno::makeAny( fCharHeight ) );
     458           0 :                 xProperties->setPropertyValue( "TextVerticalAdjust", uno::makeAny( drawing::TextVerticalAdjust_CENTER ) );
     459           0 :                 xProperties->setPropertyValue( "TextHorizontalAdjust", uno::makeAny( drawing::TextHorizontalAdjust_CENTER ) );
     460           0 :                 xProperties->setPropertyValue( "CharFontName", uno::makeAny( OUString("Albany") ) );
     461             : 
     462           0 :                 xTextShape->setPosition( rPosition );
     463             : 
     464           0 :                 m_aSelection.setSelection( xTextShape );
     465           0 :                 m_aSelection.applySelection( m_pDrawViewWrapper );
     466             : 
     467           0 :                 SdrObject* pObj = DrawViewWrapper::getSdrObject( xTextShape );
     468           0 :                 if ( pObj )
     469             :                 {
     470           0 :                     m_pDrawViewWrapper->BegUndo( SVX_RESSTR( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );
     471           0 :                     m_pDrawViewWrapper->AddUndo( new SdrUndoInsertObj( *pObj ) );
     472           0 :                     m_pDrawViewWrapper->EndUndo();
     473             : 
     474           0 :                     impl_switchDiagramPositioningToExcludingPositioning();
     475           0 :                 }
     476             :             }
     477           0 :             catch ( const uno::Exception& ex )
     478             :             {
     479             :                 ASSERT_EXCEPTION( ex );
     480             :             }
     481           0 :         }
     482             :     }
     483           0 : }
     484             : 
     485           0 : void ChartController::executeDispatch_Copy()
     486             : {
     487           0 :     if ( m_pDrawViewWrapper )
     488             :     {
     489           0 :         OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();
     490           0 :         if ( pOutlinerView )
     491             :         {
     492           0 :             pOutlinerView->Copy();
     493             :         }
     494             :         else
     495             :         {
     496           0 :             Reference< datatransfer::XTransferable > xTransferable;
     497             :             {
     498           0 :                 SolarMutexGuard aSolarGuard;
     499           0 :                 if ( m_pDrawModelWrapper )
     500             :                 {
     501           0 :                     SdrObject* pSelectedObj = 0;
     502           0 :                     ObjectIdentifier aSelOID( m_aSelection.getSelectedOID() );
     503           0 :                     if ( aSelOID.isAutoGeneratedObject() )
     504             :                     {
     505           0 :                         pSelectedObj = m_pDrawModelWrapper->getNamedSdrObject( aSelOID.getObjectCID() );
     506             :                     }
     507           0 :                     else if ( aSelOID.isAdditionalShape() )
     508             :                     {
     509           0 :                         pSelectedObj = DrawViewWrapper::getSdrObject( aSelOID.getAdditionalShape() );
     510             :                     }
     511           0 :                     if ( pSelectedObj )
     512             :                     {
     513           0 :                         xTransferable = Reference< datatransfer::XTransferable >( new ChartTransferable(
     514           0 :                                 &m_pDrawModelWrapper->getSdrModel(), pSelectedObj, aSelOID.isAdditionalShape() ) );
     515           0 :                     }
     516           0 :                 }
     517             :             }
     518           0 :             if ( xTransferable.is() )
     519             :             {
     520           0 :                 Reference< datatransfer::clipboard::XClipboard > xClipboard( TransferableHelper::GetSystemClipboard() );
     521           0 :                 if ( xClipboard.is() )
     522             :                 {
     523           0 :                     xClipboard->setContents( xTransferable, Reference< datatransfer::clipboard::XClipboardOwner >() );
     524           0 :                 }
     525           0 :             }
     526             :         }
     527             :     }
     528           0 : }
     529             : 
     530           0 : void ChartController::executeDispatch_Cut()
     531             : {
     532           0 :     executeDispatch_Copy();
     533           0 :     executeDispatch_Delete();
     534           0 : }
     535             : 
     536        1637 : bool ChartController::isObjectDeleteable( const uno::Any& rSelection )
     537             : {
     538        1637 :     ObjectIdentifier aSelOID( rSelection );
     539        1637 :     if ( aSelOID.isAutoGeneratedObject() )
     540             :     {
     541           0 :         OUString aSelObjCID( aSelOID.getObjectCID() );
     542           0 :         ObjectType aObjectType(ObjectIdentifier::getObjectType( aSelObjCID ));
     543             : 
     544           0 :         switch(aObjectType)
     545             :         {
     546             :         case OBJECTTYPE_TITLE:
     547             :         case OBJECTTYPE_LEGEND:
     548             :         case OBJECTTYPE_DATA_SERIES:
     549             :         case OBJECTTYPE_LEGEND_ENTRY:
     550             :         case OBJECTTYPE_DATA_CURVE_EQUATION:
     551             :         case OBJECTTYPE_DATA_CURVE:
     552             :         case OBJECTTYPE_DATA_AVERAGE_LINE:
     553             :         case OBJECTTYPE_DATA_ERRORS_X:
     554             :         case OBJECTTYPE_DATA_ERRORS_Y:
     555             :         case OBJECTTYPE_DATA_ERRORS_Z:
     556             :         case OBJECTTYPE_DATA_LABELS:
     557             :         case OBJECTTYPE_DATA_LABEL:
     558             :         case OBJECTTYPE_AXIS:
     559             :         case OBJECTTYPE_GRID:
     560             :         case OBJECTTYPE_SUBGRID:
     561           0 :             return true;
     562             :         default:
     563           0 :             break;
     564           0 :         }
     565             :     }
     566        1637 :     else if ( aSelOID.isAdditionalShape() )
     567             :     {
     568           0 :         return true;
     569             :     }
     570             : 
     571        1637 :     return false;
     572             : }
     573             : 
     574        1637 : bool ChartController::isShapeContext() const
     575             : {
     576        1637 :     if ( m_aSelection.isAdditionalShapeSelected() ||
     577        1603 :          ( m_pDrawViewWrapper && m_pDrawViewWrapper->AreObjectsMarked() &&
     578           0 :            ( m_pDrawViewWrapper->GetCurrentObjIdentifier() == OBJ_TEXT ) ) )
     579             :     {
     580           0 :         return true;
     581             :     }
     582             : 
     583        1637 :     return false;
     584             : }
     585             : 
     586           0 : void ChartController::impl_ClearSelection()
     587             : {
     588           0 :     if( m_aSelection.hasSelection())
     589             :     {
     590           0 :         m_aSelection.clearSelection();
     591           0 :         impl_notifySelectionChangeListeners();
     592             :     }
     593           0 : }
     594             : 
     595           0 : bool ChartController::executeDispatch_Delete()
     596             : {
     597           0 :     bool bReturn = false;
     598             : 
     599             :     // remove the selected object
     600           0 :     OUString aCID( m_aSelection.getSelectedCID() );
     601           0 :     if( !aCID.isEmpty() )
     602             :     {
     603           0 :         if( !isObjectDeleteable( uno::Any( aCID ) ) )
     604           0 :             return false;
     605             : 
     606             :         //remove chart object
     607           0 :         uno::Reference< chart2::XChartDocument > xChartDoc( getModel(), uno::UNO_QUERY );
     608           0 :         if( !xChartDoc.is() )
     609           0 :             return false;
     610             : 
     611           0 :         ObjectType aObjectType( ObjectIdentifier::getObjectType( aCID ));
     612           0 :         switch( aObjectType )
     613             :         {
     614             :             case OBJECTTYPE_TITLE:
     615             :             {
     616             :                 // using assignment for broken gcc 3.3
     617             :                 UndoGuard aUndoGuard = UndoGuard(
     618             :                     ActionDescriptionProvider::createDescription(
     619             :                         ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_TITLE )),
     620           0 :                     m_xUndoManager );
     621             :                 TitleHelper::removeTitle(
     622           0 :                     ObjectIdentifier::getTitleTypeForCID( aCID ), getModel() );
     623           0 :                 bReturn = true;
     624           0 :                 aUndoGuard.commit();
     625           0 :                 break;
     626             :             }
     627             :             case OBJECTTYPE_LEGEND:
     628             :             {
     629           0 :                 uno::Reference< chart2::XDiagram > xDiagram( xChartDoc->getFirstDiagram());
     630           0 :                 if( xDiagram.is())
     631             :                 {
     632           0 :                     uno::Reference< beans::XPropertySet > xLegendProp( xDiagram->getLegend(), uno::UNO_QUERY );
     633           0 :                     if( xLegendProp.is())
     634             :                     {
     635             :                         // using assignment for broken gcc 3.3
     636             :                         UndoGuard aUndoGuard = UndoGuard(
     637             :                             ActionDescriptionProvider::createDescription(
     638             :                                 ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_LEGEND )),
     639           0 :                             m_xUndoManager );
     640           0 :                         xLegendProp->setPropertyValue( "Show", uno::makeAny( false ));
     641           0 :                         bReturn = true;
     642           0 :                         aUndoGuard.commit();
     643           0 :                     }
     644             :                 }
     645           0 :                 break;
     646             :             }
     647             : 
     648             :             case OBJECTTYPE_DATA_SERIES:
     649           0 :                 bReturn = lcl_deleteDataSeries( aCID, getModel(), m_xUndoManager );
     650           0 :                 break;
     651             : 
     652             :             case OBJECTTYPE_LEGEND_ENTRY:
     653             :             {
     654             :                 ObjectType eParentObjectType = ObjectIdentifier::getObjectType(
     655           0 :                     ObjectIdentifier::getFullParentParticle( aCID ));
     656           0 :                 if( eParentObjectType == OBJECTTYPE_DATA_SERIES )
     657             :                 {
     658           0 :                     bReturn = lcl_deleteDataSeries( aCID, getModel(), m_xUndoManager );
     659             :                 }
     660           0 :                 else if( eParentObjectType == OBJECTTYPE_DATA_CURVE )
     661             :                 {
     662           0 :                     sal_Int32 nEndPos = aCID.lastIndexOf(':');
     663           0 :                     OUString aParentCID = aCID.copy(0, nEndPos);
     664             : 
     665           0 :                     bReturn = lcl_deleteDataCurve(aParentCID, getModel(), m_xUndoManager );
     666             :                 }
     667           0 :                 else if( eParentObjectType == OBJECTTYPE_DATA_AVERAGE_LINE )
     668             :                 {
     669           0 :                     executeDispatch_DeleteMeanValue();
     670           0 :                     bReturn = true;
     671             :                 }
     672           0 :                 break;
     673             :             }
     674             : 
     675             :             case OBJECTTYPE_DATA_AVERAGE_LINE:
     676             :             {
     677             :                 uno::Reference< chart2::XRegressionCurveContainer > xRegCurveCnt(
     678             :                     ObjectIdentifier::getObjectPropertySet(
     679           0 :                         ObjectIdentifier::getFullParentParticle( aCID ), getModel()), uno::UNO_QUERY );
     680           0 :                 if( xRegCurveCnt.is())
     681             :                 {
     682             :                     // using assignment for broken gcc 3.3
     683             :                     UndoGuard aUndoGuard = UndoGuard(
     684             :                         ActionDescriptionProvider::createDescription(
     685             :                             ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_AVERAGE_LINE )),
     686           0 :                         m_xUndoManager );
     687           0 :                     RegressionCurveHelper::removeMeanValueLine( xRegCurveCnt );
     688           0 :                     bReturn = true;
     689           0 :                     aUndoGuard.commit();
     690           0 :                 }
     691             :             }
     692           0 :             break;
     693             : 
     694             :             case OBJECTTYPE_DATA_CURVE:
     695             :             {
     696           0 :                 bReturn = lcl_deleteDataCurve( aCID, getModel(), m_xUndoManager );
     697             :             }
     698           0 :             break;
     699             : 
     700             :             case OBJECTTYPE_DATA_CURVE_EQUATION:
     701             :             {
     702             :                 uno::Reference< beans::XPropertySet > xEqProp(
     703           0 :                     ObjectIdentifier::getObjectPropertySet( aCID, getModel()));
     704             : 
     705           0 :                 if( xEqProp.is())
     706             :                 {
     707           0 :                     uno::Reference< frame::XModel > xModel( getModel() );
     708             :                     // using assignment for broken gcc 3.3
     709             :                     UndoGuard aUndoGuard = UndoGuard(
     710             :                         ActionDescriptionProvider::createDescription(
     711             :                             ActionDescriptionProvider::DELETE, SCH_RESSTR( STR_OBJECT_CURVE_EQUATION )),
     712           0 :                         m_xUndoManager );
     713             :                     {
     714           0 :                         ControllerLockGuardUNO aCtlLockGuard( xModel );
     715           0 :                         xEqProp->setPropertyValue( "ShowEquation", uno::makeAny( false ));
     716           0 :                         xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::makeAny( false ));
     717             :                     }
     718           0 :                     bReturn = true;
     719           0 :                     aUndoGuard.commit();
     720           0 :                 }
     721             :             }
     722           0 :             break;
     723             : 
     724             :             case OBJECTTYPE_DATA_ERRORS_X:
     725             :             case OBJECTTYPE_DATA_ERRORS_Y:
     726             :             case OBJECTTYPE_DATA_ERRORS_Z:
     727             :             {
     728             :                 uno::Reference< beans::XPropertySet > xErrorBarProp(
     729           0 :                     ObjectIdentifier::getObjectPropertySet( aCID, getModel() ));
     730           0 :                 if( xErrorBarProp.is())
     731             :                 {
     732             :                     sal_Int16 nId;
     733             : 
     734           0 :                     if ( aObjectType == OBJECTTYPE_DATA_ERRORS_X )
     735           0 :                         nId = STR_OBJECT_ERROR_BARS_X;
     736           0 :                     else if ( aObjectType == OBJECTTYPE_DATA_ERRORS_Y )
     737           0 :                         nId = STR_OBJECT_ERROR_BARS_Y;
     738             :                     else
     739           0 :                         nId = STR_OBJECT_ERROR_BARS_Z;
     740             : 
     741           0 :                     uno::Reference< frame::XModel > xModel( getModel() );
     742             :                     // using assignment for broken gcc 3.3
     743             :                     UndoGuard aUndoGuard = UndoGuard(
     744             :                         ActionDescriptionProvider::createDescription(
     745             :                             ActionDescriptionProvider::DELETE, SCH_RESSTR( nId )),
     746           0 :                         m_xUndoManager );
     747             :                     {
     748           0 :                         ControllerLockGuardUNO aCtlLockGuard( xModel );
     749           0 :                         xErrorBarProp->setPropertyValue(
     750             :                             "ErrorBarStyle",
     751           0 :                             uno::makeAny( ::com::sun::star::chart::ErrorBarStyle::NONE ));
     752             :                     }
     753           0 :                     bReturn = true;
     754           0 :                     aUndoGuard.commit();
     755             :                 }
     756           0 :                 break;
     757             :             }
     758             : 
     759             :             case OBJECTTYPE_DATA_LABELS:
     760             :             case OBJECTTYPE_DATA_LABEL:
     761             :             {
     762             :                 uno::Reference< beans::XPropertySet > xObjectProperties =
     763           0 :                     ObjectIdentifier::getObjectPropertySet( aCID, getModel() );
     764           0 :                 if( xObjectProperties.is() )
     765             :                 {
     766             :                     UndoGuard aUndoGuard = UndoGuard(
     767             :                         ActionDescriptionProvider::createDescription(
     768             :                         ActionDescriptionProvider::DELETE,
     769             :                             SCH_RESSTR( aObjectType == OBJECTTYPE_DATA_LABEL ? STR_OBJECT_LABEL : STR_OBJECT_DATALABELS )),
     770           0 :                                 m_xUndoManager );
     771           0 :                     chart2::DataPointLabel aLabel;
     772           0 :                     xObjectProperties->getPropertyValue(CHART_UNONAME_LABEL) >>= aLabel;
     773           0 :                     aLabel.ShowNumber = false;
     774           0 :                     aLabel.ShowNumberInPercent = false;
     775           0 :                     aLabel.ShowCategoryName = false;
     776           0 :                     aLabel.ShowLegendSymbol = false;
     777           0 :                     if( aObjectType == OBJECTTYPE_DATA_LABELS )
     778             :                     {
     779           0 :                         uno::Reference< chart2::XDataSeries > xSeries( ObjectIdentifier::getDataSeriesForCID( aCID, getModel() ));
     780           0 :                         ::chart::DataSeriesHelper::setPropertyAlsoToAllAttributedDataPoints( xSeries, CHART_UNONAME_LABEL, uno::makeAny(aLabel) );
     781             :                     }
     782             :                     else
     783           0 :                         xObjectProperties->setPropertyValue( CHART_UNONAME_LABEL, uno::makeAny(aLabel) );
     784           0 :                     bReturn = true;
     785           0 :                     aUndoGuard.commit();
     786             :                 }
     787           0 :                 break;
     788             :             }
     789             :             case OBJECTTYPE_AXIS:
     790             :             {
     791           0 :                 executeDispatch_DeleteAxis();
     792           0 :                 bReturn = true;
     793           0 :                 break;
     794             :             }
     795             :             case OBJECTTYPE_GRID:
     796             :             {
     797           0 :                 executeDispatch_DeleteMajorGrid();
     798           0 :                 bReturn = true;
     799           0 :                 break;
     800             :             }
     801             :             case OBJECTTYPE_SUBGRID:
     802             :             {
     803           0 :                 executeDispatch_DeleteMinorGrid();
     804           0 :                 bReturn = true;
     805           0 :                 break;
     806             :             }
     807             : 
     808             :             default:
     809             :             {
     810           0 :                 break;
     811             :             }
     812           0 :         }
     813             :     }
     814             :     else
     815             :     {
     816             :         //remove additional shape
     817           0 :         impl_ClearSelection();
     818             :         {
     819           0 :             SolarMutexGuard aSolarGuard;
     820           0 :             if ( m_pDrawViewWrapper )
     821             :             {
     822           0 :                 m_pDrawViewWrapper->DeleteMarked();
     823           0 :                 bReturn = true;
     824           0 :             }
     825             :         }
     826             :     }
     827           0 :     return bReturn;
     828             : }
     829             : 
     830           0 : void ChartController::executeDispatch_ToggleLegend()
     831             : {
     832           0 :     Reference< frame::XModel > xModel( getModel() );
     833             :     UndoGuard aUndoGuard = UndoGuard(
     834           0 :         SCH_RESSTR( STR_ACTION_TOGGLE_LEGEND ), m_xUndoManager );
     835           0 :     ChartModel& rModel = dynamic_cast<ChartModel&>(*xModel.get());
     836           0 :     Reference< beans::XPropertySet > xLegendProp( LegendHelper::getLegend(rModel), uno::UNO_QUERY );
     837           0 :     bool bChanged = false;
     838           0 :     if( xLegendProp.is())
     839             :     {
     840             :         try
     841             :         {
     842           0 :             bool bShow = false;
     843           0 :             if( xLegendProp->getPropertyValue( "Show") >>= bShow )
     844             :             {
     845           0 :                 xLegendProp->setPropertyValue( "Show", uno::makeAny( ! bShow ));
     846           0 :                 bChanged = true;
     847             :             }
     848             :         }
     849           0 :         catch( const uno::Exception & ex )
     850             :         {
     851             :             ASSERT_EXCEPTION( ex );
     852             :         }
     853             :     }
     854             :     else
     855             :     {
     856           0 :         xLegendProp.set( LegendHelper::getLegend(rModel, m_xCC, true), uno::UNO_QUERY );
     857           0 :         if( xLegendProp.is())
     858           0 :             bChanged = true;
     859             :     }
     860             : 
     861           0 :     if( bChanged )
     862           0 :         aUndoGuard.commit();
     863           0 : }
     864             : 
     865           0 : void ChartController::executeDispatch_ToggleGridHorizontal()
     866             : {
     867           0 :     Reference< frame::XModel > xModel( getModel() );
     868             :     UndoGuard aUndoGuard = UndoGuard(
     869           0 :         SCH_RESSTR( STR_ACTION_TOGGLE_GRID_HORZ ), m_xUndoManager );
     870           0 :     Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( getModel() ));
     871           0 :     if( xDiagram.is())
     872             :     {
     873           0 :         sal_Int32 nDimensionIndex = 1;
     874           0 :         sal_Int32 nCooSysIndex = 0;
     875             : 
     876           0 :         bool bHasMajorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true,  xDiagram );
     877           0 :         bool bHasMinorYGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
     878             : 
     879           0 :         if( bHasMajorYGrid )
     880             :         {
     881           0 :             if ( bHasMinorYGrid )
     882             :             {
     883           0 :                 AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true,  xDiagram );
     884           0 :                 AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
     885             :             }
     886             :             else
     887             :             {
     888           0 :                 AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram, m_xCC );
     889             :             }
     890             :         }
     891             :         else
     892             :         {
     893           0 :             AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram, m_xCC );
     894             :         }
     895           0 :         aUndoGuard.commit();
     896           0 :     }
     897           0 : }
     898             : 
     899           0 : void ChartController::executeDispatch_ToggleGridVertical()
     900             : {
     901           0 :     Reference< frame::XModel > xModel( getModel() );
     902             :     UndoGuard aUndoGuard = UndoGuard(
     903           0 :         SCH_RESSTR( STR_ACTION_TOGGLE_GRID_VERTICAL ), m_xUndoManager );
     904           0 :     Reference< chart2::XDiagram > xDiagram( ChartModelHelper::findDiagram( getModel() ));
     905           0 :     if( xDiagram.is())
     906             :     {
     907           0 :         sal_Int32 nDimensionIndex = 0;
     908           0 :         sal_Int32 nCooSysIndex = 0;
     909             : 
     910           0 :         bool bHasMajorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, true,  xDiagram );
     911           0 :         bool bHasMinorXGrid = AxisHelper::isGridShown( nDimensionIndex, nCooSysIndex, false, xDiagram );
     912           0 :         if( bHasMajorXGrid )
     913             :         {
     914           0 :             if (bHasMinorXGrid)
     915             :             {
     916           0 :                 AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, true,  xDiagram );
     917           0 :                 AxisHelper::hideGrid( nDimensionIndex, nCooSysIndex, false, xDiagram );
     918             :             }
     919             :             else
     920             :             {
     921           0 :                 AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, false, xDiagram, m_xCC );
     922             :             }
     923             :         }
     924             :         else
     925             :         {
     926           0 :             AxisHelper::showGrid( nDimensionIndex, nCooSysIndex, true, xDiagram, m_xCC );
     927             :         }
     928             : 
     929           0 :         aUndoGuard.commit();
     930           0 :     }
     931           0 : }
     932             : 
     933           0 : void ChartController::impl_ShapeControllerDispatch( const util::URL& rURL, const Sequence< beans::PropertyValue >& rArgs )
     934             : {
     935           0 :     Reference< frame::XDispatch > xDispatch( m_aDispatchContainer.getShapeController() );
     936           0 :     if ( xDispatch.is() )
     937             :     {
     938           0 :         xDispatch->dispatch( rURL, rArgs );
     939           0 :     }
     940           0 : }
     941             : 
     942           0 : void ChartController::impl_switchDiagramPositioningToExcludingPositioning()
     943             : {
     944             :     UndoGuard aUndoGuard( ActionDescriptionProvider::createDescription(
     945             :         ActionDescriptionProvider::POS_SIZE,
     946             :         ObjectNameProvider::getName( OBJECTTYPE_DIAGRAM)),
     947           0 :         m_xUndoManager );
     948           0 :     ChartModel& rModel = dynamic_cast<ChartModel&>(*m_aModel->getModel().get());
     949           0 :     if (DiagramHelper::switchDiagramPositioningToExcludingPositioning(rModel, true, true))
     950           0 :         aUndoGuard.commit();
     951           0 : }
     952             : 
     953         102 : } //  namespace chart
     954             : 
     955             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10