chart2/source/controller/main/DrawCommandDispatch.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 "DrawCommandDispatch.hxx"
  21 #include <ChartController.hxx>
  22 #include <DrawViewWrapper.hxx>
  23 #include <chartview/DrawModelWrapper.hxx>
  24
  25 #include <com/sun/star/frame/CommandGroup.hpp>
  26 #include <o3tl/unsafe_downcast.hxx>
  27 #include <o3tl/string_view.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <editeng/eeitem.hxx>
  30 #include <svx/strings.hrc>
  31 #include <svx/dialmgr.hxx>
  32 #include <svx/fmmodel.hxx>
  33 #include <svx/gallery.hxx>
  34 #include <svx/svdoashp.hxx>
  35 #include <svx/svdocapt.hxx>
  36 #include <svx/svdopath.hxx>
  37 #include <svx/svdpage.hxx>
  38 #include <svx/unoapi.hxx>
  39 #include <svx/xlnedit.hxx>
  40 #include <svx/xlnedwit.hxx>
  41 #include <svx/xlnwtit.hxx>
  42 #include <svx/xtable.hxx>
  43 #include <svx/sdtagitm.hxx>
  44 #include <basegfx/polygon/b2dpolygon.hxx>
  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
  53 namespace chart
  54 {
  55
  56 DrawCommandDispatch::DrawCommandDispatch( const Reference< uno::XComponentContext >& rxContext,
  57     ChartController* pController )
  58     :FeatureCommandDispatchBase( rxContext )
  59     ,m_pChartController( pController )
  60 {
  61 }
  62
  63 DrawCommandDispatch::~DrawCommandDispatch()
  64 {
  65 }
  66
  67 bool DrawCommandDispatch::isFeatureSupported( const OUString& rCommandURL )
  68 {
  69     ChartCommandID nFeatureId = ChartCommandID::NONE;
  70     OUString aBaseCommand;
  71     OUString aCustomShapeType;
  72     return parseCommandURL( rCommandURL, &nFeatureId, &aBaseCommand, &aCustomShapeType );
  73 }
  74
  75 static ::basegfx::B2DPolyPolygon getPolygon(TranslateId pResId, const SdrModel& rModel)
  76 {
  77     ::basegfx::B2DPolyPolygon aReturn;
  78     XLineEndListRef pLineEndList = rModel.GetLineEndList();
  79     if ( pLineEndList.is() )
  80     {
  81         OUString aName(SvxResId(pResId));
  82         tools::Long nCount = pLineEndList->Count();
  83         for ( tools::Long nIndex = 0; nIndex < nCount; ++nIndex )
  84         {
  85             const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nIndex);
  86             if ( pEntry->GetName() == aName )
  87             {
  88                 aReturn = pEntry->GetLineEnd();
  89                 break;
  90             }
  91         }
  92     }
  93     return aReturn;
  94 }
  95
  96 void DrawCommandDispatch::setAttributes( SdrObject* pObj )
  97 {
  98     if ( !m_pChartController )
  99         return;
 100
 101     DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
 102     DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 103     if ( !(pDrawModelWrapper && pDrawViewWrapper && pDrawViewWrapper->GetCurrentObjIdentifier() == SdrObjKind::CustomShape) )
 104         return;
 105
 106     bool bAttributesAppliedFromGallery = false;
 107     if ( GalleryExplorer::GetSdrObjCount( GALLERY_THEME_POWERPOINT ) )
 108     {
 109         std::vector< OUString > aObjList;
 110         if ( GalleryExplorer::FillObjListTitle( GALLERY_THEME_POWERPOINT, aObjList ) )
 111         {
 112             for ( size_t i = 0; i < aObjList.size(); ++i )
 113             {
 114                 if ( aObjList[ i ].equalsIgnoreAsciiCase( m_aCustomShapeType ) )
 115                 {
 116                     FmFormModel aModel;
 117
 118                     if ( GalleryExplorer::GetSdrObj( GALLERY_THEME_POWERPOINT, i, &aModel ) )
 119                     {
 120                         const SdrObject* pSourceObj = aModel.GetPage( 0 )->GetObj( 0 );
 121                         if ( pSourceObj )
 122                         {
 123                             const SfxItemSet& rSource = pSourceObj->GetMergedItemSet();
 124                             SfxItemSetFixed<
 125                                     // Ranges from SdrAttrObj:
 126                                     SDRATTR_START, SDRATTR_SHADOW_LAST,
 127                                     SDRATTR_MISC_FIRST,
 128                                         SDRATTR_MISC_LAST,
 129                                     SDRATTR_TEXTDIRECTION,
 130                                         SDRATTR_TEXTDIRECTION,
 131                                     // Graphic attributes, 3D
 132                                     // properties, CustomShape
 133                                     // properties:
 134                                     SDRATTR_GRAF_FIRST,
 135                                         SDRATTR_CUSTOMSHAPE_LAST,
 136                                     // Range from SdrTextObj:
 137                                     EE_ITEMS_START, EE_ITEMS_END>
 138                                 aDest(pObj->getSdrModelFromSdrObject().GetItemPool());
 139                             aDest.Set( rSource );
 140                             pObj->SetMergedItemSet( aDest );
 141                             Degree100 nAngle = pSourceObj->GetRotateAngle();
 142                             if ( nAngle )
 143                                 pObj->NbcRotate( pObj->GetSnapRect().Center(), nAngle );
 144                             bAttributesAppliedFromGallery = true;
 145                         }
 146                     }
 147                     break;
 148                 }
 149             }
 150         }
 151     }
 152     if ( !bAttributesAppliedFromGallery )
 153     {
 154         pObj->SetMergedItem( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) );
 155         pObj->SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_BLOCK ) );
 156         pObj->SetMergedItem( makeSdrTextAutoGrowHeightItem( false ) );
 157
 158         o3tl::unsafe_downcast< SdrObjCustomShape* >( pObj )->MergeDefaultAttributes( &m_aCustomShapeType );
 159     }
 160 }
 161
 162 void DrawCommandDispatch::setLineEnds( SfxItemSet& rAttr )
 163 {
 164     if ( !(m_nFeatureId == ChartCommandID::DrawLineArrowEnd && m_pChartController) )
 165         return;
 166
 167     DrawModelWrapper* pDrawModelWrapper = m_pChartController->GetDrawModelWrapper();
 168     DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 169     if ( !(pDrawModelWrapper && pDrawViewWrapper) )
 170         return;
 171
 172     ::basegfx::B2DPolyPolygon aArrow( getPolygon( RID_SVXSTR_ARROW, pDrawModelWrapper->getSdrModel() ) );
 173     if ( !aArrow.count() )
 174     {
 175         ::basegfx::B2DPolygon aNewArrow;
 176         aNewArrow.append( ::basegfx::B2DPoint( 10.0, 0.0 ) );
 177         aNewArrow.append( ::basegfx::B2DPoint( 0.0, 30.0) );
 178         aNewArrow.append( ::basegfx::B2DPoint( 20.0, 30.0 ) );
 179         aNewArrow.setClosed( true );
 180         aArrow.append( aNewArrow );
 181     }
 182
 183     SfxItemSet aSet(pDrawViewWrapper->GetModel().GetItemPool());
 184     pDrawViewWrapper->GetAttributes( aSet );
 185
 186     tools::Long nWidth = 300; // (1/100th mm)
 187     if ( aSet.GetItemState( XATTR_LINEWIDTH ) != SfxItemState::INVALID )
 188     {
 189         tools::Long nValue = aSet.Get( XATTR_LINEWIDTH ).GetValue();
 190         if ( nValue > 0 )
 191         {
 192             nWidth = nValue * 3;
 193         }
 194     }
 195
 196     rAttr.Put( XLineEndItem( SvxResId( RID_SVXSTR_ARROW ), std::move(aArrow) ) );
 197     rAttr.Put( XLineEndWidthItem( nWidth ) );
 198 }
 199
 200 // WeakComponentImplHelperBase
 201 void DrawCommandDispatch::disposing(std::unique_lock<std::mutex>& /*rGuard*/)
 202 {
 203 }
 204
 205 // XEventListener
 206 void DrawCommandDispatch::disposing( const lang::EventObject& /* Source */ )
 207 {
 208 }
 209
 210 FeatureState DrawCommandDispatch::getState( const OUString& rCommand )
 211 {
 212     FeatureState aReturn;
 213     aReturn.bEnabled = false;
 214     aReturn.aState <<= false;
 215
 216     ChartCommandID nFeatureId = ChartCommandID::NONE;
 217     OUString aBaseCommand;
 218     OUString aCustomShapeType;
 219     if ( parseCommandURL( rCommand, &nFeatureId, &aBaseCommand, &aCustomShapeType ) )
 220     {
 221         switch ( nFeatureId )
 222         {
 223             case ChartCommandID::DrawObjectSelect:
 224             case ChartCommandID::DrawLine:
 225             case ChartCommandID::DrawLineArrowEnd:
 226             case ChartCommandID::DrawRect:
 227             case ChartCommandID::DrawEllipse:
 228             case ChartCommandID::DrawFreelineNoFill:
 229             case ChartCommandID::DrawText:
 230             case ChartCommandID::DrawCaption:
 231             case ChartCommandID::DrawToolboxCsBasic:
 232             case ChartCommandID::DrawToolboxCsSymbol:
 233             case ChartCommandID::DrawToolboxCsArrow:
 234             case ChartCommandID::DrawToolboxCsFlowchart:
 235             case ChartCommandID::DrawToolboxCsCallout:
 236             case ChartCommandID::DrawToolboxCsStar:
 237                 {
 238                     aReturn.bEnabled = true;
 239                     aReturn.aState <<= false;
 240                 }
 241                 break;
 242             default:
 243                 {
 244                     aReturn.bEnabled = false;
 245                     aReturn.aState <<= false;
 246                 }
 247                 break;
 248         }
 249     }
 250
 251     return aReturn;
 252 }
 253
 254 void DrawCommandDispatch::execute( const OUString& rCommand, const Sequence< beans::PropertyValue>& rArgs )
 255 {
 256     ChartDrawMode eDrawMode = CHARTDRAW_SELECT;
 257     SdrObjKind eKind = SdrObjKind::NONE;
 258
 259     ChartCommandID nFeatureId = ChartCommandID::NONE;
 260     OUString aBaseCommand;
 261     OUString aCustomShapeType;
 262     if ( !parseCommandURL( rCommand, &nFeatureId, &aBaseCommand, &aCustomShapeType ) )
 263         return;
 264
 265     bool bCreate = false;
 266     m_nFeatureId = nFeatureId;
 267     m_aCustomShapeType = aCustomShapeType;
 268
 269     switch ( nFeatureId )
 270     {
 271         case ChartCommandID::DrawObjectSelect:
 272             {
 273                 eDrawMode = CHARTDRAW_SELECT;
 274                 eKind = SdrObjKind::NONE;
 275             }
 276             break;
 277         case ChartCommandID::DrawLine:
 278         case ChartCommandID::DrawLineArrowEnd:
 279             {
 280                 eDrawMode = CHARTDRAW_INSERT;
 281                 eKind = SdrObjKind::Line;
 282             }
 283             break;
 284         case ChartCommandID::DrawRect:
 285             {
 286                 eDrawMode = CHARTDRAW_INSERT;
 287                 eKind = SdrObjKind::Rectangle;
 288             }
 289             break;
 290         case ChartCommandID::DrawEllipse:
 291             {
 292                 eDrawMode = CHARTDRAW_INSERT;
 293                 eKind = SdrObjKind::CircleOrEllipse;
 294             }
 295             break;
 296         case ChartCommandID::DrawFreelineNoFill:
 297             {
 298                 eDrawMode = CHARTDRAW_INSERT;
 299                 eKind = SdrObjKind::FreehandLine;
 300             }
 301             break;
 302         case ChartCommandID::DrawText:
 303             {
 304                 eDrawMode = CHARTDRAW_INSERT;
 305                 eKind = SdrObjKind::Text;
 306                 bCreate = true;
 307             }
 308             break;
 309         case ChartCommandID::DrawCaption:
 310             {
 311                 eDrawMode = CHARTDRAW_INSERT;
 312                 eKind = SdrObjKind::Caption;
 313             }
 314             break;
 315         case ChartCommandID::DrawToolboxCsBasic:
 316         case ChartCommandID::DrawToolboxCsSymbol:
 317         case ChartCommandID::DrawToolboxCsArrow:
 318         case ChartCommandID::DrawToolboxCsFlowchart:
 319         case ChartCommandID::DrawToolboxCsCallout:
 320         case ChartCommandID::DrawToolboxCsStar:
 321             {
 322                 eDrawMode = CHARTDRAW_INSERT;
 323                 eKind = SdrObjKind::CustomShape;
 324             }
 325             break;
 326         default:
 327             {
 328                 eDrawMode = CHARTDRAW_SELECT;
 329                 eKind = SdrObjKind::NONE;
 330             }
 331             break;
 332     }
 333
 334     if ( !m_pChartController )
 335         return;
 336
 337     DrawViewWrapper* pDrawViewWrapper = m_pChartController->GetDrawViewWrapper();
 338     if ( !pDrawViewWrapper )
 339         return;
 340
 341     SolarMutexGuard aGuard;
 342     m_pChartController->setDrawMode( eDrawMode );
 343     setInsertObj(eKind);
 344     if ( bCreate )
 345     {
 346         pDrawViewWrapper->SetCreateMode();
 347     }
 348
 349     const beans::PropertyValue* pKeyModifier = std::find_if(rArgs.begin(), rArgs.end(),
 350                                                     [](const beans::PropertyValue& lhs)
 351                                                     {return lhs.Name == "KeyModifier";} );
 352     sal_Int16 nKeyModifier = 0;
 353     if ( !(pKeyModifier != rArgs.end() && ( pKeyModifier->Value >>= nKeyModifier ) && nKeyModifier == KEY_MOD1) )
 354         return;
 355
 356     if ( eDrawMode != CHARTDRAW_INSERT )
 357         return;
 358
 359     rtl::Reference<SdrObject> pObj = createDefaultObject( nFeatureId );
 360     if ( pObj )
 361     {
 362         SdrPageView* pPageView = pDrawViewWrapper->GetSdrPageView();
 363         if (pDrawViewWrapper->InsertObjectAtView(pObj.get(), *pPageView))
 364             m_pChartController->SetAndApplySelection(Reference<drawing::XShape>(pObj->getUnoShape(), uno::UNO_QUERY));
 365         if ( nFeatureId == ChartCommandID::DrawText )
 366         {
 367             m_pChartController->StartTextEdit();
 368         }
 369     }
 370 }
 371
 372 void DrawCommandDispatch::describeSupportedFeatures()
 373 {
 374     implDescribeSupportedFeature( ".uno:SelectObject",      ChartCommandID::DrawObjectSelect,           CommandGroup::INSERT );
 375     implDescribeSupportedFeature( ".uno:Line",              ChartCommandID::DrawLine,               CommandGroup::INSERT );
 376     implDescribeSupportedFeature( ".uno:LineArrowEnd",      ChartCommandID::DrawLineArrowEnd,          CommandGroup::INSERT );
 377     implDescribeSupportedFeature( ".uno:Rect",              ChartCommandID::DrawRect,               CommandGroup::INSERT );
 378     implDescribeSupportedFeature( ".uno:Ellipse",           ChartCommandID::DrawEllipse,            CommandGroup::INSERT );
 379     implDescribeSupportedFeature( ".uno:Freeline_Unfilled", ChartCommandID::DrawFreelineNoFill,    CommandGroup::INSERT );
 380     implDescribeSupportedFeature( ".uno:DrawText",          ChartCommandID::DrawText,               CommandGroup::INSERT );
 381     implDescribeSupportedFeature( ".uno:DrawCaption",       ChartCommandID::DrawCaption,            CommandGroup::INSERT );
 382     implDescribeSupportedFeature( ".uno:BasicShapes",       ChartCommandID::DrawToolboxCsBasic,        CommandGroup::INSERT );
 383     implDescribeSupportedFeature( ".uno:SymbolShapes",      ChartCommandID::DrawToolboxCsSymbol,       CommandGroup::INSERT );
 384     implDescribeSupportedFeature( ".uno:ArrowShapes",       ChartCommandID::DrawToolboxCsArrow,        CommandGroup::INSERT );
 385     implDescribeSupportedFeature( ".uno:FlowChartShapes",   ChartCommandID::DrawToolboxCsFlowchart,    CommandGroup::INSERT );
 386     implDescribeSupportedFeature( ".uno:CalloutShapes",     ChartCommandID::DrawToolboxCsCallout,      CommandGroup::INSERT );
 387     implDescribeSupportedFeature( ".uno:StarShapes",        ChartCommandID::DrawToolboxCsStar,         CommandGroup::INSERT );
 388 }
 389
 390 void DrawCommandDispatch::setInsertObj(SdrObjKind eObj)
 391 {
 392     DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
 393     if ( pDrawViewWrapper )
 394     {
 395         pDrawViewWrapper->SetCurrentObj( eObj /*, Inventor */);
 396     }
 397 }
 398
 399 rtl::Reference<SdrObject> DrawCommandDispatch::createDefaultObject( const ChartCommandID nID )
 400 {
 401     rtl::Reference<SdrObject> pObj;
 402     DrawViewWrapper* pDrawViewWrapper = ( m_pChartController ? m_pChartController->GetDrawViewWrapper() : nullptr );
 403     DrawModelWrapper* pDrawModelWrapper = ( m_pChartController ? m_pChartController->GetDrawModelWrapper() : nullptr );
 404
 405     if ( pDrawViewWrapper && pDrawModelWrapper )
 406     {
 407         Reference< drawing::XDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );
 408         SdrPage* pPage = GetSdrPageFromXDrawPage( xDrawPage );
 409         if ( pPage )
 410         {
 411             SolarMutexGuard aGuard;
 412
 413             pObj = SdrObjFactory::MakeNewObject(
 414                 pDrawModelWrapper->getSdrModel(),
 415                 pDrawViewWrapper->GetCurrentObjInventor(),
 416                 pDrawViewWrapper->GetCurrentObjIdentifier());
 417
 418             if ( pObj )
 419             {
 420                 Size aObjectSize( 4000, 2500 );
 421                 tools::Rectangle aPageRect( tools::Rectangle( Point( 0, 0 ), pPage->GetSize() ) );
 422                 Point aObjectPos = aPageRect.Center();
 423                 aObjectPos.AdjustX( -(aObjectSize.Width() / 2) );
 424                 aObjectPos.AdjustY( -(aObjectSize.Height() / 2) );
 425                 tools::Rectangle aRect( aObjectPos, aObjectSize );
 426
 427                 switch ( nID )
 428                 {
 429                     case ChartCommandID::DrawLine:
 430                     case ChartCommandID::DrawLineArrowEnd:
 431                         {
 432                             if ( auto const pathObj = dynamic_cast<SdrPathObj*>( pObj.get()) )
 433                             {
 434                                 Point aStart = aRect.TopLeft();
 435                                 Point aEnd = aRect.BottomRight();
 436                                 sal_Int32 nYMiddle( ( aRect.Top() + aRect.Bottom() ) / 2 );
 437                                 basegfx::B2DPolygon aPoly;
 438                                 aPoly.append( basegfx::B2DPoint( aStart.X(), nYMiddle ) );
 439                                 aPoly.append( basegfx::B2DPoint( aEnd.X(), nYMiddle ) );
 440                                 pathObj->SetPathPoly(basegfx::B2DPolyPolygon(aPoly));
 441                                 SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
 442                                 setLineEnds( aSet );
 443                                 pObj->SetMergedItemSet( aSet );
 444                             }
 445                         }
 446                         break;
 447                     case ChartCommandID::DrawFreelineNoFill:
 448                         {
 449                             if ( auto const pathObj = dynamic_cast<SdrPathObj*>( pObj.get()) )
 450                             {
 451                                 basegfx::B2DPolygon aInnerPoly;
 452                                 aInnerPoly.append( basegfx::B2DPoint( aRect.Left(), aRect.Bottom() ) );
 453                                 aInnerPoly.appendBezierSegment(
 454                                     basegfx::B2DPoint( aRect.Left(), aRect.Top() ),
 455                                     basegfx::B2DPoint( aRect.Center().X(), aRect.Top() ),
 456                                     basegfx::B2DPoint( aRect.Center().X(), aRect.Center().Y() ) );
 457                                 aInnerPoly.appendBezierSegment(
 458                                     basegfx::B2DPoint( aRect.Center().X(), aRect.Bottom() ),
 459                                     basegfx::B2DPoint( aRect.Right(), aRect.Bottom() ),
 460                                     basegfx::B2DPoint( aRect.Right(), aRect.Top() ) );
 461                                 basegfx::B2DPolyPolygon aPoly;
 462                                 aPoly.append( aInnerPoly );
 463                                 pathObj->SetPathPoly(aPoly);
 464                             }
 465                         }
 466                         break;
 467                     case ChartCommandID::DrawText:
 468                     case ChartCommandID::DrawTextVertical:
 469                         {
 470                             if ( SdrTextObj* pTextObj = DynCastSdrTextObj( pObj.get()) )
 471                             {
 472                                 pTextObj->SetLogicRect( aRect );
 473                                 bool bVertical = ( nID == ChartCommandID::DrawTextVertical );
 474                                 pTextObj->SetVerticalWriting( bVertical );
 475                                 if ( bVertical )
 476                                 {
 477                                     SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
 478                                     aSet.Put( makeSdrTextAutoGrowWidthItem( true ) );
 479                                     aSet.Put( makeSdrTextAutoGrowHeightItem( false ) );
 480                                     aSet.Put( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_TOP ) );
 481                                     aSet.Put( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_RIGHT ) );
 482                                     pTextObj->SetMergedItemSet( aSet );
 483                                 }
 484                             }
 485                         }
 486                         break;
 487                     case ChartCommandID::DrawCaption:
 488                     case ChartCommandID::DrawCaptionVertical:
 489                         {
 490                             if ( SdrCaptionObj* pCaptionObj = dynamic_cast<SdrCaptionObj*>( pObj.get()) )
 491                             {
 492                                 bool bIsVertical( nID == ChartCommandID::DrawCaptionVertical );
 493                                 pCaptionObj->SetVerticalWriting( bIsVertical );
 494                                 if ( bIsVertical )
 495                                 {
 496                                     SfxItemSet aSet( pObj->GetMergedItemSet() );
 497                                     aSet.Put( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) );
 498                                     aSet.Put( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_RIGHT ) );
 499                                     pObj->SetMergedItemSet( aSet );
 500                                 }
 501                                 pCaptionObj->SetLogicRect( aRect );
 502                                 pCaptionObj->SetTailPos(
 503                                     aRect.TopLeft() - Point( aRect.GetWidth() / 2, aRect.GetHeight() / 2 ) );
 504                             }
 505                         }
 506                         break;
 507                     default:
 508                         {
 509                             pObj->SetLogicRect( aRect );
 510                             SfxItemSet aSet( pDrawModelWrapper->GetItemPool() );
 511                             setAttributes( pObj.get() );
 512                             pObj->SetMergedItemSet( aSet );
 513                         }
 514                         break;
 515                 }
 516             }
 517         }
 518     }
 519
 520     return pObj;
 521 }
 522
 523 bool DrawCommandDispatch::parseCommandURL( const OUString& rCommandURL, ChartCommandID* pnFeatureId,
 524     OUString* pBaseCommand, OUString* pCustomShapeType )
 525 {
 526     bool bFound = true;
 527     ChartCommandID nFeatureId = ChartCommandID::NONE;
 528     OUString aBaseCommand;
 529     OUString aType;
 530
 531     sal_Int32 nIndex = std::min(sal_Int32(1), rCommandURL.getLength());
 532     std::u16string_view aToken = o3tl::getToken(rCommandURL, 0, '.', nIndex );
 533     if ( nIndex == -1 || aToken.empty() )
 534     {
 535         aBaseCommand = rCommandURL;
 536         SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( aBaseCommand );
 537         if ( aIter != m_aSupportedFeatures.end() )
 538         {
 539             nFeatureId = aIter->second.nFeatureId;
 540
 541             switch ( nFeatureId )
 542             {
 543                 case ChartCommandID::DrawToolboxCsBasic:
 544                     {
 545                         aType = "diamond";
 546                     }
 547                     break;
 548                 case ChartCommandID::DrawToolboxCsSymbol:
 549                     {
 550                         aType = "smiley";
 551                     }
 552                     break;
 553                 case ChartCommandID::DrawToolboxCsArrow:
 554                     {
 555                         aType = "left-right-arrow";
 556                     }
 557                     break;
 558                 case ChartCommandID::DrawToolboxCsFlowchart:
 559                     {
 560                         aType = "flowchart-internal-storage";
 561                     }
 562                     break;
 563                 case ChartCommandID::DrawToolboxCsCallout:
 564                     {
 565                         aType = "round-rectangular-callout";
 566                     }
 567                     break;
 568                 case ChartCommandID::DrawToolboxCsStar:
 569                     {
 570                         aType = "star5";
 571                     }
 572                     break;
 573                 default:
 574                     {
 575                     }
 576                     break;
 577             }
 578         }
 579         else
 580         {
 581             bFound = false;
 582         }
 583     }
 584     else
 585     {
 586         aBaseCommand = rCommandURL.copy( 0, nIndex - 1 );
 587         SupportedFeatures::const_iterator aIter = m_aSupportedFeatures.find( aBaseCommand );
 588         if ( aIter != m_aSupportedFeatures.end() )
 589         {
 590             nFeatureId = aIter->second.nFeatureId;
 591             aType = rCommandURL.getToken( 0, '.', nIndex );
 592         }
 593         else
 594         {
 595             bFound = false;
 596         }
 597     }
 598
 599     *pnFeatureId = nFeatureId;
 600     *pBaseCommand = aBaseCommand;
 601     *pCustomShapeType = aType;
 602
 603     return bFound;
 604 }
 605
 606 } //  namespace chart
 607
 608 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */