chart2/source/controller/main/ChartController_Tools.cxx

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