svx/source/unodraw/unoshap2.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 <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  23 #include <com/sun/star/awt/FontSlant.hpp>
  24 #include <com/sun/star/style/VerticalAlignment.hpp>
  25 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
  26 #include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
  27 #include <com/sun/star/awt/TextAlign.hpp>
  28 #include <com/sun/star/style/ParagraphAdjust.hpp>
  29 #include <com/sun/star/drawing/PointSequenceSequence.hpp>
  30 #include <com/sun/star/drawing/PointSequence.hpp>
  31 #include <com/sun/star/drawing/PolygonKind.hpp>
  32 #include <com/sun/star/graphic/XGraphic.hpp>
  33 #include <com/sun/star/drawing/BarCode.hpp>
  34 #include <o3tl/any.hxx>
  35 #include <o3tl/safeint.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <vcl/wmf.hxx>
  38 #include <vcl/cvtgrf.hxx>
  39 #include <vcl/graphic/BitmapHelper.hxx>
  40 #include <vcl/GraphicLoader.hxx>
  41
  42 #include <svx/svdpool.hxx>
  43
  44 #include <editeng/unoprnms.hxx>
  45 #include <svx/unoshape.hxx>
  46 #include <svx/unopage.hxx>
  47 #include <svx/svdobj.hxx>
  48 #include <svx/svdpage.hxx>
  49 #include <svx/svdmodel.hxx>
  50 #include <svx/svdouno.hxx>
  51 #include "shapeimpl.hxx"
  52 #include <svx/unoshprp.hxx>
  53 #include <svx/svdoashp.hxx>
  54 #include <svx/svdviter.hxx>
  55 #include <svx/svdview.hxx>
  56 #include <svx/svdopath.hxx>
  57 #include <basegfx/matrix/b2dhommatrix.hxx>
  58 #include <basegfx/polygon/b2dpolygon.hxx>
  59 #include <basegfx/point/b2dpoint.hxx>
  60 #include <basegfx/polygon/b2dpolygontools.hxx>
  61 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  62 #include <com/sun/star/awt/XBitmap.hpp>
  63 #include <svx/svdograf.hxx>
  64 #include <sal/log.hxx>
  65 #include <cppuhelper/queryinterface.hxx>
  66 #include <tools/stream.hxx>
  67
  68
  69 #include <memory>
  70
  71 using namespace ::cppu;
  72 using namespace ::com::sun::star;
  73 using namespace ::com::sun::star::uno;
  74 using namespace ::com::sun::star::lang;
  75 using namespace ::com::sun::star::container;
  76
  77 #define QUERYINT( xint ) \
  78     if( rType == cppu::UnoType<xint>::get() ) \
  79         aAny <<= Reference< xint >(this)
  80
  81 SvxShapeGroup::SvxShapeGroup(SdrObject* pObj, SvxDrawPage* pDrawPage)
  82     : SvxShapeGroupAnyD(pObj, getSvxMapProvider().GetMap(SVXMAP_GROUP), getSvxMapProvider().GetPropertySet(SVXMAP_GROUP, SdrObject::GetGlobalDrawObjectItemPool()))
  83     , mxWeakPage(pDrawPage)
  84 {
  85 }
  86
  87 SvxShapeGroup::~SvxShapeGroup() noexcept
  88 {
  89 }
  90
  91 void SvxShapeGroup::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
  92 {
  93     SvxShape::Create( pNewObj, pNewPage );
  94     mxWeakPage = pNewPage;
  95 }
  96
  97
  98 uno::Any SAL_CALL SvxShapeGroup::queryInterface( const uno::Type & rType )
  99 {
 100     return SvxShape::queryInterface( rType );
 101 }
 102
 103 uno::Any SAL_CALL SvxShapeGroup::queryAggregation( const uno::Type & rType )
 104 {
 105     uno::Any aAny;
 106
 107     QUERYINT( drawing::XShapeGroup );
 108     else QUERYINT( drawing::XShapes );
 109     else QUERYINT( drawing::XShapes2 );
 110     else QUERYINT( container::XIndexAccess );
 111     else QUERYINT( container::XElementAccess );
 112     else
 113         return SvxShape::queryAggregation( rType );
 114
 115     return aAny;
 116 }
 117
 118 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeGroup::getImplementationId()
 119 {
 120     return css::uno::Sequence<sal_Int8>();
 121 }
 122
 123 // css::drawing::XShape
 124
 125
 126 OUString SAL_CALL SvxShapeGroup::getShapeType()
 127 {
 128     return SvxShape::getShapeType();
 129 }
 130
 131 awt::Point SAL_CALL SvxShapeGroup::getPosition()
 132 {
 133     return SvxShape::getPosition();
 134 }
 135
 136
 137 void SAL_CALL SvxShapeGroup::setPosition( const awt::Point& Position )
 138 {
 139     SvxShape::setPosition(Position);
 140 }
 141
 142
 143 awt::Size SAL_CALL SvxShapeGroup::getSize()
 144 {
 145     return SvxShape::getSize();
 146 }
 147
 148
 149 void SAL_CALL SvxShapeGroup::setSize( const awt::Size& rSize )
 150 {
 151     SvxShape::setSize( rSize );
 152 }
 153
 154 // drawing::XShapeGroup
 155
 156
 157 void SAL_CALL SvxShapeGroup::enterGroup(  )
 158 {
 159     // Todo
 160 //  pDrView->EnterMarkedGroup();
 161 }
 162
 163
 164 void SAL_CALL SvxShapeGroup::leaveGroup(  )
 165 {
 166     // Todo
 167 //  pDrView->LeaveOneGroup();
 168 }
 169
 170 void SvxShapeGroup::addUnoShape( const uno::Reference< drawing::XShape >& xShape, size_t nPos )
 171 {
 172     SvxShape* pShape = comphelper::getFromUnoTunnel<SvxShape>( xShape );
 173     if (!pShape)
 174     {
 175         OSL_FAIL("could not add XShape to group shape!");
 176         return;
 177     }
 178     addShape(*pShape, nPos);
 179 }
 180
 181 void SvxShapeGroup::addShape( SvxShape& rShape )
 182 {
 183     addShape(rShape, SAL_MAX_SIZE);
 184 }
 185
 186 void SvxShapeGroup::addShape( SvxShape& rShape, size_t nPos )
 187 {
 188     SdrObject* pSdrObject = GetSdrObject();
 189     if (!pSdrObject)
 190     {
 191         return;
 192     }
 193     rtl::Reference<SvxDrawPage> xPage = mxWeakPage.get();
 194     if (!xPage)
 195     {
 196         OSL_FAIL("could not add XShape to group shape!");
 197         return;
 198     }
 199
 200     rtl::Reference<SdrObject> pSdrShape = rShape.GetSdrObject();
 201     if( pSdrShape == nullptr )
 202         pSdrShape = xPage->CreateSdrObject_( &rShape );
 203
 204     if( pSdrShape->IsInserted() )
 205         pSdrShape->getParentSdrObjListFromSdrObject()->RemoveObject( pSdrShape->GetOrdNum() );
 206
 207     pSdrObject->GetSubList()->InsertObject(pSdrShape.get(), nPos);
 208     // TTTT Was created using mpModel in CreateSdrObject_ above
 209     // TTTT may be good to add an assertion here for the future
 210     // pSdrShape->SetModel(GetSdrObject()->GetModel());
 211
 212     // #85922# It makes no sense to set the layer asked
 213     // from the group object since this is an iteration
 214     // over the contained objects. In consequence, this
 215     // statement erases all layer information from the draw
 216     // objects. Layers need to be set at draw objects directly
 217     // and have nothing to do with grouping at all.
 218     // pSdrShape->SetLayer(pObject->GetLayer());
 219
 220     // Establish connection between new SdrObject and its wrapper before
 221     // inserting the new shape into the group.  There a new wrapper
 222     // would be created when this connection would not already exist.
 223     rShape.Create( pSdrShape.get(), xPage.get() );
 224
 225     pSdrObject->getSdrModelFromSdrObject().SetChanged();
 226 }
 227
 228 // XShapes
 229 void SAL_CALL SvxShapeGroup::add( const uno::Reference< drawing::XShape >& xShape )
 230 {
 231     ::SolarMutexGuard aGuard;
 232
 233     // Add to the top of the stack (i.e. bottom of the list) by default.
 234     addUnoShape(xShape, SAL_MAX_SIZE);
 235 }
 236
 237
 238 void SAL_CALL SvxShapeGroup::remove( const uno::Reference< drawing::XShape >& xShape )
 239 {
 240     ::SolarMutexGuard aGuard;
 241
 242     SdrObject* pSdrShape = SdrObject::getSdrObjectFromXShape( xShape );
 243
 244     if( !HasSdrObject() || pSdrShape == nullptr || pSdrShape->getParentSdrObjectFromSdrObject() != GetSdrObject() )
 245         throw uno::RuntimeException();
 246
 247     SdrObjList& rList = *pSdrShape->getParentSdrObjListFromSdrObject();
 248
 249     const size_t nObjCount = rList.GetObjCount();
 250     size_t nObjNum = 0;
 251     while( nObjNum < nObjCount )
 252     {
 253         if(rList.GetObj( nObjNum ) == pSdrShape )
 254             break;
 255         nObjNum++;
 256     }
 257
 258     if( nObjNum < nObjCount )
 259     {
 260         // #i29181#
 261         // If the SdrObject which is about to be deleted is in any selection,
 262         // deselect it first.
 263         SdrViewIter::ForAllViews( pSdrShape,
 264             [&pSdrShape] (SdrView* pView)
 265             {
 266                 if(SAL_MAX_SIZE != pView->GetMarkedObjectList().FindObject(pSdrShape))
 267                 {
 268                     pView->MarkObj(pSdrShape, pView->GetSdrPageView(), true);
 269                 }
 270             });
 271
 272         rList.NbcRemoveObject( nObjNum );
 273     }
 274     else
 275     {
 276         SAL_WARN( "svx", "Fatality! SdrObject is not belonging to its SdrObjList! [CL]" );
 277     }
 278
 279     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 280 }
 281
 282 void SAL_CALL SvxShapeGroup::addTop( const uno::Reference< drawing::XShape >& xShape )
 283 {
 284     SolarMutexGuard aGuard;
 285
 286     // Add to the top of the stack (i.e. bottom of the list).
 287     addUnoShape(xShape, SAL_MAX_SIZE);
 288 }
 289
 290 void SAL_CALL SvxShapeGroup::addBottom( const uno::Reference< drawing::XShape >& xShape )
 291 {
 292     SolarMutexGuard aGuard;
 293
 294     // Add to the bottom of the stack (i.e. top of the list).
 295     addUnoShape(xShape, 0);
 296 }
 297
 298 // XIndexAccess
 299
 300
 301 sal_Int32 SAL_CALL SvxShapeGroup::getCount()
 302 {
 303     ::SolarMutexGuard aGuard;
 304
 305     if(!HasSdrObject() || !GetSdrObject()->GetSubList())
 306         throw uno::RuntimeException();
 307
 308     sal_Int32 nRetval = GetSdrObject()->GetSubList()->GetObjCount();
 309     return nRetval;
 310 }
 311
 312
 313 uno::Any SAL_CALL SvxShapeGroup::getByIndex( sal_Int32 Index )
 314 {
 315     ::SolarMutexGuard aGuard;
 316
 317     if( !HasSdrObject() || GetSdrObject()->GetSubList() == nullptr )
 318         throw uno::RuntimeException();
 319
 320     if( Index<0 || GetSdrObject()->GetSubList()->GetObjCount() <= o3tl::make_unsigned(Index) )
 321         throw lang::IndexOutOfBoundsException();
 322
 323     SdrObject* pDestObj = GetSdrObject()->GetSubList()->GetObj( Index );
 324
 325     if(pDestObj == nullptr)
 326         throw lang::IndexOutOfBoundsException();
 327
 328     Reference< drawing::XShape > xShape( pDestObj->getUnoShape(), uno::UNO_QUERY );
 329     return uno::Any( xShape );
 330 }
 331
 332 // css::container::XElementAccess
 333
 334
 335 uno::Type SAL_CALL SvxShapeGroup::getElementType()
 336 {
 337     return cppu::UnoType<drawing::XShape>::get();
 338 }
 339
 340
 341 sal_Bool SAL_CALL SvxShapeGroup::hasElements()
 342 {
 343     ::SolarMutexGuard aGuard;
 344
 345     return HasSdrObject() && GetSdrObject()->GetSubList() && (GetSdrObject()->GetSubList()->GetObjCount() > 0);
 346 }
 347
 348 SvxShapeConnector::SvxShapeConnector(SdrObject* pObj)
 349     : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CONNECTOR), getSvxMapProvider().GetPropertySet(SVXMAP_CONNECTOR, SdrObject::GetGlobalDrawObjectItemPool()) )
 350 {
 351 }
 352
 353
 354 SvxShapeConnector::~SvxShapeConnector() noexcept
 355 {
 356 }
 357
 358
 359 uno::Any SAL_CALL SvxShapeConnector::queryInterface( const uno::Type & rType )
 360 {
 361     return SvxShapeText::queryInterface( rType );
 362 }
 363
 364 uno::Any SAL_CALL SvxShapeConnector::queryAggregation( const uno::Type & rType )
 365 {
 366     uno::Any aAny;
 367
 368     QUERYINT( drawing::XConnectorShape );
 369     else
 370         return SvxShapeText::queryAggregation( rType );
 371
 372     return aAny;
 373 }
 374
 375 // XTypeProvider
 376
 377 uno::Sequence< uno::Type > SAL_CALL SvxShapeConnector::getTypes()
 378 {
 379     return SvxShape::getTypes();
 380 }
 381
 382 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeConnector::getImplementationId()
 383 {
 384     return css::uno::Sequence<sal_Int8>();
 385 }
 386
 387 // css::drawing::XShape
 388
 389
 390 OUString SAL_CALL SvxShapeConnector::getShapeType()
 391 {
 392     return SvxShapeText::getShapeType();
 393 }
 394
 395 awt::Point SAL_CALL SvxShapeConnector::getPosition()
 396 {
 397     return SvxShapeText::getPosition();
 398 }
 399
 400
 401 void SAL_CALL SvxShapeConnector::setPosition( const awt::Point& Position )
 402 {
 403     SvxShapeText::setPosition(Position);
 404 }
 405
 406
 407 awt::Size SAL_CALL SvxShapeConnector::getSize()
 408 {
 409     return SvxShapeText::getSize();
 410 }
 411
 412
 413 void SAL_CALL SvxShapeConnector::setSize( const awt::Size& rSize )
 414 {
 415     SvxShapeText::setSize( rSize );
 416 }
 417
 418
 419 // XConnectorShape
 420
 421 void SAL_CALL SvxShapeConnector::connectStart( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType )
 422 {
 423     ::SolarMutexGuard aGuard;
 424
 425     Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
 426     SdrObject* pSdrObject = SdrObject::getSdrObjectFromXShape( xRef );
 427
 428     if( pSdrObject )
 429         GetSdrObject()->ConnectToNode( true, pSdrObject );
 430
 431     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 432 }
 433
 434
 435 void SAL_CALL SvxShapeConnector::connectEnd( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType  )
 436 {
 437     ::SolarMutexGuard aGuard;
 438
 439     Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
 440     SdrObject* pSdrObject = SdrObject::getSdrObjectFromXShape( xRef );
 441
 442     if( HasSdrObject() && pSdrObject )
 443         GetSdrObject()->ConnectToNode( false, pSdrObject );
 444
 445     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 446 }
 447
 448
 449 void SAL_CALL SvxShapeConnector::disconnectBegin( const uno::Reference< drawing::XConnectableShape >&  )
 450 {
 451     ::SolarMutexGuard aGuard;
 452
 453     if(HasSdrObject())
 454         GetSdrObject()->DisconnectFromNode( true );
 455
 456     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 457 }
 458
 459
 460 void SAL_CALL SvxShapeConnector::disconnectEnd( const uno::Reference< drawing::XConnectableShape >& )
 461 {
 462     ::SolarMutexGuard aGuard;
 463
 464     if(HasSdrObject())
 465         GetSdrObject()->DisconnectFromNode( false );
 466
 467     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 468 }
 469
 470 SvxShapeControl::SvxShapeControl(SdrObject* pObj)
 471     : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CONTROL), getSvxMapProvider().GetPropertySet(SVXMAP_CONTROL, SdrObject::GetGlobalDrawObjectItemPool()) )
 472 {
 473     setShapeKind( SdrObjKind::UNO );
 474 }
 475
 476
 477 SvxShapeControl::~SvxShapeControl() noexcept
 478 {
 479 }
 480
 481
 482 uno::Any SAL_CALL SvxShapeControl::queryInterface( const uno::Type & rType )
 483 {
 484     return SvxShapeText::queryInterface( rType );
 485 }
 486
 487 uno::Any SAL_CALL SvxShapeControl::queryAggregation( const uno::Type & rType )
 488 {
 489     uno::Any aAny;
 490
 491     QUERYINT( drawing::XControlShape );
 492     else
 493         return SvxShapeText::queryAggregation( rType );
 494
 495     return aAny;
 496 }
 497
 498 // XTypeProvider
 499
 500 uno::Sequence< uno::Type > SAL_CALL SvxShapeControl::getTypes()
 501 {
 502     return SvxShape::getTypes();
 503 }
 504
 505 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeControl::getImplementationId()
 506 {
 507     return css::uno::Sequence<sal_Int8>();
 508 }
 509
 510 // css::drawing::XShape
 511
 512
 513 OUString SAL_CALL SvxShapeControl::getShapeType()
 514 {
 515     return SvxShapeText::getShapeType();
 516 }
 517
 518 awt::Point SAL_CALL SvxShapeControl::getPosition()
 519 {
 520     return SvxShapeText::getPosition();
 521 }
 522
 523
 524 void SAL_CALL SvxShapeControl::setPosition( const awt::Point& Position )
 525 {
 526     SvxShapeText::setPosition(Position);
 527 }
 528
 529
 530 awt::Size SAL_CALL SvxShapeControl::getSize()
 531 {
 532     return SvxShapeText::getSize();
 533 }
 534
 535
 536 void SAL_CALL SvxShapeControl::setSize( const awt::Size& rSize )
 537 {
 538     SvxShapeText::setSize( rSize );
 539 }
 540
 541
 542 // XControlShape
 543
 544 Reference< awt::XControlModel > SAL_CALL SvxShapeControl::getControl()
 545 {
 546     ::SolarMutexGuard aGuard;
 547
 548     Reference< awt::XControlModel > xModel;
 549
 550     SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(GetSdrObject());
 551     if( pUnoObj )
 552         xModel = pUnoObj->GetUnoControlModel();
 553
 554     return xModel;
 555 }
 556
 557
 558 void SAL_CALL SvxShapeControl::setControl( const Reference< awt::XControlModel >& xControl )
 559 {
 560     ::SolarMutexGuard aGuard;
 561
 562     SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(GetSdrObject());
 563     if( pUnoObj )
 564         pUnoObj->SetUnoControlModel( xControl );
 565
 566     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
 567 }
 568
 569 struct
 570 {
 571     OUString msAPIName;
 572     OUString msFormName;
 573 }
 574 const SvxShapeControlPropertyMapping[] =
 575 {
 576     // Warning: The first entry must be FontSlant because the any needs to be converted
 577     { UNO_NAME_EDIT_CHAR_POSTURE, u"FontSlant"_ustr  }, //  const sal_Int16 => css::awt::FontSlant
 578     { UNO_NAME_EDIT_CHAR_FONTNAME, u"FontName"_ustr },
 579     { UNO_NAME_EDIT_CHAR_FONTSTYLENAME, u"FontStyleName"_ustr },
 580     { UNO_NAME_EDIT_CHAR_FONTFAMILY, u"FontFamily"_ustr },
 581     { UNO_NAME_EDIT_CHAR_FONTCHARSET, u"FontCharset"_ustr },
 582     { UNO_NAME_EDIT_CHAR_HEIGHT, u"FontHeight"_ustr },
 583     { UNO_NAME_EDIT_CHAR_FONTPITCH, u"FontPitch"_ustr },
 584     { UNO_NAME_EDIT_CHAR_WEIGHT, u"FontWeight"_ustr },
 585     { UNO_NAME_EDIT_CHAR_UNDERLINE, u"FontUnderline"_ustr },
 586     { UNO_NAME_EDIT_CHAR_STRIKEOUT, u"FontStrikeout"_ustr },
 587     { u"CharKerning"_ustr, u"FontKerning"_ustr },
 588     { u"CharWordMode"_ustr, u"FontWordLineMode"_ustr },
 589     { UNO_NAME_EDIT_CHAR_COLOR,   u"TextColor"_ustr },
 590     { u"CharBackColor"_ustr, u"CharBackColor"_ustr },
 591     { u"CharBackTransparent"_ustr, u"CharBackTransparent"_ustr },
 592     { UNO_NAME_TEXT_CHAINNEXTNAME, UNO_NAME_TEXT_CHAINNEXTNAME },
 593     { u"CharRelief"_ustr,   u"FontRelief"_ustr },
 594     { u"CharUnderlineColor"_ustr,   u"TextLineColor"_ustr },
 595     { UNO_NAME_EDIT_PARA_ADJUST, u"Align"_ustr },
 596     { u"TextVerticalAdjust"_ustr, u"VerticalAlign"_ustr },
 597     { u"ControlBackground"_ustr, u"BackgroundColor"_ustr },
 598     { u"ControlSymbolColor"_ustr, u"SymbolColor"_ustr },
 599     { u"ControlBorder"_ustr, u"Border"_ustr },
 600     { u"ControlBorderColor"_ustr, u"BorderColor"_ustr },
 601     { u"ControlTextEmphasis"_ustr,  u"FontEmphasisMark"_ustr },
 602     { u"ImageScaleMode"_ustr,  u"ScaleMode"_ustr },
 603     { u"ControlWritingMode"_ustr, u"WritingMode"_ustr },
 604     //added for exporting OCX control
 605     { u"ControlTypeinMSO"_ustr, u"ControlTypeinMSO"_ustr },
 606     { u"ObjIDinMSO"_ustr, u"ObjIDinMSO"_ustr },
 607     { u"CharCaseMap"_ustr, u"CharCaseMap"_ustr },
 608     { u"CharColorTheme"_ustr, u"CharColorTheme"_ustr },
 609     { u"CharColorTintOrShade"_ustr, u"CharColorTintOrShade"_ustr },
 610     { UNO_NAME_EDIT_CHAR_COMPLEX_COLOR, u"CharComplexColor"_ustr },
 611 };
 612
 613 namespace
 614 {
 615     bool lcl_convertPropertyName( std::u16string_view rApiName, OUString& rInternalName )
 616     {
 617         for( const auto & rEntry : SvxShapeControlPropertyMapping )
 618         {
 619             if( rApiName == rEntry.msAPIName )
 620             {
 621                 rInternalName = rEntry.msFormName;
 622             }
 623         }
 624         return !rInternalName.isEmpty();
 625     }
 626
 627     struct EnumConversionMap
 628     {
 629         style::ParagraphAdjust   nAPIValue;
 630         sal_Int16                nFormValue;
 631     };
 632
 633     EnumConversionMap const aMapAdjustToAlign[] =
 634     {
 635         // note that order matters:
 636         // lcl_convertTextAlignmentToParaAdjustment and lcl_convertParaAdjustmentToTextAlignment search this map from the _beginning_
 637         // and use the first matching entry
 638         {style::ParagraphAdjust_LEFT,           sal_Int16(awt::TextAlign::LEFT)},
 639         {style::ParagraphAdjust_CENTER,         sal_Int16(awt::TextAlign::CENTER)},
 640         {style::ParagraphAdjust_RIGHT,          sal_Int16(awt::TextAlign::RIGHT)},
 641         {style::ParagraphAdjust_BLOCK,          sal_Int16(awt::TextAlign::RIGHT)},
 642         {style::ParagraphAdjust_STRETCH,        sal_Int16(awt::TextAlign::LEFT)},
 643         {style::ParagraphAdjust(-1),-1}
 644     };
 645
 646     void lcl_convertTextAlignmentToParaAdjustment( Any& _rValue )
 647     {
 648         sal_Int16 nValue = sal_Int16();
 649         OSL_VERIFY( _rValue >>= nValue );
 650
 651         for ( auto const & rEntry : aMapAdjustToAlign )
 652             if ( nValue == rEntry.nFormValue )
 653             {
 654                 _rValue <<= static_cast<sal_uInt16>(rEntry.nAPIValue);
 655                 return;
 656             }
 657     }
 658
 659     void lcl_convertParaAdjustmentToTextAlignment( Any& _rValue )
 660     {
 661         sal_Int32 nValue = 0;
 662         OSL_VERIFY( _rValue >>= nValue );
 663
 664         for ( auto const & rEntry : aMapAdjustToAlign )
 665             if ( static_cast<style::ParagraphAdjust>(nValue) == rEntry.nAPIValue )
 666             {
 667                 _rValue <<= rEntry.nFormValue;
 668                 return;
 669             }
 670     }
 671
 672     void convertVerticalAdjustToVerticalAlign( Any& _rValue )
 673     {
 674         if ( !_rValue.hasValue() )
 675             return;
 676
 677         drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
 678         style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
 679         if ( !( _rValue >>= eAdjust ) )
 680             throw lang::IllegalArgumentException();
 681         switch ( eAdjust )
 682         {
 683         case drawing::TextVerticalAdjust_TOP:    eAlign = style::VerticalAlignment_TOP; break;
 684         case drawing::TextVerticalAdjust_BOTTOM: eAlign = style::VerticalAlignment_BOTTOM; break;
 685         default:                                 eAlign = style::VerticalAlignment_MIDDLE; break;
 686         }
 687         _rValue <<= eAlign;
 688     }
 689
 690     void convertVerticalAlignToVerticalAdjust( Any& _rValue )
 691     {
 692         if ( !_rValue.hasValue() )
 693             return;
 694         style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
 695         drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
 696         OSL_VERIFY( _rValue >>= eAlign );
 697         switch ( eAlign )
 698         {
 699         case style::VerticalAlignment_TOP:    eAdjust = drawing::TextVerticalAdjust_TOP; break;
 700         case style::VerticalAlignment_BOTTOM: eAdjust = drawing::TextVerticalAdjust_BOTTOM; break;
 701         default:                              eAdjust = drawing::TextVerticalAdjust_CENTER; break;
 702         }
 703         _rValue <<= eAdjust;
 704     }
 705 }
 706
 707 void SAL_CALL SvxShapeControl::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 708 {
 709     OUString aFormsName;
 710     if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
 711     {
 712         uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
 713         if( xControl.is() )
 714         {
 715             uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
 716             if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
 717             {
 718                 uno::Any aConvertedValue( aValue );
 719                 if ( aFormsName == "FontSlant" )
 720                 {
 721                     awt::FontSlant nSlant;
 722                     if( !(aValue >>= nSlant ) )
 723                         throw lang::IllegalArgumentException();
 724                     aConvertedValue <<= static_cast<sal_Int16>(nSlant);
 725                 }
 726                 else if ( aFormsName == "Align" )
 727                 {
 728                     lcl_convertParaAdjustmentToTextAlignment( aConvertedValue );
 729                 }
 730                 else if ( aFormsName == "VerticalAlign" )
 731                 {
 732                     convertVerticalAdjustToVerticalAlign( aConvertedValue );
 733                 }
 734
 735                 xControl->setPropertyValue( aFormsName, aConvertedValue );
 736             }
 737         }
 738     }
 739     else
 740     {
 741         SvxShape::setPropertyValue( aPropertyName, aValue );
 742     }
 743 }
 744
 745 uno::Any SAL_CALL SvxShapeControl::getPropertyValue( const OUString& aPropertyName )
 746 {
 747     OUString aFormsName;
 748     if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
 749     {
 750         uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
 751
 752         uno::Any aValue;
 753         if( xControl.is() )
 754         {
 755             uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
 756             if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
 757             {
 758                 aValue = xControl->getPropertyValue( aFormsName );
 759                 if ( aFormsName == "FontSlant" )
 760                 {
 761                     awt::FontSlant eSlant = awt::FontSlant_NONE;
 762                     sal_Int16 nSlant = sal_Int16();
 763                     if ( aValue >>= nSlant )
 764                     {
 765                         eSlant = static_cast<awt::FontSlant>(nSlant);
 766                     }
 767                     else
 768                     {
 769                         OSL_VERIFY( aValue >>= eSlant );
 770                     }
 771                     aValue <<= eSlant;
 772                 }
 773                 else if ( aFormsName == "Align" )
 774                 {
 775                     lcl_convertTextAlignmentToParaAdjustment( aValue );
 776                 }
 777                 else if ( aFormsName == "VerticalAlign" )
 778                 {
 779                     convertVerticalAlignToVerticalAdjust( aValue );
 780                 }
 781             }
 782         }
 783
 784         return aValue;
 785     }
 786     else
 787     {
 788         return SvxShape::getPropertyValue( aPropertyName );
 789     }
 790
 791 }
 792
 793 // XPropertyState
 794 beans::PropertyState SAL_CALL SvxShapeControl::getPropertyState( const OUString& PropertyName )
 795 {
 796     OUString aFormsName;
 797     if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
 798     {
 799         uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
 800         uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
 801
 802         if( xControl.is() && xPropSet.is() )
 803         {
 804             uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
 805             if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
 806             {
 807                 return xControl->getPropertyState( aFormsName );
 808             }
 809         }
 810
 811         return beans::PropertyState_DEFAULT_VALUE;
 812     }
 813     else
 814     {
 815         return SvxShape::getPropertyState( PropertyName );
 816     }
 817 }
 818
 819 void SAL_CALL SvxShapeControl::setPropertyToDefault( const OUString& PropertyName )
 820 {
 821     OUString aFormsName;
 822     if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
 823     {
 824         uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
 825         uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
 826
 827         if( xControl.is() && xPropSet.is() )
 828         {
 829             uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
 830             if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
 831             {
 832                 xControl->setPropertyToDefault( aFormsName );
 833             }
 834         }
 835     }
 836     else
 837     {
 838         SvxShape::setPropertyToDefault( PropertyName );
 839     }
 840 }
 841
 842 uno::Any SAL_CALL SvxShapeControl::getPropertyDefault( const OUString& aPropertyName )
 843 {
 844     OUString aFormsName;
 845     if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
 846     {
 847         uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
 848
 849         if( xControl.is() )
 850         {
 851             Any aDefault( xControl->getPropertyDefault( aFormsName ) );
 852             if ( aFormsName == "FontSlant" )
 853             {
 854                 sal_Int16 nSlant( 0 );
 855                 aDefault >>= nSlant;
 856                 aDefault <<= static_cast<awt::FontSlant>(nSlant);
 857             }
 858             else if ( aFormsName == "Align" )
 859             {
 860                 lcl_convertTextAlignmentToParaAdjustment( aDefault );
 861             }
 862             else if ( aFormsName == "VerticalAlign" )
 863             {
 864                 convertVerticalAlignToVerticalAdjust( aDefault );
 865             }
 866             return aDefault;
 867         }
 868
 869         throw beans::UnknownPropertyException( aPropertyName, getXWeak());
 870     }
 871     else
 872     {
 873         return SvxShape::getPropertyDefault( aPropertyName );
 874     }
 875 }
 876
 877 SvxShapeDimensioning::SvxShapeDimensioning(SdrObject* pObj)
 878     : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_DIMENSIONING), getSvxMapProvider().GetPropertySet(SVXMAP_DIMENSIONING, SdrObject::GetGlobalDrawObjectItemPool()) )
 879 {
 880 }
 881
 882 SvxShapeDimensioning::~SvxShapeDimensioning() noexcept
 883 {
 884 }
 885
 886 SvxShapeCircle::SvxShapeCircle(SdrObject* pObj)
 887     : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CIRCLE), getSvxMapProvider().GetPropertySet(SVXMAP_CIRCLE, SdrObject::GetGlobalDrawObjectItemPool()) )
 888 {
 889 }
 890
 891 SvxShapeCircle::~SvxShapeCircle() noexcept
 892 {
 893 }
 894
 895 //////////////////////////////////////////////////////////////////////////////
 896
 897 SvxShapePolyPolygon::SvxShapePolyPolygon(
 898     SdrObject* pObj)
 899 :   SvxShapeText(
 900         pObj,
 901         getSvxMapProvider().GetMap(SVXMAP_POLYPOLYGON),
 902         getSvxMapProvider().GetPropertySet(SVXMAP_POLYPOLYGON, SdrObject::GetGlobalDrawObjectItemPool()))
 903 {
 904 }
 905
 906 SvxShapePolyPolygon::~SvxShapePolyPolygon() noexcept
 907 {
 908 }
 909
 910 bool SvxShapePolyPolygon::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
 911 {
 912     switch( pProperty->nWID )
 913     {
 914     case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
 915     {
 916         if( auto s = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rValue) )
 917         {
 918             basegfx::B2DPolyPolygon aNewPolyPolygon(
 919                 basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(*s));
 920
 921             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
 922             ForceMetricToItemPoolMetric(aNewPolyPolygon);
 923
 924             SetPolygon(aNewPolyPolygon);
 925             return true;
 926         }
 927         break;
 928     }
 929     case OWN_ATTR_VALUE_POLYPOLYGON:
 930     {
 931         if( auto s = o3tl::tryAccess<drawing::PointSequenceSequence>(rValue) )
 932         {
 933             basegfx::B2DPolyPolygon aNewPolyPolygon(
 934                 basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(*s));
 935
 936             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
 937             ForceMetricToItemPoolMetric(aNewPolyPolygon);
 938
 939             SetPolygon(aNewPolyPolygon);
 940             return true;
 941         }
 942         break;
 943     }
 944     case OWN_ATTR_BASE_GEOMETRY:
 945     {
 946         drawing::PointSequenceSequence aPointSequenceSequence;
 947         drawing::PolyPolygonBezierCoords aPolyPolygonBezierCoords;
 948
 949         if( rValue >>= aPointSequenceSequence)
 950         {
 951             if( HasSdrObject() )
 952             {
 953                 basegfx::B2DPolyPolygon aNewPolyPolygon;
 954                 basegfx::B2DHomMatrix aNewHomogenMatrix;
 955
 956                 GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
 957                 aNewPolyPolygon = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(aPointSequenceSequence);
 958
 959                 // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
 960                 // Need to adapt aNewPolyPolygon from 100thmm to app-specific
 961                 ForceMetricToItemPoolMetric(aNewPolyPolygon);
 962
 963                 GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
 964             }
 965             return true;
 966         }
 967         else if( rValue >>= aPolyPolygonBezierCoords)
 968         {
 969             if( HasSdrObject() )
 970             {
 971                 basegfx::B2DPolyPolygon aNewPolyPolygon;
 972                 basegfx::B2DHomMatrix aNewHomogenMatrix;
 973
 974                 GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
 975                 aNewPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(aPolyPolygonBezierCoords);
 976
 977                 // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
 978                 ForceMetricToItemPoolMetric(aNewPolyPolygon);
 979
 980                 GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
 981             }
 982             return true;
 983         }
 984         break;
 985     }
 986     case OWN_ATTR_VALUE_POLYGON:
 987     {
 988         if( auto pSequence = o3tl::tryAccess<drawing::PointSequence>(rValue) )
 989         {
 990             // prepare new polygon
 991             basegfx::B2DPolygon aNewPolygon;
 992
 993             // get pointer to arrays
 994             const awt::Point* pArray    = pSequence->getConstArray();
 995             const awt::Point* pArrayEnd = pArray + pSequence->getLength();
 996
 997             for(;pArray != pArrayEnd;++pArray)
 998             {
 999                 aNewPolygon.append(basegfx::B2DPoint(pArray->X, pArray->Y));
1000             }
1001
1002             // check for closed state flag
1003             basegfx::utils::checkClosed(aNewPolygon);
1004
1005             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
1006             basegfx::B2DPolyPolygon aNewPolyPolygon(aNewPolygon);
1007             ForceMetricToItemPoolMetric(aNewPolyPolygon);
1008
1009             // set polygon
1010             SetPolygon(aNewPolyPolygon);
1011             return true;
1012         }
1013         break;
1014     }
1015     default:
1016         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
1017     }
1018
1019     throw lang::IllegalArgumentException();
1020 }
1021
1022 bool SvxShapePolyPolygon::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty,
1023                                                 css::uno::Any& rValue )
1024 {
1025     switch( pProperty->nWID )
1026     {
1027     case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
1028     {
1029         // pack a tools::PolyPolygon in a struct tools::PolyPolygon
1030         basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
1031
1032         // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
1033         ForceMetricTo100th_mm(aPolyPoly);
1034
1035         drawing::PolyPolygonBezierCoords aRetval;
1036         basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(aPolyPoly, aRetval);
1037
1038         rValue <<= aRetval;
1039         break;
1040     }
1041     case OWN_ATTR_VALUE_POLYPOLYGON:
1042     {
1043         // pack a tools::PolyPolygon in a struct tools::PolyPolygon
1044         basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
1045
1046         // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
1047         ForceMetricTo100th_mm(aPolyPoly);
1048
1049         drawing::PointSequenceSequence aRetval( aPolyPoly.count() );
1050         basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(aPolyPoly, aRetval);
1051
1052         rValue <<= aRetval;
1053         break;
1054     }
1055     case OWN_ATTR_BASE_GEOMETRY:
1056     {
1057         // pack a tools::PolyPolygon in struct PolyPolygon
1058         basegfx::B2DPolyPolygon aPolyPoly;
1059         basegfx::B2DHomMatrix aNewHomogenMatrix;
1060
1061         if(HasSdrObject())
1062         {
1063             GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aPolyPoly);
1064
1065             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
1066             ForceMetricTo100th_mm(aPolyPoly);
1067         }
1068
1069         if(aPolyPoly.areControlPointsUsed())
1070         {
1071             drawing::PolyPolygonBezierCoords aRetval;
1072             basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(aPolyPoly, aRetval);
1073             rValue <<= aRetval;
1074         }
1075         else
1076         {
1077             drawing::PointSequenceSequence aRetval(aPolyPoly.count());
1078             basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(aPolyPoly, aRetval);
1079             rValue <<= aRetval;
1080         }
1081         break;
1082     }
1083     case OWN_ATTR_VALUE_POLYGON:
1084     {
1085         // pack a tools::PolyPolygon in a struct tools::PolyPolygon
1086         basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
1087
1088         // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
1089         ForceMetricTo100th_mm(aPolyPoly);
1090
1091         const sal_Int32 nCount(0 == aPolyPoly.count() ? 0 : aPolyPoly.getB2DPolygon(0).count());
1092         drawing::PointSequence aRetval( nCount );
1093
1094         if( nCount > 0 )
1095         {
1096             // get single polygon
1097             const basegfx::B2DPolygon& aPoly(aPolyPoly.getB2DPolygon(0));
1098
1099             // get pointer to arrays
1100             awt::Point* pSequence = aRetval.getArray();
1101
1102             for(sal_Int32 b=0;b<nCount;b++)
1103             {
1104                 const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(b));
1105                 *pSequence++ = awt::Point( basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY()) );
1106             }
1107         }
1108
1109         rValue <<= aRetval;
1110         break;
1111     }
1112     case OWN_ATTR_VALUE_POLYGONKIND:
1113     {
1114         rValue <<= GetPolygonKind();
1115         break;
1116     }
1117     default:
1118         return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
1119     }
1120
1121     return true;
1122 }
1123
1124 drawing::PolygonKind SvxShapePolyPolygon::GetPolygonKind() const
1125 {
1126     ::SolarMutexGuard aGuard;
1127     drawing::PolygonKind aRetval(drawing::PolygonKind_LINE);
1128
1129     if(HasSdrObject())
1130     {
1131         switch(GetSdrObject()->GetObjIdentifier())
1132         {
1133             case SdrObjKind::Polygon:      aRetval = drawing::PolygonKind_POLY; break;
1134             case SdrObjKind::PolyLine:      aRetval = drawing::PolygonKind_PLIN; break;
1135             case SdrObjKind::PathLine:  aRetval = drawing::PolygonKind_PATHLINE; break;
1136             case SdrObjKind::PathFill:  aRetval = drawing::PolygonKind_PATHFILL; break;
1137             case SdrObjKind::FreehandLine:  aRetval = drawing::PolygonKind_FREELINE; break;
1138             case SdrObjKind::FreehandFill:  aRetval = drawing::PolygonKind_FREEFILL; break;
1139             default: break;
1140         }
1141     }
1142
1143     return aRetval;
1144 }
1145
1146 void SvxShapePolyPolygon::SetPolygon(const basegfx::B2DPolyPolygon& rNew)
1147 {
1148     ::SolarMutexGuard aGuard;
1149
1150     if(HasSdrObject())
1151         static_cast<SdrPathObj*>(GetSdrObject())->SetPathPoly(rNew);
1152 }
1153
1154
1155 basegfx::B2DPolyPolygon SvxShapePolyPolygon::GetPolygon() const noexcept
1156 {
1157     ::SolarMutexGuard aGuard;
1158
1159     if(HasSdrObject())
1160     {
1161         return static_cast<SdrPathObj*>(GetSdrObject())->GetPathPoly();
1162     }
1163     else
1164     {
1165         return basegfx::B2DPolyPolygon();
1166     }
1167 }
1168
1169 //////////////////////////////////////////////////////////////////////////////
1170
1171 SvxGraphicObject::SvxGraphicObject(SdrObject* pObj)
1172     : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_GRAPHICOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_GRAPHICOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
1173 {
1174 }
1175
1176 SvxGraphicObject::~SvxGraphicObject() noexcept
1177 {
1178 }
1179
1180 bool SvxGraphicObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
1181 {
1182     bool bOk = false;
1183     switch( pProperty->nWID )
1184     {
1185     case OWN_ATTR_VALUE_FILLBITMAP:
1186     {
1187         if( auto pSeq = o3tl::tryAccess<uno::Sequence<sal_Int8>>(rValue) )
1188         {
1189             SvMemoryStream  aMemStm;
1190             Graphic         aGraphic;
1191
1192             aMemStm.SetBuffer( const_cast<css::uno::Sequence<sal_Int8> *>(pSeq)->getArray(), pSeq->getLength(), pSeq->getLength() );
1193
1194             if( GraphicConverter::Import( aMemStm, aGraphic ) == ERRCODE_NONE )
1195             {
1196                 static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
1197                 bOk = true;
1198             }
1199         }
1200         else if (uno::Reference<graphic::XGraphic> xGraphic = vcl::GetGraphic(rValue))
1201         {
1202             // Handles both graphic::XGraphic and awt::XBitmap
1203             static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(Graphic(xGraphic));
1204             bOk = true;
1205         }
1206         if (bOk)
1207             GetSdrObject()->SetEmptyPresObj(false);
1208         break;
1209     }
1210
1211     case OWN_ATTR_GRAFSTREAMURL:
1212     {
1213         OUString aStreamURL;
1214
1215         if( rValue >>= aStreamURL )
1216         {
1217             if( !aStreamURL.startsWith( UNO_NAME_GRAPHOBJ_URLPKGPREFIX ) )
1218                 aStreamURL.clear();
1219
1220             if( HasSdrObject() )
1221             {
1222                 static_cast<SdrGrafObj*>(GetSdrObject())->SetGrafStreamURL( aStreamURL );
1223                 GetSdrObject()->SetEmptyPresObj(false);
1224             }
1225             bOk = true;
1226         }
1227         break;
1228     }
1229
1230     case OWN_ATTR_GRAPHIC_URL:
1231     {
1232         OUString aURL;
1233         uno::Reference<awt::XBitmap> xBitmap;
1234         if (rValue >>= aURL)
1235         {
1236             Graphic aGraphic = vcl::graphic::loadFromURL(aURL);
1237             if (!aGraphic.IsNone())
1238             {
1239                 static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
1240                 bOk = true;
1241             }
1242         }
1243         else if (rValue >>= xBitmap)
1244         {
1245             uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
1246             if (xGraphic.is())
1247             {
1248                 Graphic aGraphic = xGraphic;
1249                 if (!aGraphic.IsNone())
1250                 {
1251                     static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
1252                     bOk = true;
1253                 }
1254             }
1255         }
1256         if (bOk)
1257             GetSdrObject()->SetEmptyPresObj(false);
1258         break;
1259     }
1260
1261     case OWN_ATTR_VALUE_GRAPHIC:
1262     {
1263         Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
1264         if( xGraphic.is() )
1265         {
1266             static_cast< SdrGrafObj*>( GetSdrObject() )->SetGraphic( xGraphic );
1267             GetSdrObject()->SetEmptyPresObj(false);
1268             bOk = true;
1269         }
1270         break;
1271     }
1272
1273     case OWN_ATTR_IS_SIGNATURELINE:
1274     {
1275         bool bIsSignatureLine;
1276         if (rValue >>= bIsSignatureLine)
1277         {
1278             static_cast<SdrGrafObj*>(GetSdrObject())->setIsSignatureLine(bIsSignatureLine);
1279             bOk = true;
1280         }
1281         break;
1282     }
1283
1284     case OWN_ATTR_SIGNATURELINE_ID:
1285     {
1286         OUString aSignatureLineId;
1287         if (rValue >>= aSignatureLineId)
1288         {
1289             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineId(aSignatureLineId);
1290             bOk = true;
1291         }
1292         break;
1293     }
1294
1295     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_NAME:
1296     {
1297         OUString aSuggestedSignerName;
1298         if (rValue >>= aSuggestedSignerName)
1299         {
1300             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerName(aSuggestedSignerName);
1301             bOk = true;
1302         }
1303         break;
1304     }
1305
1306     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_TITLE:
1307     {
1308         OUString aSuggestedSignerTitle;
1309         if (rValue >>= aSuggestedSignerTitle)
1310         {
1311             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerTitle(aSuggestedSignerTitle);
1312             bOk = true;
1313         }
1314         break;
1315     }
1316
1317     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_EMAIL:
1318     {
1319         OUString aSuggestedSignerEmail;
1320         if (rValue >>= aSuggestedSignerEmail)
1321         {
1322             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerEmail(aSuggestedSignerEmail);
1323             bOk = true;
1324         }
1325         break;
1326     }
1327
1328     case OWN_ATTR_SIGNATURELINE_SIGNING_INSTRUCTIONS:
1329     {
1330         OUString aSigningInstructions;
1331         if (rValue >>= aSigningInstructions)
1332         {
1333             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSigningInstructions(aSigningInstructions);
1334             bOk = true;
1335         }
1336         break;
1337     }
1338
1339     case OWN_ATTR_SIGNATURELINE_SHOW_SIGN_DATE:
1340     {
1341         bool bShowSignDate;
1342         if (rValue >>= bShowSignDate)
1343         {
1344             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineShowSignDate(bShowSignDate);
1345             bOk = true;
1346         }
1347         break;
1348     }
1349
1350     case OWN_ATTR_SIGNATURELINE_CAN_ADD_COMMENT:
1351     {
1352         bool bCanAddComment;
1353         if (rValue >>= bCanAddComment)
1354         {
1355             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineCanAddComment(bCanAddComment);
1356             bOk = true;
1357         }
1358         break;
1359     }
1360
1361     case OWN_ATTR_SIGNATURELINE_UNSIGNED_IMAGE:
1362     {
1363         Reference<graphic::XGraphic> xGraphic(rValue, uno::UNO_QUERY);
1364         if (xGraphic.is())
1365         {
1366             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineUnsignedGraphic(xGraphic);
1367             bOk = true;
1368         }
1369         break;
1370     }
1371
1372     case OWN_ATTR_OBJ_ISEMPTYPRESOBJ:
1373     {
1374         bool bIsEmptyPresObj;
1375         if (rValue >>= bIsEmptyPresObj)
1376         {
1377             GetSdrObject()->SetEmptyPresObj(bIsEmptyPresObj);
1378             bOk = true;
1379         }
1380         break;
1381     }
1382
1383     case OWN_ATTR_SIGNATURELINE_IS_SIGNED:
1384     {
1385         bool bIsSigned;
1386         if (rValue >>= bIsSigned)
1387         {
1388             static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineIsSigned(bIsSigned);
1389             bOk = true;
1390         }
1391         break;
1392     }
1393
1394     case OWN_ATTR_QRCODE:
1395     {
1396         css::drawing::BarCode aBarCode;
1397         if (rValue >>= aBarCode)
1398         {
1399             static_cast<SdrGrafObj*>(GetSdrObject())->setQrCode(aBarCode);
1400             bOk = true;
1401         }
1402         break;
1403     }
1404
1405     default:
1406         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
1407     }
1408
1409     if( !bOk )
1410         throw lang::IllegalArgumentException();
1411
1412     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
1413
1414     return true;
1415 }
1416
1417 bool SvxGraphicObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
1418 {
1419     switch( pProperty->nWID )
1420     {
1421     case OWN_ATTR_VALUE_FILLBITMAP:
1422     {
1423         const Graphic& rGraphic = static_cast<SdrGrafObj*>(GetSdrObject())->GetGraphic();
1424
1425         if (rGraphic.GetType() != GraphicType::GdiMetafile)
1426         {
1427             uno::Reference<awt::XBitmap> xBitmap(rGraphic.GetXGraphic(), uno::UNO_QUERY);
1428             rValue <<= xBitmap;
1429         }
1430         else
1431         {
1432             SvMemoryStream aDestStrm( 65535, 65535 );
1433
1434             ConvertGDIMetaFileToWMF( rGraphic.GetGDIMetaFile(), aDestStrm, nullptr, false );
1435             const uno::Sequence<sal_Int8> aSeq(
1436                 static_cast< const sal_Int8* >(aDestStrm.GetData()),
1437                 aDestStrm.GetEndOfData());
1438             rValue <<= aSeq;
1439         }
1440         break;
1441     }
1442
1443     case OWN_ATTR_REPLACEMENT_GRAPHIC:
1444     {
1445         const GraphicObject* pGrafObj = static_cast< SdrGrafObj* >(GetSdrObject())->GetReplacementGraphicObject();
1446
1447         if (pGrafObj)
1448         {
1449             rValue <<= pGrafObj->GetGraphic().GetXGraphic();
1450         }
1451
1452         break;
1453     }
1454
1455     case OWN_ATTR_GRAFSTREAMURL:
1456     {
1457         const OUString  aStreamURL( static_cast<SdrGrafObj*>( GetSdrObject() )->GetGrafStreamURL() );
1458         if( !aStreamURL.isEmpty() )
1459             rValue <<= aStreamURL;
1460         break;
1461     }
1462
1463     case OWN_ATTR_GRAPHIC_URL:
1464     case OWN_ATTR_VALUE_GRAPHIC:
1465     {
1466         if (pProperty->nWID == OWN_ATTR_GRAPHIC_URL)
1467         {
1468             SAL_WARN("svx", "Getting Graphic by URL is not supported, getting it by value");
1469         }
1470
1471         Reference<graphic::XGraphic> xGraphic;
1472         auto pSdrGraphicObject = static_cast<SdrGrafObj*>(GetSdrObject());
1473         if (pSdrGraphicObject
1474             && pSdrGraphicObject->GetGraphicObject().GetType() != GraphicType::NONE)
1475             xGraphic = pSdrGraphicObject->GetGraphic().GetXGraphic();
1476         rValue <<= xGraphic;
1477         break;
1478     }
1479
1480     case OWN_ATTR_GRAPHIC_STREAM:
1481     {
1482         rValue <<= static_cast< SdrGrafObj* >( GetSdrObject() )->getInputStream();
1483         break;
1484     }
1485
1486     case OWN_ATTR_IS_SIGNATURELINE:
1487     {
1488         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLine();
1489         break;
1490     }
1491
1492     case OWN_ATTR_SIGNATURELINE_ID:
1493     {
1494         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineId();
1495         break;
1496     }
1497
1498     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_NAME:
1499     {
1500         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerName();
1501         break;
1502     }
1503
1504     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_TITLE:
1505     {
1506         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerTitle();
1507         break;
1508     }
1509
1510     case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_EMAIL:
1511     {
1512         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerEmail();
1513         break;
1514     }
1515
1516     case OWN_ATTR_SIGNATURELINE_SIGNING_INSTRUCTIONS:
1517     {
1518         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSigningInstructions();
1519         break;
1520     }
1521
1522     case OWN_ATTR_SIGNATURELINE_SHOW_SIGN_DATE:
1523     {
1524         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineShowSignDate();
1525         break;
1526     }
1527
1528     case OWN_ATTR_SIGNATURELINE_CAN_ADD_COMMENT:
1529     {
1530         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineCanAddComment();
1531         break;
1532     }
1533
1534     case OWN_ATTR_SIGNATURELINE_UNSIGNED_IMAGE:
1535     {
1536         Reference<graphic::XGraphic> xGraphic(
1537             static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineUnsignedGraphic());
1538         rValue <<= xGraphic;
1539         break;
1540     }
1541
1542     case OWN_ATTR_SIGNATURELINE_IS_SIGNED:
1543     {
1544         rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineSigned();
1545         break;
1546     }
1547
1548     case OWN_ATTR_OBJ_ISEMPTYPRESOBJ:
1549     {
1550         rValue <<= GetSdrObject()->IsEmptyPresObj();
1551         break;
1552     }
1553
1554     case OWN_ATTR_QRCODE:
1555     {
1556         css::drawing::BarCode* ptr = static_cast<SdrGrafObj*>(GetSdrObject())->getQrCode();
1557         if(ptr)
1558         {
1559             rValue <<= *ptr;
1560         }
1561         break;
1562     }
1563
1564     default:
1565         return SvxShapeText::getPropertyValueImpl(rName, pProperty,rValue);
1566     }
1567
1568     return true;
1569 }
1570
1571
1572 SvxShapeCaption::SvxShapeCaption(SdrObject* pObj)
1573 : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CAPTION), getSvxMapProvider().GetPropertySet(SVXMAP_CAPTION, SdrObject::GetGlobalDrawObjectItemPool()) )
1574 {
1575 }
1576
1577 SvxShapeCaption::~SvxShapeCaption() noexcept
1578 {
1579 }
1580
1581 SvxCustomShape::SvxCustomShape(SdrObject* pObj)
1582     : SvxShapeText( pObj, getSvxMapProvider().GetMap( SVXMAP_CUSTOMSHAPE ), getSvxMapProvider().GetPropertySet(SVXMAP_CUSTOMSHAPE, SdrObject::GetGlobalDrawObjectItemPool()) )
1583 {
1584 }
1585
1586 SvxCustomShape::~SvxCustomShape() noexcept
1587 {
1588 }
1589
1590 uno::Any SAL_CALL SvxCustomShape::queryInterface( const uno::Type & rType )
1591 {
1592     return SvxShapeText::queryInterface( rType );
1593 }
1594
1595 uno::Any SAL_CALL SvxCustomShape::queryAggregation( const uno::Type & rType )
1596 {
1597     css::uno::Any aReturn = SvxShapeText::queryAggregation( rType );
1598     if ( !aReturn.hasValue() )
1599         aReturn = ::cppu::queryInterface(rType, static_cast<drawing::XEnhancedCustomShapeDefaulter*>(this) );
1600     return aReturn;
1601 }
1602
1603 uno::Sequence< sal_Int8 > SAL_CALL SvxCustomShape::getImplementationId()
1604 {
1605     return css::uno::Sequence<sal_Int8>();
1606 }
1607
1608 // css::drawing::XShape
1609
1610
1611 awt::Point SAL_CALL SvxCustomShape::getPosition()
1612 {
1613     ::SolarMutexGuard aGuard;
1614     if ( HasSdrObject() )
1615     {
1616         SdrAShapeObjGeoData aCustomShapeGeoData;
1617         static_cast<SdrObjCustomShape*>(GetSdrObject())->SaveGeoData( aCustomShapeGeoData );
1618
1619         bool bMirroredX = false;
1620         bool bMirroredY = false;
1621
1622         if ( HasSdrObject() )
1623         {
1624             bMirroredX = static_cast<SdrObjCustomShape*>(GetSdrObject())->IsMirroredX();
1625             bMirroredY = static_cast<SdrObjCustomShape*>(GetSdrObject())->IsMirroredY();
1626         }
1627         // get aRect, this is the unrotated snaprect
1628         tools::Rectangle aRect(static_cast<SdrObjCustomShape*>(GetSdrObject())->GetLogicRect());
1629         tools::Rectangle aRectangle( aRect );
1630
1631         if ( bMirroredX || bMirroredY )
1632         {   // we have to retrieve the unmirrored rect
1633
1634             GeoStat aNewGeo(aCustomShapeGeoData.maGeo);
1635             if ( bMirroredX )
1636             {
1637                 tools::Polygon aPol( Rect2Poly( aRect, aNewGeo ) );
1638                 tools::Rectangle aBoundRect( aPol.GetBoundRect() );
1639
1640                 Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() );
1641                 Point aRef2( aRef1.X(), aRef1.Y() + 1000 );
1642                 sal_uInt16 i;
1643                 sal_uInt16 nPointCount=aPol.GetSize();
1644                 for (i=0; i<nPointCount; i++)
1645                 {
1646                     MirrorPoint(aPol[i],aRef1,aRef2);
1647                 }
1648                 // turn and move polygon
1649                 tools::Polygon aPol0(aPol);
1650                 aPol[0]=aPol0[1];
1651                 aPol[1]=aPol0[0];
1652                 aPol[2]=aPol0[3];
1653                 aPol[3]=aPol0[2];
1654                 aPol[4]=aPol0[1];
1655                 aRectangle = svx::polygonToRectangle(aPol, aNewGeo);
1656             }
1657             if ( bMirroredY )
1658             {
1659                 tools::Polygon aPol( Rect2Poly( aRectangle, aNewGeo ) );
1660                 tools::Rectangle aBoundRect( aPol.GetBoundRect() );
1661
1662                 Point aRef1( aBoundRect.Left(), ( aBoundRect.Top() + aBoundRect.Bottom() ) >> 1 );
1663                 Point aRef2( aRef1.X() + 1000, aRef1.Y() );
1664                 sal_uInt16 i;
1665                 sal_uInt16 nPointCount=aPol.GetSize();
1666                 for (i=0; i<nPointCount; i++)
1667                 {
1668                     MirrorPoint(aPol[i],aRef1,aRef2);
1669                 }
1670                 // turn and move polygon
1671                 tools::Polygon aPol0(aPol);
1672                 aPol[0]=aPol0[1];
1673                 aPol[1]=aPol0[0];
1674                 aPol[2]=aPol0[3];
1675                 aPol[3]=aPol0[2];
1676                 aPol[4]=aPol0[1];
1677                 aRectangle = svx::polygonToRectangle(aPol, aNewGeo);
1678             }
1679         }
1680         Point aPt( aRectangle.TopLeft() );
1681
1682         if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
1683             aPt -= GetSdrObject()->GetAnchorPos();
1684
1685         ForceMetricTo100th_mm(aPt);
1686         return css::awt::Point( aPt.X(), aPt.Y() );
1687     }
1688     else
1689         return SvxShape::getPosition();
1690 }
1691
1692
1693 void SAL_CALL SvxCustomShape::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
1694 {
1695     ::SolarMutexGuard aGuard;
1696
1697     SdrObject* pObject = GetSdrObject();
1698
1699     // tdf#98163 Use a custom slot to have filter code flush the UNO
1700     // API implementations of SdrObjCustomShape. Used e.g. by
1701     // ~SdXMLCustomShapeContext, see there for more information
1702     if("FlushCustomShapeUnoApiObjects" == aPropertyName)
1703     {
1704         SdrObjCustomShape* pTarget = dynamic_cast< SdrObjCustomShape* >(pObject);
1705         if(pTarget)
1706         {
1707             // Luckily, the object causing problems in tdf#93994 is not the
1708             // UNO API object, but the XCustomShapeEngine involved. This
1709             // object is on-demand replaceable and can be reset here. This
1710             // will free the involved EditEngine and VirtualDevice.
1711             pTarget->mxCustomShapeEngine.clear();
1712         }
1713         // since this case is only for the application cores
1714         // we should return from this function now
1715         return;
1716     }
1717
1718     bool bCustomShapeGeometry = pObject && aPropertyName == "CustomShapeGeometry";
1719
1720     bool bMirroredX = false;
1721     bool bMirroredY = false;
1722
1723     if ( bCustomShapeGeometry )
1724     {
1725         bMirroredX = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredX();
1726         bMirroredY = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredY();
1727     }
1728
1729     SvxShape::setPropertyValue( aPropertyName, aValue );
1730
1731     if ( !bCustomShapeGeometry )
1732         return;
1733
1734     static_cast<SdrObjCustomShape*>(pObject)->MergeDefaultAttributes();
1735     tools::Rectangle aRect( pObject->GetSnapRect() );
1736
1737     // #i38892#
1738     bool bNeedsMirrorX = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredX() != bMirroredX;
1739     bool bNeedsMirrorY = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredY() != bMirroredY;
1740
1741     std::unique_ptr< SdrGluePointList > pListCopy;
1742     if( bNeedsMirrorX || bNeedsMirrorY )
1743     {
1744         const SdrGluePointList* pList = pObject->GetGluePointList();
1745         if( pList )
1746             pListCopy.reset( new SdrGluePointList(*pList) );
1747     }
1748
1749     if ( bNeedsMirrorX )
1750     {
1751         Point aTop( ( aRect.Left() + aRect.Right() ) >> 1, aRect.Top() );
1752         Point aBottom( aTop.X(), aTop.Y() + 1000 );
1753         pObject->NbcMirror( aTop, aBottom );
1754         // NbcMirroring is flipping the current mirror state,
1755         // so we have to set the correct state again
1756         static_cast<SdrObjCustomShape*>(pObject)->SetMirroredX( !bMirroredX );
1757     }
1758     if ( bNeedsMirrorY )
1759     {
1760         Point aLeft( aRect.Left(), ( aRect.Top() + aRect.Bottom() ) >> 1 );
1761         Point aRight( aLeft.X() + 1000, aLeft.Y() );
1762         pObject->NbcMirror( aLeft, aRight );
1763         // NbcMirroring is flipping the current mirror state,
1764         // so we have to set the correct state again
1765         static_cast<SdrObjCustomShape*>(pObject)->SetMirroredY( !bMirroredY );
1766     }
1767
1768     if( pListCopy )
1769     {
1770         SdrGluePointList* pNewList = const_cast< SdrGluePointList* >( pObject->GetGluePointList() );
1771         if(pNewList)
1772             *pNewList = *pListCopy;
1773     }
1774 }
1775
1776 bool SvxCustomShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
1777 {
1778     switch( pProperty->nWID )
1779     {
1780     case SDRATTR_ROTATEANGLE:
1781     {
1782         double fAngle = static_cast<SdrObjCustomShape*>(GetSdrObject())->GetObjectRotation();
1783         fAngle *= 100;
1784         rValue <<= static_cast<sal_Int32>(fAngle);
1785         return true;
1786     }
1787     default:
1788         return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
1789     }
1790 }
1791
1792 void SvxCustomShape::createCustomShapeDefaults( const OUString& rValueType )
1793 {
1794     if (!HasSdrObject())
1795     {
1796         OSL_FAIL("could not create Custom Shape Defaults!");
1797         return;
1798     }
1799
1800     static_cast<SdrObjCustomShape*>(GetSdrObject())->MergeDefaultAttributes( &rValueType );
1801 }
1802
1803 SvxShapeGroupAnyD::SvxShapeGroupAnyD( SdrObject* pObject, std::span<const SfxItemPropertyMapEntry> pEntries, const SvxItemPropertySet* pPropertySet )
1804     : SvxShape(pObject, pEntries, pPropertySet)
1805 {}
1806
1807 SvxShapeGroupAnyD::~SvxShapeGroupAnyD() noexcept
1808 {}
1809
1810 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */