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