chart2/source/controller/main/ShapeController.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 "ShapeController.hxx"
  21 #include <ShapeController.h>
  22 #include <ChartController.hxx>
  23 #include <ChartWindow.hxx>
  24 #include <ViewElementListProvider.hxx>
  25 #include <dlg_ShapeFont.hxx>
  26 #include <dlg_ShapeParagraph.hxx>
  27 #include <chartview/DrawModelWrapper.hxx>
  28
  29 #include <com/sun/star/frame/CommandGroup.hpp>
  30 #include <com/sun/star/frame/XStorable.hpp>
  31
  32 #include <vcl/svapp.hxx>
  33 #include <editeng/formatbreakitem.hxx>
  34 #include <svx/dialogs.hrc>
  35 #include <svx/drawitem.hxx>
  36 #include <editeng/eeitem.hxx>
  37 #include <editeng/hyphenzoneitem.hxx>
  38 #include <editeng/orphitem.hxx>
  39 #include <editeng/spltitem.hxx>
  40 #include <svx/svxdlg.hxx>
  41 #include <editeng/widwitem.hxx>
  42 #include <tools/diagnose_ex.h>
  43
  44 #include <memory>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::frame;
  48
  49 using ::com::sun::star::uno::Reference;
  50 using ::com::sun::star::uno::Sequence;
  51
  52 namespace chart
  53 {
  54
  55 ShapeController::ShapeController( const Reference< uno::XComponentContext >& rxContext,
  56         ChartController* pController )
  57     :FeatureCommandDispatchBase( rxContext )
  58     ,m_pChartController( pController )
  59 {
  60 }
  61
  62 ShapeController::~ShapeController()
  63 {
  64 }
  65
  66 // WeakComponentImplHelperBase
  67 void ShapeController::disposing()
  68 {
  69 }
  70
  71 // XEventListener
  72 void ShapeController::disposing( const lang::EventObject& /* Source */ )
  73 {
  74 }
  75
  76 FeatureState ShapeController::getState( const OUString& rCommand )
  77 {
  78     FeatureState aReturn;
  79     aReturn.bEnabled = false;
  80     aReturn.aState <<= false;
  81
  82     bool bWritable = false;
  83     if ( m_pChartController )
  84     {
  85         Reference< frame::XStorable > xStorable( m_pChartController->getModel(), uno::UNO_QUERY );
  86         if ( xStorable.is() )
  87         {
  88             bWritable = !xStorable->isReadonly();
  89         }
  90     }
  91
  92     SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( rCommand );
  93     if ( aIter != m_aSupportedFeatures.end() )
  94     {
  95         sal_uInt16 nFeatureId = aIter->second.nFeatureId;
  96         switch ( nFeatureId )
  97         {
  98             case COMMAND_ID_FORMAT_LINE:
  99             case COMMAND_ID_FORMAT_AREA:
 100             case COMMAND_ID_TEXT_ATTRIBUTES:
 101             case COMMAND_ID_TRANSFORM_DIALOG:
 102             case COMMAND_ID_OBJECT_TITLE_DESCRIPTION:
 103             case COMMAND_ID_RENAME_OBJECT:
 104                 {
 105                     aReturn.bEnabled = bWritable;
 106                     aReturn.aState <<= false;
 107                 }
 108                 break;
 109             case COMMAND_ID_BRING_TO_FRONT:
 110             case COMMAND_ID_FORWARD:
 111                 {
 112                     aReturn.bEnabled = ( bWritable && isForwardPossible() );
 113                     aReturn.aState <<= false;
 114                 }
 115                 break;
 116             case COMMAND_ID_BACKWARD:
 117             case COMMAND_ID_SEND_TO_BACK:
 118                 {
 119
 120                     aReturn.bEnabled = ( bWritable && isBackwardPossible() );
 121                     aReturn.aState <<= false;
 122                 }
 123                 break;
 124             case COMMAND_ID_FONT_DIALOG:
 125             case COMMAND_ID_PARAGRAPH_DIALOG:
 126                 {
 127                     aReturn.bEnabled = bWritable;
 128                     aReturn.aState <<= false;
 129                 }
 130                 break;
 131             default:
 132                 {
 133                     aReturn.bEnabled = false;
 134                     aReturn.aState <<= false;
 135                 }
 136                 break;
 137         }
 138     }
 139
 140     return aReturn;
 141 }
 142
 143 void ShapeController::execute( const OUString& rCommand, const Sequence< beans::PropertyValue>& )
 144 {
 145     SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( rCommand );
 146     if ( aIter != m_aSupportedFeatures.end() )
 147     {
 148         sal_uInt16 nFeatureId = aIter->second.nFeatureId;
 149         switch ( nFeatureId )
 150         {
 151             case COMMAND_ID_FORMAT_LINE:
 152                 {
 153                     executeDispatch_FormatLine();
 154                 }
 155                 break;
 156             case COMMAND_ID_FORMAT_AREA:
 157                 {
 158                     executeDispatch_FormatArea();
 159                 }
 160                 break;
 161             case COMMAND_ID_TEXT_ATTRIBUTES:
 162                 {
 163                     executeDispatch_TextAttributes();
 164                 }
 165                 break;
 166             case COMMAND_ID_TRANSFORM_DIALOG:
 167                 {
 168                     executeDispatch_TransformDialog();
 169                 }
 170                 break;
 171             case COMMAND_ID_OBJECT_TITLE_DESCRIPTION:
 172                 {
 173                     executeDispatch_ObjectTitleDescription();
 174                 }
 175                 break;
 176             case COMMAND_ID_RENAME_OBJECT:
 177                 {
 178                     executeDispatch_RenameObject();
 179                 }
 180                 break;
 181             case COMMAND_ID_BRING_TO_FRONT:
 182             case COMMAND_ID_FORWARD:
 183             case COMMAND_ID_BACKWARD:
 184             case COMMAND_ID_SEND_TO_BACK:
 185                 {
 186                     executeDispatch_ChangeZOrder( nFeatureId );
 187                 }
 188                 break;
 189             case COMMAND_ID_FONT_DIALOG:
 190                 {
 191                     executeDispatch_FontDialog();
 192                 }
 193                 break;
 194             case COMMAND_ID_PARAGRAPH_DIALOG:
 195                 {
 196                     executeDispatch_ParagraphDialog();
 197                 }
 198                 break;
 199             default:
 200                 {
 201                 }
 202                 break;
 203         }
 204     }
 205 }
 206
 207 void ShapeController::describeSupportedFeatures()
 208 {
 209     implDescribeSupportedFeature( ".uno:FormatLine",                COMMAND_ID_FORMAT_LINE,                 CommandGroup::FORMAT );
 210     implDescribeSupportedFeature( ".uno:FormatArea",                COMMAND_ID_FORMAT_AREA,                 CommandGroup::FORMAT );
 211     implDescribeSupportedFeature( ".uno:TextAttributes",            COMMAND_ID_TEXT_ATTRIBUTES,             CommandGroup::FORMAT );
 212     implDescribeSupportedFeature( ".uno:TransformDialog",           COMMAND_ID_TRANSFORM_DIALOG,            CommandGroup::FORMAT );
 213     implDescribeSupportedFeature( ".uno:ObjectTitleDescription",    COMMAND_ID_OBJECT_TITLE_DESCRIPTION,    CommandGroup::FORMAT );
 214     implDescribeSupportedFeature( ".uno:RenameObject",              COMMAND_ID_RENAME_OBJECT,               CommandGroup::FORMAT );
 215     implDescribeSupportedFeature( ".uno:BringToFront",              COMMAND_ID_BRING_TO_FRONT,              CommandGroup::FORMAT );
 216     implDescribeSupportedFeature( ".uno:Forward",                   COMMAND_ID_FORWARD,                     CommandGroup::FORMAT );
 217     implDescribeSupportedFeature( ".uno:Backward",                  COMMAND_ID_BACKWARD,                    CommandGroup::FORMAT );
 218     implDescribeSupportedFeature( ".uno:SendToBack",                COMMAND_ID_SEND_TO_BACK,                CommandGroup::FORMAT );
 219     implDescribeSupportedFeature( ".uno:FontDialog",                COMMAND_ID_FONT_DIALOG,                 CommandGroup::EDIT );
 220     implDescribeSupportedFeature( ".uno:ParagraphDialog",           COMMAND_ID_PARAGRAPH_DIALOG,            CommandGroup::EDIT );
 221 }
 222
 223 IMPL_LINK( ShapeController, CheckNameHdl, AbstractSvxObjectNameDialog&, rDialog, bool )
 224 {
 225     OUString aName;
 226     rDialog.GetName( aName );
 227
 228     if ( !aName.isEmpty() )
 229     {
 230         DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
 231         if ( pDrawViewWrapper && pDrawViewWrapper->getNamedSdrObject( aName ) )
 232         {
 233             return false;
 234         }
 235     }
 236     return true;
 237 }
 238
 239 void ShapeController::executeDispatch_FormatLine()
 240 {
 241     SolarMutexGuard aGuard;
 242     if ( m_pChartController )
 243     {
 244         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 245         DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
 246         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 247         if ( pChartWindow && pDrawModelWrapper && pDrawViewWrapper )
 248         {
 249             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 250             SfxItemSet aAttr( pDrawViewWrapper->GetDefaultAttr() );
 251             bool bHasMarked = pDrawViewWrapper->AreObjectsMarked();
 252             if ( bHasMarked )
 253             {
 254                 pDrawViewWrapper->MergeAttrFromMarked( aAttr, false );
 255             }
 256             SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 257             if ( pFact )
 258             {
 259                 ScopedVclPtr< SfxAbstractTabDialog > pDlg(
 260                     pFact->CreateSvxLineTabDialog( pChartWindow, &aAttr, &pDrawModelWrapper->getSdrModel(),
 261                         pSelectedObj, bHasMarked ) );
 262                 if ( pDlg->Execute() == RET_OK )
 263                 {
 264                     const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 265                     if ( bHasMarked )
 266                     {
 267                         pDrawViewWrapper->SetAttrToMarked( *pOutAttr, false );
 268                     }
 269                     else
 270                     {
 271                         pDrawViewWrapper->SetDefaultAttr( *pOutAttr, false );
 272                     }
 273                 }
 274             }
 275         }
 276     }
 277 }
 278
 279 void ShapeController::executeDispatch_FormatArea()
 280 {
 281     SolarMutexGuard aGuard;
 282     if ( m_pChartController )
 283     {
 284         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 285         DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
 286         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 287         if ( pChartWindow && pDrawModelWrapper && pDrawViewWrapper )
 288         {
 289             SfxItemSet aAttr( pDrawViewWrapper->GetDefaultAttr() );
 290             bool bHasMarked = pDrawViewWrapper->AreObjectsMarked();
 291             if ( bHasMarked )
 292             {
 293                 pDrawViewWrapper->MergeAttrFromMarked( aAttr, false );
 294             }
 295             SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 296             if ( pFact )
 297             {
 298                 ScopedVclPtr< AbstractSvxAreaTabDialog > pDlg(
 299                     pFact->CreateSvxAreaTabDialog( pChartWindow, &aAttr, &pDrawModelWrapper->getSdrModel(), true ) );
 300                 if ( pDlg.get() )
 301                 {
 302                     if ( pDlg->Execute() == RET_OK )
 303                     {
 304                         const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 305                         if ( bHasMarked )
 306                         {
 307                             pDrawViewWrapper->SetAttrToMarked( *pOutAttr, false );
 308                         }
 309                         else
 310                         {
 311                             pDrawViewWrapper->SetDefaultAttr( *pOutAttr, false );
 312                         }
 313                     }
 314                 }
 315             }
 316         }
 317     }
 318 }
 319
 320 void ShapeController::executeDispatch_TextAttributes()
 321 {
 322     SolarMutexGuard aGuard;
 323     if ( m_pChartController )
 324     {
 325         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 326         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 327         if ( pChartWindow && pDrawViewWrapper )
 328         {
 329             SfxItemSet aAttr( pDrawViewWrapper->GetDefaultAttr() );
 330             bool bHasMarked = pDrawViewWrapper->AreObjectsMarked();
 331             if ( bHasMarked )
 332             {
 333                 pDrawViewWrapper->MergeAttrFromMarked( aAttr, false );
 334             }
 335             SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 336             if ( pFact )
 337             {
 338                 ScopedVclPtr< SfxAbstractTabDialog > pDlg(
 339                     pFact->CreateTextTabDialog( pChartWindow ? pChartWindow->GetFrameWeld() : nullptr, &aAttr, pDrawViewWrapper ) );
 340                 if ( pDlg.get() && ( pDlg->Execute() == RET_OK ) )
 341                 {
 342                     const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 343                     if ( bHasMarked )
 344                     {
 345                         pDrawViewWrapper->SetAttributes( *pOutAttr );
 346                     }
 347                     else
 348                     {
 349                         pDrawViewWrapper->SetDefaultAttr( *pOutAttr, false );
 350                     }
 351                 }
 352             }
 353         }
 354     }
 355 }
 356
 357 void ShapeController::executeDispatch_TransformDialog()
 358 {
 359     SolarMutexGuard aGuard;
 360     if ( m_pChartController )
 361     {
 362         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 363         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 364         if ( pChartWindow && pDrawViewWrapper )
 365         {
 366             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 367             if ( pSelectedObj && pSelectedObj->GetObjIdentifier() == OBJ_CAPTION )
 368             {
 369                 // item set for caption
 370                 SfxItemSet aAttr( pDrawViewWrapper->GetModel()->GetItemPool() );
 371                 pDrawViewWrapper->GetAttributes( aAttr );
 372                 // item set for position and size
 373                 SfxItemSet aGeoAttr( pDrawViewWrapper->GetGeoAttrFromMarked() );
 374                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 375                 if ( pFact )
 376                 {
 377                     ScopedVclPtr< SfxAbstractTabDialog > pDlg(
 378                         pFact->CreateCaptionDialog( pChartWindow, pDrawViewWrapper ) );
 379                     if ( pDlg.get() )
 380                     {
 381                         const sal_uInt16* pRange = pDlg->GetInputRanges( *aAttr.GetPool() );
 382                         SfxItemSet aCombAttr( *aAttr.GetPool(), pRange );
 383                         aCombAttr.Put( aAttr );
 384                         aCombAttr.Put( aGeoAttr );
 385                         pDlg->SetInputSet( &aCombAttr );
 386                         if ( pDlg->Execute() == RET_OK )
 387                         {
 388                             const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 389                             pDrawViewWrapper->SetAttributes( *pOutAttr );
 390                             pDrawViewWrapper->SetGeoAttrToMarked( *pOutAttr );
 391                         }
 392                     }
 393                 }
 394             }
 395             else
 396             {
 397                 SfxItemSet aGeoAttr( pDrawViewWrapper->GetGeoAttrFromMarked() );
 398                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 399                 if ( pFact )
 400                 {
 401                     ScopedVclPtr< SfxAbstractTabDialog > pDlg(
 402                         pFact->CreateSvxTransformTabDialog(pChartWindow ? pChartWindow->GetFrameWeld() : nullptr, &aGeoAttr, pDrawViewWrapper));
 403                     if ( pDlg.get() && ( pDlg->Execute() == RET_OK ) )
 404                     {
 405                         const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 406                         pDrawViewWrapper->SetGeoAttrToMarked( *pOutAttr );
 407                     }
 408                 }
 409             }
 410         }
 411     }
 412 }
 413
 414 void ShapeController::executeDispatch_ObjectTitleDescription()
 415 {
 416     SolarMutexGuard aGuard;
 417     if ( m_pChartController )
 418     {
 419         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 420         if ( pDrawViewWrapper && pDrawViewWrapper->GetMarkedObjectCount() == 1 )
 421         {
 422             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 423             if ( pSelectedObj )
 424             {
 425                 OUString aTitle( pSelectedObj->GetTitle() );
 426                 OUString aDescription( pSelectedObj->GetDescription() );
 427                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 428                 if ( pFact )
 429                 {
 430                     VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 431                     ScopedVclPtr< AbstractSvxObjectTitleDescDialog > pDlg(
 432                         pFact->CreateSvxObjectTitleDescDialog(pChartWindow ? pChartWindow->GetFrameWeld() : nullptr, aTitle, aDescription ) );
 433                     if ( pDlg.get() && ( pDlg->Execute() == RET_OK ) )
 434                     {
 435                         pDlg->GetTitle( aTitle );
 436                         pDlg->GetDescription( aDescription );
 437                         pSelectedObj->SetTitle( aTitle );
 438                         pSelectedObj->SetDescription( aDescription );
 439                     }
 440                 }
 441             }
 442         }
 443     }
 444 }
 445
 446 void ShapeController::executeDispatch_RenameObject()
 447 {
 448     SolarMutexGuard aGuard;
 449     if ( m_pChartController )
 450     {
 451         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 452         if ( pDrawViewWrapper && pDrawViewWrapper->GetMarkedObjectCount() == 1 )
 453         {
 454             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 455             if ( pSelectedObj )
 456             {
 457                 OUString aName = pSelectedObj->GetName();
 458                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 459                 if ( pFact )
 460                 {
 461                     VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 462                     ScopedVclPtr< AbstractSvxObjectNameDialog > pDlg(
 463                         pFact->CreateSvxObjectNameDialog(pChartWindow ? pChartWindow->GetFrameWeld() : nullptr, aName));
 464                     pDlg->SetCheckNameHdl( LINK( this, ShapeController, CheckNameHdl ) );
 465                     if ( pDlg.get() && ( pDlg->Execute() == RET_OK ) )
 466                     {
 467                         pDlg->GetName(aName);
 468                         if (pSelectedObj->GetName() == aName)
 469                         {
 470                             pSelectedObj->SetName( aName );
 471                         }
 472                     }
 473                 }
 474             }
 475         }
 476     }
 477 }
 478
 479 void ShapeController::executeDispatch_ChangeZOrder( sal_uInt16 nId )
 480 {
 481     SolarMutexGuard aGuard;
 482     DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
 483     if ( pDrawViewWrapper )
 484     {
 485         switch ( nId )
 486         {
 487             case COMMAND_ID_BRING_TO_FRONT:
 488                 {
 489                     if ( isForwardPossible() )
 490                     {
 491                         pDrawViewWrapper->PutMarkedToTop();
 492                     }
 493                 }
 494                 break;
 495             case COMMAND_ID_FORWARD:
 496                 {
 497                     if ( isForwardPossible() )
 498                     {
 499                         pDrawViewWrapper->MovMarkedToTop();
 500                     }
 501                 }
 502                 break;
 503             case COMMAND_ID_BACKWARD:
 504                 {
 505                     if ( isBackwardPossible() )
 506                     {
 507                         pDrawViewWrapper->MovMarkedToBtm();
 508                     }
 509                 }
 510                 break;
 511             case COMMAND_ID_SEND_TO_BACK:
 512                 {
 513                     if ( isBackwardPossible() )
 514                     {
 515                         SdrObject* pFirstObj = getFirstAdditionalShape();
 516                         pDrawViewWrapper->PutMarkedBehindObj( pFirstObj );
 517                     }
 518                 }
 519                 break;
 520             default:
 521                 {
 522                 }
 523                 break;
 524         }
 525     }
 526 }
 527
 528 void ShapeController::executeDispatch_FontDialog()
 529 {
 530     SolarMutexGuard aGuard;
 531     if ( m_pChartController )
 532     {
 533         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 534         DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
 535         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 536         if ( pChartWindow && pDrawModelWrapper && pDrawViewWrapper )
 537         {
 538             SfxItemSet aAttr( pDrawViewWrapper->GetModel()->GetItemPool() );
 539             pDrawViewWrapper->GetAttributes( aAttr );
 540             ViewElementListProvider aViewElementListProvider( pDrawModelWrapper );
 541             ScopedVclPtrInstance< ShapeFontDialog > pDlg( pChartWindow, &aAttr, &aViewElementListProvider );
 542             if ( pDlg->Execute() == RET_OK )
 543             {
 544                 const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 545                 pDrawViewWrapper->SetAttributes( *pOutAttr );
 546             }
 547         }
 548     }
 549 }
 550
 551 void ShapeController::executeDispatch_ParagraphDialog()
 552 {
 553     SolarMutexGuard aGuard;
 554     if ( m_pChartController )
 555     {
 556         VclPtr<ChartWindow> pChartWindow( m_pChartController->GetChartWindow() );
 557         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 558         if ( pChartWindow && pDrawViewWrapper )
 559         {
 560             SfxItemPool& rPool = pDrawViewWrapper->GetModel()->GetItemPool();
 561             SfxItemSet aAttr( rPool );
 562             pDrawViewWrapper->GetAttributes( aAttr );
 563
 564             SfxItemSet aNewAttr(
 565                 rPool,
 566                 svl::Items<
 567                     EE_ITEMS_START, EE_ITEMS_END,
 568                     SID_ATTR_PARA_PAGEBREAK, SID_ATTR_PARA_WIDOWS>{});
 569             aNewAttr.Put( aAttr );
 570             aNewAttr.Put( SvxHyphenZoneItem( false, SID_ATTR_PARA_HYPHENZONE ) );
 571             aNewAttr.Put( SvxFormatBreakItem( SvxBreak::NONE, SID_ATTR_PARA_PAGEBREAK ) );
 572             aNewAttr.Put( SvxFormatSplitItem( true, SID_ATTR_PARA_SPLIT)  );
 573             aNewAttr.Put( SvxWidowsItem( 0, SID_ATTR_PARA_WIDOWS) );
 574             aNewAttr.Put( SvxOrphansItem( 0, SID_ATTR_PARA_ORPHANS) );
 575
 576             ScopedVclPtrInstance< ShapeParagraphDialog > pDlg( pChartWindow, &aNewAttr );
 577             if ( pDlg->Execute() == RET_OK )
 578             {
 579                 const SfxItemSet* pOutAttr = pDlg->GetOutputItemSet();
 580                 pDrawViewWrapper->SetAttributes( *pOutAttr );
 581             }
 582         }
 583     }
 584 }
 585
 586 SdrObject* ShapeController::getFirstAdditionalShape()
 587 {
 588     SdrObject* pFirstObj = nullptr;
 589
 590     try
 591     {
 592         DrawModelWrapper* pDrawModelWrapper = ( m_pChartController ? m_pChartController->GetDrawModelWrapper() : nullptr );
 593         if ( pDrawModelWrapper )
 594         {
 595             Reference< drawing::XShape > xFirstShape;
 596             Reference< drawing::XDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );
 597             Reference< drawing::XShapes > xDrawPageShapes( xDrawPage, uno::UNO_QUERY_THROW );
 598             Reference< drawing::XShapes > xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
 599             sal_Int32 nCount = xDrawPageShapes->getCount();
 600             for ( sal_Int32 i = 0; i < nCount; ++i )
 601             {
 602                 Reference< drawing::XShape > xShape;
 603                 if ( xDrawPageShapes->getByIndex( i ) >>= xShape )
 604                 {
 605                     if ( xShape.is() && xShape != xChartRoot )
 606                     {
 607                         xFirstShape = xShape;
 608                         break;
 609                     }
 610                 }
 611             }
 612             if ( xFirstShape.is() )
 613             {
 614                 pFirstObj = DrawViewWrapper::getSdrObject( xFirstShape );
 615             }
 616         }
 617     }
 618     catch ( const uno::Exception& )
 619     {
 620         DBG_UNHANDLED_EXCEPTION("chart2");
 621     }
 622
 623     return pFirstObj;
 624 }
 625
 626 SdrObject* ShapeController::getLastAdditionalShape()
 627 {
 628     SdrObject* pLastObj = nullptr;
 629
 630     try
 631     {
 632         DrawModelWrapper* pDrawModelWrapper = ( m_pChartController ? m_pChartController->GetDrawModelWrapper() : nullptr );
 633         if ( pDrawModelWrapper )
 634         {
 635             Reference< drawing::XShape > xLastShape;
 636             Reference< drawing::XDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );
 637             Reference< drawing::XShapes > xDrawPageShapes( xDrawPage, uno::UNO_QUERY_THROW );
 638             Reference< drawing::XShapes > xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
 639             sal_Int32 nCount = xDrawPageShapes->getCount();
 640             for ( sal_Int32 i = nCount - 1; i >= 0; --i )
 641             {
 642                 Reference< drawing::XShape > xShape;
 643                 if ( xDrawPageShapes->getByIndex( i ) >>= xShape )
 644                 {
 645                     if ( xShape.is() && xShape != xChartRoot )
 646                     {
 647                         xLastShape = xShape;
 648                         break;
 649                     }
 650                 }
 651             }
 652             if ( xLastShape.is() )
 653             {
 654                 pLastObj = DrawViewWrapper::getSdrObject( xLastShape );
 655             }
 656         }
 657     }
 658     catch ( const uno::Exception& )
 659     {
 660         DBG_UNHANDLED_EXCEPTION("chart2");
 661     }
 662
 663     return pLastObj;
 664 }
 665
 666 bool ShapeController::isBackwardPossible()
 667 {
 668     if ( m_pChartController && m_pChartController->isAdditionalShapeSelected() )
 669     {
 670         SolarMutexGuard aGuard;
 671         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 672         if ( pDrawViewWrapper )
 673         {
 674             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 675             SdrObject* pFirstObj = getFirstAdditionalShape();
 676             if ( pSelectedObj && pFirstObj && pSelectedObj != pFirstObj )
 677             {
 678                 return true;
 679             }
 680         }
 681     }
 682     return false;
 683 }
 684
 685 bool ShapeController::isForwardPossible()
 686 {
 687     if ( m_pChartController && m_pChartController->isAdditionalShapeSelected() )
 688     {
 689         SolarMutexGuard aGuard;
 690         DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 691         if ( pDrawViewWrapper )
 692         {
 693             SdrObject* pSelectedObj = pDrawViewWrapper->getSelectedObject();
 694             SdrObject* pLastObj = getLastAdditionalShape();
 695             if ( pSelectedObj && pLastObj && pSelectedObj != pLastObj )
 696             {
 697                 return true;
 698             }
 699         }
 700     }
 701     return false;
 702 }
 703
 704 } //  namespace chart
 705
 706 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */