chart2/source/controller/main/ChartController_Tools.cxx

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