svx/source/unodraw/unoshape.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 <cppuhelper/supportsservice.hxx>
  21 #include <com/sun/star/awt/XBitmap.hpp>
  22 #include <com/sun/star/awt/Rectangle.hpp>
  23 #include <com/sun/star/drawing/CircleKind.hpp>
  24 #include <com/sun/star/lang/NoSupportException.hpp>
  25 #include <vcl/svapp.hxx>
  26 #include <svl/itemprop.hxx>
  27 #include <o3tl/any.hxx>
  28 #include <osl/mutex.hxx>
  29 #include <editeng/unotext.hxx>
  30 #include <svx/svdobj.hxx>
  31 #include <svx/svdoole2.hxx>
  32 #include <svx/shapepropertynotifier.hxx>
  33 #include <comphelper/interfacecontainer3.hxx>
  34 #include <comphelper/scopeguard.hxx>
  35 #include <comphelper/servicehelper.hxx>
  36 #include <toolkit/helper/vclunohelper.hxx>
  37 #include <vcl/gfxlink.hxx>
  38 #include <vcl/virdev.hxx>
  39 #include <svx/sdangitm.hxx>
  40 #include <svx/svdlayer.hxx>
  41 #include <svx/svdopage.hxx>
  42 #include <svx/xflbstit.hxx>
  43 #include <svx/xflbmtit.hxx>
  44 #include <svx/xlnstit.hxx>
  45 #include <svx/xlnedit.hxx>
  46 #include <svx/xlnclit.hxx>
  47 #include <svx/svdmodel.hxx>
  48 #include <svx/svdobjkind.hxx>
  49 #include <svx/unopage.hxx>
  50 #include <svx/unoshape.hxx>
  51 #include <svx/unoshtxt.hxx>
  52 #include <svx/svdpage.hxx>
  53 #include <svx/unoshprp.hxx>
  54 #include <svx/svdograf.hxx>
  55 #include <svx/unoapi.hxx>
  56 #include <svx/svdomeas.hxx>
  57 #include <svx/svdpool.hxx>
  58 #include <comphelper/diagnose_ex.hxx>
  59 #include <tools/stream.hxx>
  60 #include <tools/gen.hxx>
  61 #include <tools/UnitConversion.hxx>
  62 #include <svx/svdoedge.hxx>
  63 #include <svx/svdocapt.hxx>
  64 #include <svx/obj3d.hxx>
  65 #include <svx/xflftrit.hxx>
  66 #include <svx/xtable.hxx>
  67 #include <svx/xbtmpit.hxx>
  68 #include <svx/xfillit0.hxx>
  69 #include <svx/xflgrit.hxx>
  70 #include <svx/xflhtit.hxx>
  71 #include <svx/xlineit0.hxx>
  72 #include <svx/xlndsit.hxx>
  73 #include <svx/unomaster.hxx>
  74 #include <basegfx/matrix/b2dhommatrix.hxx>
  75 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  76 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  77 #include "gluepts.hxx"
  78 #include "shapeimpl.hxx"
  79 #include <sal/log.hxx>
  80
  81 #include <svx/lathe3d.hxx>
  82 #include <extrud3d.hxx>
  83 #include <svx/sdr/contact/viewcontact.hxx>
  84 #include <drawinglayer/converters.hxx>
  85 #include <drawinglayer/geometry/viewinformation2d.hxx>
  86 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  87
  88 #include <vcl/gdimtf.hxx>
  89 #include <vcl/wmf.hxx>
  90 #include <svx/sdtfsitm.hxx>
  91 #include <svx/svdopath.hxx>
  92 #include <svx/SvxXTextColumns.hxx>
  93 #include <svx/xflclit.hxx>
  94 #include <editeng/frmdiritem.hxx>
  95
  96 #include <memory>
  97 #include <optional>
  98 #include <vector>
  99 #include <iostream>
 100
 101 #include <bitmaps.hlst>
 102
 103 using namespace ::osl;
 104 using namespace ::cppu;
 105 using namespace ::com::sun::star;
 106 using namespace ::com::sun::star::uno;
 107 using namespace ::com::sun::star::lang;
 108 using namespace ::com::sun::star::container;
 109 using svx::PropertyValueProvider;
 110
 111 class GDIMetaFile;
 112
 113 struct SvxShapeImpl
 114 {
 115     std::optional<SfxItemSet> mxItemSet;
 116     SdrObjKind      mnObjId;
 117     SvxShapeMaster* mpMaster;
 118     bool            mbDisposing;
 119
 120     /** CL, OD 2005-07-19 #i52126# - this is initially 0 and set when
 121      *  a SvxShape::Create() call is executed. It is then set to the created
 122      *  SdrObject so a multiple call to SvxShape::Create() with same SdrObject
 123      *  is prohibited.
 124      */
 125     ::unotools::WeakReference< SdrObject > mxCreatedObj;
 126
 127     // for xComponent
 128     ::comphelper::OInterfaceContainerHelper4<css::lang::XEventListener> maDisposeListeners;
 129     svx::PropertyChangeNotifier       maPropertyNotifier;
 130
 131     SvxShapeImpl( SvxShape& _rAntiImpl )
 132         :mnObjId( SdrObjKind::NONE )
 133         ,mpMaster( nullptr )
 134         ,mbDisposing( false )
 135         ,maPropertyNotifier( _rAntiImpl )
 136     {
 137     }
 138 };
 139
 140 namespace {
 141
 142 class ShapePositionProvider : public PropertyValueProvider
 143 {
 144 public:
 145     static constexpr OUStringLiteral sPosition = u"Position";
 146     explicit ShapePositionProvider( SvxShape& _shape )
 147         :PropertyValueProvider( _shape, sPosition )
 148     {
 149     }
 150
 151 protected:
 152     virtual void getCurrentValue( Any& _out_rCurrentValue ) const override
 153     {
 154         _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getPosition();
 155     }
 156 };
 157
 158
 159 class ShapeSizeProvider : public PropertyValueProvider
 160 {
 161 public:
 162     static constexpr OUStringLiteral sSize = u"Size";
 163     explicit ShapeSizeProvider( SvxShape& _shape )
 164         :PropertyValueProvider( _shape, sSize )
 165     {
 166     }
 167
 168 protected:
 169     virtual void getCurrentValue( Any& _out_rCurrentValue ) const override
 170     {
 171         _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getSize();
 172     }
 173 };
 174
 175 /// Calculates what scaling factor will be used for autofit text scaling of this shape.
 176 double GetTextFitToSizeScale(SdrObject* pObject)
 177 {
 178     SdrTextObj* pTextObj = DynCastSdrTextObj(pObject);
 179     if (!pTextObj)
 180     {
 181         return 0;
 182     }
 183
 184     const SfxItemSet& rTextObjSet = pTextObj->GetMergedItemSet();
 185     if (rTextObjSet.GetItem<SdrTextFitToSizeTypeItem>(SDRATTR_TEXT_FITTOSIZE)->GetValue()
 186         != drawing::TextFitToSizeType_AUTOFIT)
 187     {
 188         return 0;
 189     }
 190
 191     return pTextObj->GetFontScale();
 192 }
 193 }
 194
 195 SvxShape::SvxShape( SdrObject* pObject )
 196 :   maSize(100,100)
 197 ,   mpImpl( new SvxShapeImpl( *this ) )
 198 ,   mbIsMultiPropertyCall(false)
 199 ,   mpPropSet(getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
 200 ,   maPropMapEntries(getSvxMapProvider().GetMap(SVXMAP_SHAPE))
 201 ,   mxSdrObject(pObject)
 202 ,   mnLockCount(0)
 203 {
 204     impl_construct();
 205 }
 206
 207
 208 SvxShape::SvxShape( SdrObject* pObject, o3tl::span<const SfxItemPropertyMapEntry> pEntries, const SvxItemPropertySet* pPropertySet )
 209 :   maSize(100,100)
 210 ,   mpImpl( new SvxShapeImpl( *this ) )
 211 ,   mbIsMultiPropertyCall(false)
 212 ,   mpPropSet(pPropertySet)
 213 ,   maPropMapEntries(pEntries)
 214 ,   mxSdrObject(pObject)
 215 ,   mnLockCount(0)
 216 {
 217     impl_construct();
 218 }
 219
 220
 221 SvxShape::~SvxShape() noexcept
 222 {
 223     ::SolarMutexGuard aGuard;
 224
 225     DBG_ASSERT( mnLockCount == 0, "Locked shape was disposed!" );
 226
 227     if ( mpImpl->mpMaster )
 228         mpImpl->mpMaster->dispose();
 229
 230     if ( mxSdrObject )
 231     {
 232         EndListening(mxSdrObject->getSdrModelFromSdrObject());
 233         mxSdrObject->setUnoShape(nullptr);
 234         mxSdrObject.clear();
 235     }
 236
 237     EndListeningAll(); // call explicitly within SolarMutexGuard
 238 }
 239
 240
 241 void SvxShape::InvalidateSdrObject()
 242 {
 243     if(mxSdrObject)
 244     {
 245         EndListening(mxSdrObject->getSdrModelFromSdrObject());
 246         mxSdrObject.clear();
 247     }
 248 };
 249
 250 void SvxShape::setShapeKind( SdrObjKind nKind )
 251 {
 252     mpImpl->mnObjId = nKind;
 253 }
 254
 255
 256 SdrObjKind SvxShape::getShapeKind() const
 257 {
 258     return mpImpl->mnObjId;
 259 }
 260
 261
 262 void SvxShape::setMaster( SvxShapeMaster* pMaster )
 263 {
 264     mpImpl->mpMaster = pMaster;
 265 }
 266
 267
 268 uno::Any SAL_CALL SvxShape::queryAggregation( const uno::Type& rType )
 269 {
 270     if( mpImpl->mpMaster )
 271     {
 272         uno::Any aAny;
 273         if( mpImpl->mpMaster->queryAggregation( rType, aAny ) )
 274             return aAny;
 275     }
 276
 277     return SvxShape_UnoImplHelper::queryAggregation(rType);
 278 }
 279
 280 const css::uno::Sequence< sal_Int8 > & SvxShape::getUnoTunnelId() noexcept
 281 {
 282     static const comphelper::UnoIdInit theSvxShapeUnoTunnelId;
 283     return theSvxShapeUnoTunnelId.getSeq();
 284 }
 285
 286 sal_Int64 SAL_CALL SvxShape::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
 287 {
 288     return comphelper::getSomethingImpl(rId, this);
 289 }
 290
 291
 292 void SvxShape::notifyPropertyChange(svx::ShapePropertyProviderId eProp)
 293 {
 294     std::unique_lock g(m_aMutex);
 295     mpImpl->maPropertyNotifier.notifyPropertyChange(g, eProp);
 296 }
 297
 298 void SvxShape::registerProvider(svx::ShapePropertyProviderId eProp, std::unique_ptr<svx::PropertyValueProvider> provider)
 299 {
 300     mpImpl->maPropertyNotifier.registerProvider(eProp, std::move(provider));
 301 }
 302
 303 void SvxShape::impl_construct()
 304 {
 305     mpImpl->maPropertyNotifier.registerProvider( svx::ShapePropertyProviderId::Position,
 306         std::make_unique<ShapePositionProvider>( *this ) );
 307     mpImpl->maPropertyNotifier.registerProvider( svx::ShapePropertyProviderId::Size,
 308         std::make_unique<ShapeSizeProvider>( *this ) );
 309
 310     if ( HasSdrObject() )
 311     {
 312         StartListening(GetSdrObject()->getSdrModelFromSdrObject());
 313         impl_initFromSdrObject();
 314     }
 315 }
 316
 317
 318 void SvxShape::impl_initFromSdrObject()
 319 {
 320     DBG_TESTSOLARMUTEX();
 321     OSL_PRECOND( HasSdrObject(), "SvxShape::impl_initFromSdrObject: not to be called without SdrObject!" );
 322     if ( !HasSdrObject() )
 323         return;
 324
 325     osl_atomic_increment( &m_refCount );
 326     {
 327         GetSdrObject()->setUnoShape(this);
 328     }
 329     osl_atomic_decrement( &m_refCount );
 330
 331     // #i40944#
 332     // Do not simply return when no model but do the type corrections
 333     // following below.
 334     const SdrInventor nInventor = GetSdrObject()->GetObjInventor();
 335
 336     // is it one of ours (svx) ?
 337     if( !(nInventor == SdrInventor::Default || nInventor == SdrInventor::E3d || nInventor == SdrInventor::FmForm) )
 338         return;
 339
 340     if(nInventor == SdrInventor::FmForm)
 341     {
 342         mpImpl->mnObjId = SdrObjKind::UNO;
 343     }
 344     else
 345     {
 346         mpImpl->mnObjId = GetSdrObject()->GetObjIdentifier();
 347     }
 348
 349     switch(mpImpl->mnObjId)
 350     {
 351     case SdrObjKind::CircleCut:          // segment of circle
 352     case SdrObjKind::CircleArc:          // arc of circle
 353     case SdrObjKind::CircleSection:          // sector
 354         mpImpl->mnObjId = SdrObjKind::CircleOrEllipse;
 355         break;
 356     default: ;
 357     }
 358 }
 359
 360
 361 void SvxShape::Create( SdrObject* pNewObj, SvxDrawPage* /*pNewPage*/ )
 362 {
 363     DBG_TESTSOLARMUTEX();
 364
 365     assert( pNewObj && "SvxShape::Create: invalid new object!" );
 366     if ( !pNewObj )
 367         return;
 368
 369     rtl::Reference<SdrObject> pCreatedObj = mpImpl->mxCreatedObj.get();
 370     assert( ( !pCreatedObj || ( pCreatedObj == pNewObj ) ) &&
 371         "SvxShape::Create: the same shape used for two different objects?! Strange ..." );
 372
 373     // Correct condition (#i52126#)
 374     if ( pCreatedObj == pNewObj )
 375         return;
 376
 377     // Correct condition (#i52126#)
 378     mpImpl->mxCreatedObj = pNewObj;
 379
 380     if( HasSdrObject() )
 381     {
 382         EndListening( GetSdrObject()->getSdrModelFromSdrObject() );
 383     }
 384
 385     mxSdrObject = pNewObj;
 386
 387     if( HasSdrObject() )
 388     {
 389         StartListening( GetSdrObject()->getSdrModelFromSdrObject() );
 390     }
 391
 392     OSL_ENSURE( !mbIsMultiPropertyCall, "SvxShape::Create: hmm?" );
 393         // this was previously set in impl_initFromSdrObject, but I think it was superfluous
 394         // (it definitely was in the other context where it was called, but I strongly suppose
 395         // it was also superfluous when called from here)
 396     impl_initFromSdrObject();
 397
 398     ObtainSettingsFromPropertySet( *mpPropSet );
 399
 400     // save user call
 401     SdrObjUserCall* pUser = GetSdrObject()->GetUserCall();
 402     GetSdrObject()->SetUserCall(nullptr);
 403
 404     setPosition( maPosition );
 405     setSize( maSize );
 406
 407     // restore user call after we set the initial size
 408     GetSdrObject()->SetUserCall( pUser );
 409
 410     // if this shape was already named, use this name
 411     if( !maShapeName.isEmpty() )
 412     {
 413         GetSdrObject()->SetName( maShapeName );
 414         maShapeName.clear();
 415     }
 416 }
 417
 418 void SvxShape::ForceMetricToItemPoolMetric(Pair& rPoint) const noexcept
 419 {
 420     DBG_TESTSOLARMUTEX();
 421     if(!HasSdrObject())
 422         return;
 423
 424     MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0));
 425     if(eMapUnit == MapUnit::Map100thMM)
 426         return;
 427
 428     if (const auto eTo = MapToO3tlLength(eMapUnit); eTo != o3tl::Length::invalid)
 429     {
 430         rPoint.A() = o3tl::convert(rPoint.A(), o3tl::Length::mm100, eTo);
 431         rPoint.B() = o3tl::convert(rPoint.B(), o3tl::Length::mm100, eTo);
 432     }
 433     else
 434     {
 435         OSL_FAIL("AW: Missing unit translation to PoolMetric!");
 436     }
 437 }
 438
 439 void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon& rPolyPolygon) const noexcept
 440 {
 441     DBG_TESTSOLARMUTEX();
 442     if(!HasSdrObject())
 443         return;
 444
 445     GetSdrObject()->ForceMetricToItemPoolMetric(rPolyPolygon);
 446 }
 447
 448 void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DHomMatrix& rB2DHomMatrix) const noexcept
 449 {
 450     DBG_TESTSOLARMUTEX();
 451     if(!HasSdrObject())
 452         return;
 453
 454     MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0));
 455     if(eMapUnit == MapUnit::Map100thMM)
 456         return;
 457
 458     if (const auto eTo = MapToO3tlLength(eMapUnit); eTo != o3tl::Length::invalid)
 459     {
 460         const double fConvert(o3tl::convert(1.0, o3tl::Length::mm100, eTo));
 461         const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix);
 462         rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
 463             aDecomposedTransform.getScale() * fConvert,
 464             aDecomposedTransform.getShearX(),
 465             aDecomposedTransform.getRotate(),
 466             aDecomposedTransform.getTranslate() * fConvert);
 467     }
 468     else
 469     {
 470         OSL_FAIL("Missing unit translation to PoolMetric!");
 471     }
 472 }
 473
 474 void SvxShape::ForceMetricTo100th_mm(Pair& rPoint) const noexcept
 475 {
 476     DBG_TESTSOLARMUTEX();
 477     if(!HasSdrObject())
 478         return;
 479
 480     MapUnit eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
 481     if(eMapUnit == MapUnit::Map100thMM)
 482         return;
 483
 484     if (const auto eFrom = MapToO3tlLength(eMapUnit); eFrom != o3tl::Length::invalid)
 485     {
 486         rPoint.A() = o3tl::convert(rPoint.A(), eFrom, o3tl::Length::mm100);
 487         rPoint.B() = o3tl::convert(rPoint.B(), eFrom, o3tl::Length::mm100);
 488     }
 489     else
 490     {
 491         OSL_FAIL("AW: Missing unit translation to 100th mm!");
 492     }
 493 }
 494
 495 void SvxShape::ForceMetricTo100th_mm(basegfx::B2DPolyPolygon& rPolyPolygon) const noexcept
 496 {
 497     DBG_TESTSOLARMUTEX();
 498     if(!HasSdrObject())
 499         return;
 500
 501     MapUnit eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
 502     if(eMapUnit == MapUnit::Map100thMM)
 503         return;
 504
 505     if (const auto eFrom = MapToO3tlLength(eMapUnit); eFrom != o3tl::Length::invalid)
 506     {
 507         const double fConvert(o3tl::convert(1.0, eFrom, o3tl::Length::mm100));
 508         rPolyPolygon.transform(basegfx::utils::createScaleB2DHomMatrix(fConvert, fConvert));
 509     }
 510     else
 511     {
 512         OSL_FAIL("Missing unit translation to 100th mm!");
 513     }
 514 }
 515
 516 void SvxShape::ForceMetricTo100th_mm(basegfx::B2DHomMatrix& rB2DHomMatrix) const noexcept
 517 {
 518     DBG_TESTSOLARMUTEX();
 519     if(!HasSdrObject())
 520         return;
 521
 522     MapUnit eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
 523     if(eMapUnit == MapUnit::Map100thMM)
 524         return;
 525
 526     if (const auto eFrom = MapToO3tlLength(eMapUnit); eFrom != o3tl::Length::invalid)
 527     {
 528         const double fConvert(o3tl::convert(1.0, eFrom, o3tl::Length::mm100));
 529         const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix);
 530         rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
 531             aDecomposedTransform.getScale() * fConvert,
 532             aDecomposedTransform.getShearX(),
 533             aDecomposedTransform.getRotate(),
 534             aDecomposedTransform.getTranslate() * fConvert);
 535     }
 536     else
 537     {
 538         OSL_FAIL("Missing unit translation to 100th mm!");
 539     }
 540 }
 541
 542 static void SvxItemPropertySet_ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet, SvxItemPropertySetUsrAnys& rAnys,
 543   SfxItemSet& rSet, const uno::Reference< beans::XPropertySet >& xSet, const SfxItemPropertyMap* pMap )
 544 {
 545     if(!rAnys.AreThereOwnUsrAnys())
 546         return;
 547
 548     const SfxItemPropertyMap& rSrc = rPropSet.getPropertyMap();
 549
 550     for(const SfxItemPropertyMapEntry* pSrcProp : rSrc.getPropertyEntries())
 551     {
 552         const sal_uInt16 nWID = pSrcProp->nWID;
 553         if(SfxItemPool::IsWhich(nWID)
 554                 && (nWID < OWN_ATTR_VALUE_START || nWID > OWN_ATTR_VALUE_END)
 555                 && rAnys.GetUsrAnyForID(*pSrcProp))
 556             rSet.Put(rSet.GetPool()->GetDefaultItem(nWID));
 557     }
 558
 559     for(const SfxItemPropertyMapEntry* pSrcProp : rSrc.getPropertyEntries())
 560     {
 561         if(pSrcProp->nWID)
 562         {
 563             uno::Any* pUsrAny = rAnys.GetUsrAnyForID(*pSrcProp);
 564             if(pUsrAny)
 565             {
 566                 // search for equivalent entry in pDst
 567                 const SfxItemPropertyMapEntry* pEntry = pMap->getByName( pSrcProp->aName );
 568                 if(pEntry)
 569                 {
 570                     // entry found
 571                     if(pEntry->nWID >= OWN_ATTR_VALUE_START && pEntry->nWID <= OWN_ATTR_VALUE_END)
 572                     {
 573                         // special ID in PropertySet, can only be set
 574                         // directly at the object
 575                         xSet->setPropertyValue( pSrcProp->aName, *pUsrAny);
 576                     }
 577                     else
 578                     {
 579                         SvxItemPropertySet_setPropertyValue(pEntry, *pUsrAny, rSet);
 580                     }
 581                 }
 582             }
 583         }
 584     }
 585     rAnys.ClearAllUsrAny();
 586 }
 587
 588
 589 void SvxShape::ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet)
 590 {
 591     DBG_TESTSOLARMUTEX();
 592     if(HasSdrObject() && maUrsAnys.AreThereOwnUsrAnys())
 593     {
 594         SfxItemSetFixed<SDRATTR_START, SDRATTR_END> aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool() );
 595         Reference< beans::XPropertySet > xShape(this);
 596         SvxItemPropertySet_ObtainSettingsFromPropertySet(rPropSet, maUrsAnys, aSet, xShape, &mpPropSet->getPropertyMap() );
 597
 598         GetSdrObject()->SetMergedItemSetAndBroadcast(aSet);
 599
 600         GetSdrObject()->ApplyNotPersistAttr( aSet );
 601     }
 602 }
 603
 604 uno::Any SvxShape::GetBitmap( bool bMetaFile /* = false */ ) const
 605 {
 606     DBG_TESTSOLARMUTEX();
 607     uno::Any aAny;
 608
 609     if(!HasSdrObject() || nullptr == GetSdrObject()->getSdrPageFromSdrObject())
 610     {
 611         return aAny;
 612     }
 613
 614     // tdf#118662 Emulate old behaviour of XclObjComment (see there)
 615     const SdrCaptionObj* pSdrCaptionObj(dynamic_cast<SdrCaptionObj*>(GetSdrObject()));
 616     if(nullptr != pSdrCaptionObj && pSdrCaptionObj->isSuppressGetBitmap())
 617     {
 618         return aAny;
 619     }
 620
 621     // tdf#119180 If we do not ask for Metafile and we access a SdrGrafObj,
 622     // and content exists and is a Bitmap, take the shortcut.
 623     // Do *not* do this for Metafile - as can be seen, requested in that case
 624     // is a byte-sequence of a saved WMF format file (see below)
 625     if(!bMetaFile)
 626     {
 627         const SdrGrafObj* pSdrGrafObj(dynamic_cast<SdrGrafObj*>(GetSdrObject()));
 628
 629         if(nullptr != pSdrGrafObj)
 630         {
 631             const Graphic& rGraphic(pSdrGrafObj->GetGraphic());
 632
 633             if(GraphicType::Bitmap == rGraphic.GetType())
 634             {
 635                 Reference< awt::XBitmap > xBmp( rGraphic.GetXGraphic(), UNO_QUERY );
 636                 aAny <<= xBmp;
 637
 638                 return aAny;
 639             }
 640         }
 641     }
 642
 643     // tdf#118662 instead of creating an E3dView instance every time to paint
 644     // a single SdrObject, use the existing SdrObject::SingleObjectPainter to
 645     // use less resources and runtime
 646     if(bMetaFile)
 647     {
 648         ScopedVclPtrInstance< VirtualDevice > pVDev;
 649         const tools::Rectangle aBoundRect(GetSdrObject()->GetCurrentBoundRect());
 650         GDIMetaFile aMtf;
 651
 652         pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));
 653         pVDev->EnableOutput(false);
 654         aMtf.Record(pVDev);
 655         GetSdrObject()->SingleObjectPainter(*pVDev);
 656         aMtf.Stop();
 657         aMtf.WindStart();
 658         aMtf.Move(-aBoundRect.Left(), -aBoundRect.Top());
 659         aMtf.SetPrefMapMode(MapMode(MapUnit::Map100thMM));
 660         aMtf.SetPrefSize(aBoundRect.GetSize());
 661
 662         SvMemoryStream aDestStrm(65535, 65535);
 663
 664         ConvertGDIMetaFileToWMF(
 665             aMtf,
 666             aDestStrm,
 667             nullptr,
 668             false);
 669
 670         const uno::Sequence<sal_Int8> aSeq(
 671             static_cast< const sal_Int8* >(aDestStrm.GetData()),
 672             aDestStrm.GetEndOfData());
 673
 674         aAny <<= aSeq;
 675     }
 676     else
 677     {
 678         drawinglayer::primitive2d::Primitive2DContainer xPrimitives;
 679         GetSdrObject()->GetViewContact().getViewIndependentPrimitive2DContainer(xPrimitives);
 680
 681         if(!xPrimitives.empty())
 682         {
 683             const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 684             basegfx::B2DRange aRange(
 685                 xPrimitives.getB2DRange(aViewInformation2D));
 686
 687             if(!aRange.isEmpty())
 688             {
 689                 const MapUnit aSourceMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetScaleUnit());
 690
 691                 if(MapUnit::Map100thMM != aSourceMapUnit)
 692                 {
 693                     // tdf#119180 This is UNO API and thus works in 100th_mm,
 694                     // so if the MapMode from the used SdrModel is *not* equal
 695                     // to Map100thMM we need to embed the primitives to an adapting
 696                     // homogen transformation for correct values
 697                     const basegfx::B2DHomMatrix aMapTransform(
 698                         OutputDevice::LogicToLogic(
 699                             MapMode(aSourceMapUnit),
 700                             MapMode(MapUnit::Map100thMM)));
 701
 702                     // Embed primitives to get them in 100th mm
 703                     drawinglayer::primitive2d::Primitive2DReference xEmbedRef(
 704                         new drawinglayer::primitive2d::TransformPrimitive2D(
 705                             aMapTransform,
 706                             std::move(xPrimitives)));
 707
 708                     xPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xEmbedRef };
 709
 710                     // Update basegfx::B2DRange aRange, too. Here we have the
 711                     // choice of transforming the existing value or get newly by
 712                     // again using 'xPrimitives.getB2DRange(aViewInformation2D)'
 713                     aRange.transform(aMapTransform);
 714                 }
 715
 716                 const BitmapEx aBmp(
 717                     drawinglayer::convertPrimitive2DContainerToBitmapEx(
 718                         std::move(xPrimitives),
 719                         aRange));
 720
 721                 Graphic aGraph(aBmp);
 722
 723                 aGraph.SetPrefSize(aBmp.GetPrefSize());
 724                 aGraph.SetPrefMapMode(aBmp.GetPrefMapMode());
 725
 726                 Reference< awt::XBitmap > xBmp( aGraph.GetXGraphic(), UNO_QUERY );
 727                 aAny <<= xBmp;
 728             }
 729         }
 730     }
 731
 732     return aAny;
 733 }
 734
 735 uno::Sequence< uno::Type > SAL_CALL SvxShape::getTypes()
 736 {
 737     if( mpImpl->mpMaster )
 738     {
 739         return mpImpl->mpMaster->getTypes();
 740     }
 741     else
 742     {
 743         return _getTypes();
 744     }
 745 }
 746
 747
 748 uno::Sequence< uno::Type > const & SvxShape::_getTypes()
 749 {
 750     switch( mpImpl->mnObjId )
 751     {
 752     // shapes without text
 753     case SdrObjKind::Page:
 754     case SdrObjKind::OLEPluginFrame:
 755     case SdrObjKind::OLE2Plugin:
 756     case SdrObjKind::OLE2Applet:
 757     case SdrObjKind::E3D_Cube:
 758     case SdrObjKind::E3D_Sphere:
 759     case SdrObjKind::E3D_Lathe:
 760     case SdrObjKind::E3D_Extrusion:
 761     case SdrObjKind::E3D_Polygon:
 762     case SdrObjKind::Media:
 763     case SdrObjKind::Table:
 764         {
 765             static uno::Sequence<uno::Type> aTypeSequence{
 766                 cppu::UnoType<drawing::XShape>::get(),
 767                 cppu::UnoType<lang::XComponent>::get(),
 768                 cppu::UnoType<beans::XPropertySet>::get(),
 769                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 770                 cppu::UnoType<beans::XPropertyState>::get(),
 771                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 772                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 773                 cppu::UnoType<container::XChild>::get(),
 774                 cppu::UnoType<lang::XServiceInfo>::get(),
 775                 cppu::UnoType<lang::XTypeProvider>::get(),
 776                 cppu::UnoType<lang::XUnoTunnel>::get(),
 777                 cppu::UnoType<container::XNamed>::get(),
 778             };
 779
 780             return aTypeSequence;
 781         }
 782     // group shape
 783     case SdrObjKind::Group:
 784         {
 785             static uno::Sequence<uno::Type> aTypeSequence{
 786                 cppu::UnoType<drawing::XShape>::get(),
 787                 cppu::UnoType<lang::XComponent>::get(),
 788                 cppu::UnoType<beans::XPropertySet>::get(),
 789                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 790                 cppu::UnoType<beans::XPropertyState>::get(),
 791                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 792                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 793                 cppu::UnoType<container::XChild>::get(),
 794                 cppu::UnoType<lang::XServiceInfo>::get(),
 795                 cppu::UnoType<lang::XTypeProvider>::get(),
 796                 cppu::UnoType<lang::XUnoTunnel>::get(),
 797                 cppu::UnoType<container::XNamed>::get(),
 798                 cppu::UnoType<drawing::XShapes>::get(),
 799                 cppu::UnoType<drawing::XShapeGroup>::get(),
 800             };
 801
 802             return aTypeSequence;
 803         }
 804     // connector shape
 805     case SdrObjKind::Edge:
 806         {
 807             static uno::Sequence<uno::Type> aTypeSequence{
 808                 cppu::UnoType<drawing::XShape>::get(),
 809                 cppu::UnoType<lang::XComponent>::get(),
 810                 cppu::UnoType<beans::XPropertySet>::get(),
 811                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 812                 cppu::UnoType<beans::XPropertyState>::get(),
 813                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 814                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 815                 cppu::UnoType<container::XChild>::get(),
 816                 cppu::UnoType<lang::XServiceInfo>::get(),
 817                 cppu::UnoType<lang::XTypeProvider>::get(),
 818                 cppu::UnoType<lang::XUnoTunnel>::get(),
 819                 cppu::UnoType<container::XNamed>::get(),
 820                 cppu::UnoType<drawing::XConnectorShape>::get(),
 821                 // from SvxUnoTextBase::getTypes()
 822                 cppu::UnoType<text::XTextAppend>::get(),
 823                 cppu::UnoType<text::XTextCopy>::get(),
 824                 cppu::UnoType<container::XEnumerationAccess>::get(),
 825                 cppu::UnoType<text::XTextRangeMover>::get(),
 826             };
 827
 828             return aTypeSequence;
 829         }
 830     // control shape
 831     case SdrObjKind::UNO:
 832         {
 833             static uno::Sequence<uno::Type> aTypeSequence{
 834                 cppu::UnoType<drawing::XShape>::get(),
 835                 cppu::UnoType<lang::XComponent>::get(),
 836                 cppu::UnoType<beans::XPropertySet>::get(),
 837                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 838                 cppu::UnoType<beans::XPropertyState>::get(),
 839                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 840                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 841                 cppu::UnoType<container::XChild>::get(),
 842                 cppu::UnoType<lang::XServiceInfo>::get(),
 843                 cppu::UnoType<lang::XTypeProvider>::get(),
 844                 cppu::UnoType<lang::XUnoTunnel>::get(),
 845                 cppu::UnoType<container::XNamed>::get(),
 846                 cppu::UnoType<drawing::XControlShape>::get(),
 847             };
 848
 849             return aTypeSequence;
 850         }
 851     // 3d scene shape
 852     case SdrObjKind::E3D_Scene:
 853         {
 854             static uno::Sequence<uno::Type> aTypeSequence{
 855                 cppu::UnoType<drawing::XShape>::get(),
 856                 cppu::UnoType<lang::XComponent>::get(),
 857                 cppu::UnoType<beans::XPropertySet>::get(),
 858                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 859                 cppu::UnoType<beans::XPropertyState>::get(),
 860                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 861                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 862                 cppu::UnoType<container::XChild>::get(),
 863                 cppu::UnoType<lang::XServiceInfo>::get(),
 864                 cppu::UnoType<lang::XTypeProvider>::get(),
 865                 cppu::UnoType<lang::XUnoTunnel>::get(),
 866                 cppu::UnoType<container::XNamed>::get(),
 867                 cppu::UnoType<drawing::XShapes>::get(),
 868             };
 869
 870             return aTypeSequence;
 871         }
 872     case SdrObjKind::CustomShape:
 873         {
 874             static uno::Sequence<uno::Type> aTypeSequence{
 875                 cppu::UnoType<drawing::XShape>::get(),
 876                 cppu::UnoType<lang::XComponent>::get(),
 877                 cppu::UnoType<beans::XPropertySet>::get(),
 878                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 879                 cppu::UnoType<beans::XPropertyState>::get(),
 880                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 881                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 882                 cppu::UnoType<container::XChild>::get(),
 883                 cppu::UnoType<lang::XServiceInfo>::get(),
 884                 cppu::UnoType<lang::XTypeProvider>::get(),
 885                 cppu::UnoType<lang::XUnoTunnel>::get(),
 886                 cppu::UnoType<container::XNamed>::get(),
 887                 // from SvxUnoTextBase::getTypes()
 888                 cppu::UnoType<text::XText>::get(),
 889                 cppu::UnoType<container::XEnumerationAccess>::get(),
 890                 cppu::UnoType<text::XTextRangeMover>::get(),
 891                 cppu::UnoType<drawing::XEnhancedCustomShapeDefaulter>::get(),
 892             };
 893
 894             return aTypeSequence;
 895         }
 896     // shapes with text
 897     case SdrObjKind::Rectangle:
 898     case SdrObjKind::CircleOrEllipse:
 899     case SdrObjKind::Measure:
 900     case SdrObjKind::Line:
 901     case SdrObjKind::Polygon:
 902     case SdrObjKind::PolyLine:
 903     case SdrObjKind::PathLine:
 904     case SdrObjKind::PathFill:
 905     case SdrObjKind::FreehandLine:
 906     case SdrObjKind::FreehandFill:
 907     case SdrObjKind::PathPoly:
 908     case SdrObjKind::PathPolyLine:
 909     case SdrObjKind::Graphic:
 910     case SdrObjKind::Text:
 911     case SdrObjKind::Caption:
 912     case SdrObjKind::OLE2: // #i118485# Moved to shapes with text
 913     default:
 914         {
 915             static uno::Sequence<uno::Type> aTypeSequence{
 916                 cppu::UnoType<drawing::XShape>::get(),
 917                 cppu::UnoType<lang::XComponent>::get(),
 918                 cppu::UnoType<beans::XPropertySet>::get(),
 919                 cppu::UnoType<beans::XMultiPropertySet>::get(),
 920                 cppu::UnoType<beans::XPropertyState>::get(),
 921                 cppu::UnoType<beans::XMultiPropertyStates>::get(),
 922                 cppu::UnoType<drawing::XGluePointsSupplier>::get(),
 923                 cppu::UnoType<container::XChild>::get(),
 924                 cppu::UnoType<lang::XServiceInfo>::get(),
 925                 cppu::UnoType<lang::XTypeProvider>::get(),
 926                 cppu::UnoType<lang::XUnoTunnel>::get(),
 927                 cppu::UnoType<container::XNamed>::get(),
 928                 // from SvxUnoTextBase::getTypes()
 929                 cppu::UnoType<text::XTextAppend>::get(),
 930                 cppu::UnoType<text::XTextCopy>::get(),
 931                 cppu::UnoType<container::XEnumerationAccess>::get(),
 932                 cppu::UnoType<text::XTextRangeMover>::get(),
 933             };
 934
 935             return aTypeSequence;
 936         }
 937     }
 938 }
 939
 940
 941 uno::Sequence< sal_Int8 > SAL_CALL SvxShape::getImplementationId()
 942 {
 943     return css::uno::Sequence<sal_Int8>();
 944 }
 945
 946 void SvxShape::Notify( SfxBroadcaster&, const SfxHint& rHint ) noexcept
 947 {
 948     DBG_TESTSOLARMUTEX();
 949
 950     // do cheap checks first, this method is hot
 951     if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
 952         return;
 953     if( !mxSdrObject )
 954         return;
 955     const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
 956     // #i55919# SdrHintKind::ObjectChange is only interesting if it's for this object
 957     if ((pSdrHint->GetKind() != SdrHintKind::ModelCleared) &&
 958          (pSdrHint->GetKind() != SdrHintKind::ObjectChange || pSdrHint->GetObject() != mxSdrObject.get() ))
 959         return;
 960
 961     // prevent object being deleted from under us
 962     rtl::Reference<SdrObject> xSdrSelf(mxSdrObject);
 963     uno::Reference< uno::XInterface > xSelf( mxSdrObject->getWeakUnoShape() );
 964     if( !xSelf.is() )
 965     {
 966         EndListening(mxSdrObject->getSdrModelFromSdrObject());
 967         mxSdrObject.clear();
 968         return;
 969     }
 970
 971     if (pSdrHint->GetKind() == SdrHintKind::ObjectChange)
 972     {
 973         updateShapeKind();
 974     }
 975     else // (pSdrHint->GetKind() == SdrHintKind::ModelCleared)
 976     {
 977         EndListening(mxSdrObject->getSdrModelFromSdrObject());
 978         mxSdrObject->setUnoShape(nullptr);
 979         mxSdrObject.clear();
 980
 981         if(!mpImpl->mbDisposing)
 982             dispose();
 983     }
 984 }
 985
 986 // XShape
 987
 988
 989 // The "*LogicRectHack" functions also existed in sch, and those
 990 // duplicate symbols cause Bad Things To Happen (TM)  #i9462#.
 991 // Prefixing with 'svx' and marking static to make sure name collisions
 992 // do not occur.
 993
 994 static bool svx_needLogicRectHack( SdrObject const * pObj )
 995 {
 996     if( pObj->GetObjInventor() == SdrInventor::Default)
 997     {
 998         switch(pObj->GetObjIdentifier())
 999         {
1000         case SdrObjKind::Group:
1001         case SdrObjKind::Line:
1002         case SdrObjKind::Polygon:
1003         case SdrObjKind::PolyLine:
1004         case SdrObjKind::PathLine:
1005         case SdrObjKind::PathFill:
1006         case SdrObjKind::FreehandLine:
1007         case SdrObjKind::FreehandFill:
1008         case SdrObjKind::Edge:
1009         case SdrObjKind::PathPoly:
1010         case SdrObjKind::PathPolyLine:
1011         case SdrObjKind::Measure:
1012             return true;
1013         default:
1014             break;
1015         }
1016     }
1017     return false;
1018 }
1019
1020
1021 static tools::Rectangle svx_getLogicRectHack( SdrObject const * pObj )
1022 {
1023     if(svx_needLogicRectHack(pObj))
1024     {
1025         return pObj->GetSnapRect();
1026     }
1027     else
1028     {
1029         return pObj->GetLogicRect();
1030     }
1031 }
1032
1033
1034 static void svx_setLogicRectHack( SdrObject* pObj, const tools::Rectangle& rRect )
1035 {
1036     if(svx_needLogicRectHack(pObj))
1037     {
1038         pObj->SetSnapRect( rRect );
1039     }
1040     else
1041     {
1042         pObj->SetLogicRect( rRect );
1043     }
1044 }
1045
1046
1047 awt::Point SAL_CALL SvxShape::getPosition()
1048 {
1049     ::SolarMutexGuard aGuard;
1050
1051     if(HasSdrObject())
1052     {
1053         tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
1054         Point aPt( aRect.Left(), aRect.Top() );
1055
1056         // Position is relative to anchor, so recalc to absolute position
1057         if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
1058             aPt -= GetSdrObject()->GetAnchorPos();
1059
1060         ForceMetricTo100th_mm(aPt);
1061         return css::awt::Point( aPt.X(), aPt.Y() );
1062     }
1063     else
1064     {
1065         return maPosition;
1066     }
1067 }
1068
1069
1070 void SAL_CALL SvxShape::setPosition( const awt::Point& Position )
1071 {
1072     ::SolarMutexGuard aGuard;
1073
1074     if(HasSdrObject())
1075     {
1076         // do NOT move 3D objects, this would change the homogen
1077         // transformation matrix
1078         if(dynamic_cast<const E3dCompoundObject* >(GetSdrObject()) == nullptr)
1079         {
1080             tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
1081             Point aLocalPos( Position.X, Position.Y );
1082             ForceMetricToItemPoolMetric(aLocalPos);
1083
1084             // Position is absolute, so recalc to position relative to anchor
1085             if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
1086                 aLocalPos += GetSdrObject()->GetAnchorPos();
1087
1088             tools::Long nDX = aLocalPos.X() - aRect.Left();
1089             tools::Long nDY = aLocalPos.Y() - aRect.Top();
1090
1091             GetSdrObject()->Move( Size( nDX, nDY ) );
1092             GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
1093         }
1094     }
1095
1096     maPosition = Position;
1097 }
1098
1099
1100 awt::Size SAL_CALL SvxShape::getSize()
1101 {
1102     ::SolarMutexGuard aGuard;
1103
1104     if(HasSdrObject())
1105     {
1106         tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
1107         Size aObjSize( aRect.getOpenWidth(), aRect.getOpenHeight() );
1108         ForceMetricTo100th_mm(aObjSize);
1109         return css::awt::Size( aObjSize.getWidth(), aObjSize.getHeight() );
1110     }
1111     else
1112         return maSize;
1113 }
1114
1115
1116 void SAL_CALL SvxShape::setSize( const awt::Size& rSize )
1117 {
1118     ::SolarMutexGuard aGuard;
1119
1120     if(HasSdrObject())
1121     {
1122         tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
1123         Size aLocalSize( rSize.Width, rSize.Height );
1124         ForceMetricToItemPoolMetric(aLocalSize);
1125
1126         if(GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == SdrObjKind::Measure )
1127         {
1128             Fraction aWdt(aLocalSize.Width(),aRect.Right()-aRect.Left());
1129             Fraction aHgt(aLocalSize.Height(),aRect.Bottom()-aRect.Top());
1130             Point aPt = GetSdrObject()->GetSnapRect().TopLeft();
1131             GetSdrObject()->Resize(aPt,aWdt,aHgt);
1132         }
1133         else
1134         {
1135             //aRect.SetSize(aLocalSize); // this call subtract 1 // https://bz.apache.org/ooo/show_bug.cgi?id=83193
1136             if ( !aLocalSize.Width() )
1137             {
1138                 aRect.SetWidthEmpty();
1139             }
1140             else
1141                 aRect.setWidth(aLocalSize.Width());
1142             if ( !aLocalSize.Height() )
1143             {
1144                 aRect.SetHeightEmpty();
1145             }
1146             else
1147                 aRect.setHeight(aLocalSize.Height());
1148
1149             svx_setLogicRectHack( GetSdrObject(), aRect );
1150         }
1151
1152         GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
1153     }
1154     maSize = rSize;
1155 }
1156
1157
1158 // XNamed
1159 OUString SAL_CALL SvxShape::getName(  )
1160 {
1161     ::SolarMutexGuard aGuard;
1162     if( HasSdrObject() )
1163     {
1164         return GetSdrObject()->GetName();
1165     }
1166     else
1167     {
1168         return maShapeName;
1169     }
1170 }
1171
1172
1173 void SAL_CALL SvxShape::setName( const OUString& aName )
1174 {
1175     ::SolarMutexGuard aGuard;
1176     if( HasSdrObject() )
1177     {
1178         GetSdrObject()->SetName( aName );
1179     }
1180     else
1181     {
1182         maShapeName = aName;
1183     }
1184 }
1185
1186 // XShapeDescriptor
1187
1188
1189 OUString SAL_CALL SvxShape::getShapeType()
1190 {
1191     if( !maShapeType.getLength() )
1192         return UHashMap::getNameFromId( mpImpl->mnObjId );
1193     else
1194         return maShapeType;
1195 }
1196
1197 // XComponent
1198
1199
1200 void SAL_CALL SvxShape::dispose()
1201 {
1202     std::unique_lock g(m_aMutex);
1203
1204     if( mpImpl->mbDisposing )
1205         return; // caught a recursion
1206
1207     mpImpl->mbDisposing = true;
1208
1209     lang::EventObject aEvt;
1210     aEvt.Source = *static_cast<OWeakAggObject*>(this);
1211     mpImpl->maDisposeListeners.disposeAndClear(g, aEvt);
1212     mpImpl->maPropertyNotifier.disposing(g);
1213
1214     rtl::Reference<SdrObject> pObject = mxSdrObject;
1215     if (!pObject)
1216         return;
1217
1218     EndListening( pObject->getSdrModelFromSdrObject() );
1219
1220     if ( pObject->IsInserted() && pObject->getSdrPageFromSdrObject() )
1221     {
1222         SdrPage* pPage = pObject->getSdrPageFromSdrObject();
1223         // delete the SdrObject from the page
1224         const size_t nCount = pPage->GetObjCount();
1225         for ( size_t nNum = 0; nNum < nCount; ++nNum )
1226         {
1227             if ( pPage->GetObj( nNum ) == pObject.get() )
1228             {
1229                 OSL_VERIFY( pPage->RemoveObject( nNum ) == pObject );
1230                 break;
1231             }
1232         }
1233     }
1234
1235     mxSdrObject.clear();
1236     pObject->setUnoShape(nullptr);
1237 }
1238
1239
1240 void SAL_CALL SvxShape::addEventListener( const Reference< lang::XEventListener >& xListener )
1241 {
1242     std::unique_lock g(m_aMutex);
1243     mpImpl->maDisposeListeners.addInterface(g, xListener);
1244 }
1245
1246
1247 void SAL_CALL SvxShape::removeEventListener( const Reference< lang::XEventListener >& aListener )
1248 {
1249     std::unique_lock g(m_aMutex);
1250     mpImpl->maDisposeListeners.removeInterface(g, aListener);
1251 }
1252
1253 // XPropertySet
1254
1255
1256 Reference< beans::XPropertySetInfo > SAL_CALL
1257     SvxShape::getPropertySetInfo()
1258 {
1259     if( mpImpl->mpMaster )
1260     {
1261         return mpImpl->mpMaster->getPropertySetInfo();
1262     }
1263     else
1264     {
1265         return _getPropertySetInfo();
1266     }
1267 }
1268
1269 Reference< beans::XPropertySetInfo > const &
1270     SvxShape::_getPropertySetInfo()
1271 {
1272     return mpPropSet->getPropertySetInfo();
1273 }
1274
1275
1276 void SAL_CALL SvxShape::addPropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener  )
1277 {
1278     std::unique_lock g(m_aMutex);
1279     mpImpl->maPropertyNotifier.addPropertyChangeListener( g, _propertyName, _listener );
1280 }
1281
1282
1283 void SAL_CALL SvxShape::removePropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener  )
1284 {
1285     std::unique_lock g(m_aMutex);
1286     mpImpl->maPropertyNotifier.removePropertyChangeListener( g, _propertyName, _listener );
1287 }
1288
1289
1290 void SAL_CALL SvxShape::addVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >&  )
1291 {
1292     OSL_FAIL( "SvxShape::addVetoableChangeListener: don't have any vetoable properties, so why ...?" );
1293 }
1294
1295
1296 void SAL_CALL SvxShape::removeVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >&  )
1297 {
1298     OSL_FAIL( "SvxShape::removeVetoableChangeListener: don't have any vetoable properties, so why ...?" );
1299 }
1300
1301
1302 bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName )
1303 {
1304     if(HasSdrObject())
1305     {
1306         SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), nWID, nWID );
1307
1308         if( SetFillAttribute( nWID, rName, aSet, &GetSdrObject()->getSdrModelFromSdrObject() ) )
1309         {
1310             //GetSdrObject()->SetItemSetAndBroadcast(aSet);
1311             GetSdrObject()->SetMergedItemSetAndBroadcast(aSet);
1312
1313             return true;
1314         }
1315     }
1316
1317     return false;
1318 }
1319
1320
1321 bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet, SdrModel const * pModel )
1322 {
1323     // check if an item with the given name and which id is inside the models
1324     // pool or the stylesheet pool, if found it's put in the itemset
1325     if( !SetFillAttribute( nWID, rName, rSet ) )
1326     {
1327         // we did not find such item in one of the pools, so we check
1328         // the property lists that are loaded for the model for items
1329         // that support such.
1330         OUString aStrName = SvxUnogetInternalNameForItem(nWID, rName);
1331
1332         switch( nWID )
1333         {
1334         case XATTR_FILLBITMAP:
1335         {
1336             XBitmapListRef pBitmapList = pModel->GetBitmapList();
1337
1338             if( !pBitmapList.is() )
1339                 return false;
1340
1341             tools::Long nPos = pBitmapList->GetIndex(aStrName);
1342             if( nPos == -1 )
1343                 return false;
1344
1345             const XBitmapEntry* pEntry = pBitmapList->GetBitmap(nPos);
1346             XFillBitmapItem aBmpItem(rName, pEntry->GetGraphicObject());
1347             rSet.Put(aBmpItem);
1348             break;
1349         }
1350         case XATTR_FILLGRADIENT:
1351         {
1352             XGradientListRef pGradientList = pModel->GetGradientList();
1353
1354             if( !pGradientList.is() )
1355                 return false;
1356
1357             tools::Long nPos = pGradientList->GetIndex(aStrName);
1358             if( nPos == -1 )
1359                 return false;
1360
1361             const XGradientEntry* pEntry = pGradientList->GetGradient(nPos);
1362             XFillGradientItem aGrdItem(rName, pEntry->GetGradient());
1363             rSet.Put( aGrdItem );
1364             break;
1365         }
1366         case XATTR_FILLHATCH:
1367         {
1368             XHatchListRef pHatchList = pModel->GetHatchList();
1369
1370             if( !pHatchList.is() )
1371                 return false;
1372
1373             tools::Long nPos = pHatchList->GetIndex(aStrName);
1374             if( nPos == -1 )
1375                 return false;
1376
1377             const XHatchEntry* pEntry = pHatchList->GetHatch( nPos );
1378             XFillHatchItem aHatchItem(rName, pEntry->GetHatch());
1379             rSet.Put( aHatchItem );
1380             break;
1381         }
1382         case XATTR_LINEEND:
1383         case XATTR_LINESTART:
1384         {
1385             XLineEndListRef pLineEndList = pModel->GetLineEndList();
1386
1387             if( !pLineEndList.is() )
1388                 return false;
1389
1390             tools::Long nPos = pLineEndList->GetIndex(aStrName);
1391             if( nPos == -1 )
1392                 return false;
1393
1394             const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos);
1395             if( sal_uInt16(XATTR_LINEEND) == nWID )
1396             {
1397                 XLineEndItem aLEItem(rName, pEntry->GetLineEnd());
1398                 rSet.Put( aLEItem );
1399             }
1400             else
1401             {
1402                 XLineStartItem aLSItem(rName, pEntry->GetLineEnd());
1403                 rSet.Put( aLSItem );
1404             }
1405
1406             break;
1407         }
1408         case XATTR_LINEDASH:
1409         {
1410             XDashListRef pDashList = pModel->GetDashList();
1411
1412             if( !pDashList.is() )
1413                 return false;
1414
1415             tools::Long nPos = pDashList->GetIndex(aStrName);
1416             if( nPos == -1 )
1417                 return false;
1418
1419             const XDashEntry* pEntry = pDashList->GetDash(nPos);
1420             XLineDashItem aDashItem(rName, pEntry->GetDash());
1421             rSet.Put( aDashItem );
1422             break;
1423         }
1424         default:
1425             return false;
1426         }
1427     }
1428
1429     return true;
1430 }
1431
1432
1433 bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet )
1434 {
1435     OUString aName = SvxUnogetInternalNameForItem(nWID, rName);
1436
1437     if (aName.isEmpty())
1438     {
1439         switch( nWID )
1440         {
1441         case XATTR_LINEEND:
1442         case XATTR_LINESTART:
1443             {
1444                 const basegfx::B2DPolyPolygon aEmptyPoly;
1445                 if( nWID == sal_uInt16(XATTR_LINEEND) )
1446                     rSet.Put( XLineEndItem( "", aEmptyPoly ) );
1447                 else
1448                     rSet.Put( XLineStartItem( "", aEmptyPoly ) );
1449
1450                 return true;
1451             }
1452         case XATTR_FILLFLOATTRANSPARENCE:
1453             {
1454                 // #85953# Set a disabled XFillFloatTransparenceItem
1455                 rSet.Put(XFillFloatTransparenceItem());
1456
1457                 return true;
1458             }
1459         }
1460
1461         return false;
1462     }
1463
1464     for (const SfxPoolItem* p : rSet.GetPool()->GetItemSurrogates(nWID))
1465     {
1466         const NameOrIndex* pItem = static_cast<const NameOrIndex*>(p);
1467         if( pItem->GetName() == aName )
1468         {
1469             rSet.Put( *pItem );
1470             return true;
1471         }
1472     }
1473
1474     return false;
1475 }
1476
1477
1478 void SAL_CALL SvxShape::setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
1479 {
1480     if( mpImpl->mpMaster )
1481     {
1482         mpImpl->mpMaster->setPropertyValue( rPropertyName, rVal );
1483     }
1484     else
1485     {
1486         _setPropertyValue( rPropertyName, rVal );
1487     }
1488 }
1489
1490 void SvxShape::_setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
1491 {
1492     ::SolarMutexGuard aGuard;
1493
1494     const SfxItemPropertyMapEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
1495
1496     if (!HasSdrObject())
1497     {
1498         // Since we have no actual sdr object right now, remember all
1499         // properties in a list. These properties will be set when the sdr
1500         // object is created.
1501
1502         if (pMap && pMap->nWID)
1503         {
1504             // FIXME: We should throw a UnknownPropertyException here.
1505             //        But since this class is aggregated from classes that
1506             //        support additional properties that we don't know here we
1507             //        silently store *all* properties, even if they may be not
1508             //        supported after creation.
1509             SvxItemPropertySet::setPropertyValue( pMap, rVal, maUrsAnys );
1510         }
1511
1512         return;
1513     }
1514
1515     if (rPropertyName == "HandlePathObjScale")
1516     {
1517         auto pPathObj = dynamic_cast<SdrPathObj*>(GetSdrObject());
1518         if (pPathObj)
1519         {
1520             bool bHandleScale{};
1521             if (rVal >>= bHandleScale)
1522             {
1523                 pPathObj->SetHandleScale(bHandleScale);
1524             }
1525         }
1526         return;
1527     }
1528
1529     if (!pMap)
1530     {
1531         // reduce log noise by ignoring two properties that higher level code queries for on all objects
1532         SAL_WARN_IF(rPropertyName != "FromWordArt" && rPropertyName != "GraphicColorMode",
1533             "svx.uno", "Unknown Property: " << rPropertyName);
1534         throw beans::UnknownPropertyException( rPropertyName, static_cast<cppu::OWeakObject*>(this));
1535     }
1536
1537     if ((pMap->nFlags & beans::PropertyAttribute::READONLY) != 0)
1538         throw beans::PropertyVetoException(
1539             "Readonly property can't be set: " + rPropertyName,
1540             uno::Reference<drawing::XShape>(this));
1541
1542     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
1543
1544     if (setPropertyValueImpl(rPropertyName, pMap, rVal))
1545         return;
1546
1547     DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST, "Not persist item not handled!" );
1548     DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
1549
1550     bool bIsNotPersist = pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST && pMap->nWID != SDRATTR_TEXTDIRECTION;
1551
1552     if( pMap->nWID == SDRATTR_CORNER_RADIUS )
1553     {
1554         sal_Int32 nCornerRadius = 0;
1555         if( !(rVal >>= nCornerRadius) || (nCornerRadius < 0) || (nCornerRadius > 5000000))
1556             throw IllegalArgumentException();
1557     }
1558
1559     std::optional<SfxItemSet> xLocalSet;
1560     SfxItemSet* pSet;
1561     if( mbIsMultiPropertyCall && !bIsNotPersist )
1562     {
1563         if( !mpImpl->mxItemSet )
1564         {
1565             mpImpl->mxItemSet.emplace( GetSdrObject()->GetProperties().CreateObjectSpecificItemSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool() ) );
1566         }
1567         pSet = &*mpImpl->mxItemSet;
1568     }
1569     else
1570     {
1571         xLocalSet.emplace( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), pMap->nWID, pMap->nWID);
1572         pSet = &*xLocalSet;
1573     }
1574
1575     if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
1576         pSet->Put(GetSdrObject()->GetMergedItem(pMap->nWID));
1577
1578     if( !SvxUnoTextRangeBase::SetPropertyValueHelper( pMap, rVal, *pSet ))
1579     {
1580         if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
1581         {
1582             if(bIsNotPersist)
1583             {
1584                 // not-persistent attribute, get those extra
1585                 GetSdrObject()->TakeNotPersistAttr(*pSet);
1586             }
1587         }
1588
1589         if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
1590         {
1591             // get default from ItemPool
1592             if(SfxItemPool::IsWhich(pMap->nWID))
1593                 pSet->Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
1594         }
1595
1596         if( pSet->GetItemState( pMap->nWID ) == SfxItemState::SET )
1597         {
1598             SvxItemPropertySet_setPropertyValue( pMap, rVal, *pSet );
1599         }
1600     }
1601
1602     if(bIsNotPersist)
1603     {
1604         // set not-persistent attribute extra
1605         GetSdrObject()->ApplyNotPersistAttr( *pSet );
1606     }
1607     else
1608     {
1609         // if we have a XMultiProperty call then the item set
1610         // will be set in setPropertyValues later
1611         if( !mbIsMultiPropertyCall )
1612             GetSdrObject()->SetMergedItemSetAndBroadcast( *pSet );
1613     }
1614 }
1615
1616
1617 uno::Any SAL_CALL SvxShape::getPropertyValue( const OUString& PropertyName )
1618 {
1619     if ( mpImpl->mpMaster )
1620         return mpImpl->mpMaster->getPropertyValue( PropertyName );
1621     else
1622         return _getPropertyValue( PropertyName );
1623 }
1624
1625
1626 uno::Any SvxShape::_getPropertyValue( const OUString& PropertyName )
1627 {
1628     ::SolarMutexGuard aGuard;
1629
1630     const SfxItemPropertyMapEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1631
1632     uno::Any aAny;
1633     if(HasSdrObject())
1634     {
1635         if(pMap == nullptr )
1636             throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1637
1638         if( !getPropertyValueImpl( PropertyName, pMap, aAny ) )
1639         {
1640             DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || (pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST), "Not persist item not handled!" );
1641             DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
1642
1643             SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), pMap->nWID, pMap->nWID );
1644             aSet.Put(GetSdrObject()->GetMergedItem(pMap->nWID));
1645
1646             if(SvxUnoTextRangeBase::GetPropertyValueHelper(  aSet, pMap, aAny ))
1647                 return aAny;
1648
1649             if(!aSet.Count())
1650             {
1651                 if(pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST)
1652                 {
1653                     // not-persistent attribute, get those extra
1654                     GetSdrObject()->TakeNotPersistAttr(aSet);
1655                 }
1656             }
1657
1658             if(!aSet.Count())
1659             {
1660                 // get default from ItemPool
1661                 if(SfxItemPool::IsWhich(pMap->nWID))
1662                     aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
1663             }
1664
1665             if(aSet.Count())
1666                 aAny = GetAnyForItem( aSet, pMap );
1667         }
1668     }
1669     else
1670     {
1671
1672 // Fixme: we should return default values for OWN_ATTR !
1673
1674         if(pMap && pMap->nWID)
1675 //      FixMe: see setPropertyValue
1676             aAny = mpPropSet->getPropertyValue( pMap, maUrsAnys );
1677
1678     }
1679     return aAny;
1680 }
1681
1682
1683 // XMultiPropertySet
1684 void SAL_CALL SvxShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues )
1685 {
1686     ::SolarMutexGuard aSolarGuard;
1687
1688     const sal_Int32 nCount = aPropertyNames.getLength();
1689     if (nCount != aValues.getLength())
1690         throw css::lang::IllegalArgumentException("lengths do not match",
1691                                                   static_cast<cppu::OWeakObject*>(this), -1);
1692
1693     const OUString* pNames = aPropertyNames.getConstArray();
1694     const uno::Any* pValues = aValues.getConstArray();
1695
1696     // make sure mbIsMultiPropertyCall and mpImpl->mpItemSet are
1697     // reset even when an exception is thrown
1698     const ::comphelper::ScopeGuard aGuard( [this] () { return this->endSetPropertyValues(); } );
1699
1700     mbIsMultiPropertyCall = true;
1701
1702     if( mpImpl->mpMaster )
1703     {
1704         for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1705         {
1706             try
1707             {
1708                 setPropertyValue( *pNames, *pValues );
1709             }
1710             catch (beans::UnknownPropertyException&)
1711             {
1712                 DBG_UNHANDLED_EXCEPTION("svx");
1713             }
1714             catch (uno::Exception&)
1715             {
1716                 DBG_UNHANDLED_EXCEPTION("svx");
1717             }
1718         }
1719     }
1720     else
1721     {
1722         uno::Reference< beans::XPropertySet > xSet;
1723         queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet;
1724
1725         for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1726         {
1727             try
1728             {
1729                 xSet->setPropertyValue( *pNames, *pValues );
1730             }
1731             catch (beans::UnknownPropertyException&)
1732             {
1733                 DBG_UNHANDLED_EXCEPTION("svx");
1734             }
1735             catch (uno::Exception&)
1736             {
1737                 DBG_UNHANDLED_EXCEPTION("svx");
1738             }
1739         }
1740     }
1741
1742     if( mpImpl->mxItemSet && HasSdrObject() )
1743         GetSdrObject()->SetMergedItemSetAndBroadcast( *mpImpl->mxItemSet );
1744 }
1745
1746
1747 void SvxShape::endSetPropertyValues()
1748 {
1749     mbIsMultiPropertyCall = false;
1750     mpImpl->mxItemSet.reset();
1751 }
1752
1753
1754 css::uno::Sequence< css::uno::Any > SAL_CALL SvxShape::getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames )
1755 {
1756     const sal_Int32 nCount = aPropertyNames.getLength();
1757     const OUString* pNames = aPropertyNames.getConstArray();
1758
1759     uno::Sequence< uno::Any > aRet( nCount );
1760     uno::Any* pValue = aRet.getArray();
1761
1762     if( mpImpl->mpMaster )
1763     {
1764         for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
1765         {
1766             try
1767             {
1768                 *pValue = getPropertyValue( *pNames );
1769             }
1770             catch( uno::Exception& )
1771             {
1772                 OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" );
1773             }
1774         }
1775     }
1776     else
1777     {
1778         uno::Reference< beans::XPropertySet > xSet;
1779         queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet;
1780
1781         for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
1782         {
1783             try
1784             {
1785                 *pValue = xSet->getPropertyValue( *pNames );
1786             }
1787             catch( uno::Exception& )
1788             {
1789                 OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" );
1790             }
1791         }
1792     }
1793
1794     return aRet;
1795 }
1796
1797 void SAL_CALL SvxShape::addPropertiesChangeListener( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
1798 {
1799 }
1800
1801 void SAL_CALL SvxShape::removePropertiesChangeListener( const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
1802 {
1803 }
1804
1805 void SAL_CALL SvxShape::firePropertiesChangeEvent( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
1806 {
1807 }
1808
1809
1810 uno::Any SvxShape::GetAnyForItem( SfxItemSet const & aSet, const SfxItemPropertyMapEntry* pMap ) const
1811 {
1812     DBG_TESTSOLARMUTEX();
1813     uno::Any aAny;
1814
1815     switch(pMap->nWID)
1816     {
1817     case SDRATTR_CIRCSTARTANGLE:
1818     {
1819         if(const SdrAngleItem* pPoolItem = aSet.GetItemIfSet(SDRATTR_CIRCSTARTANGLE,false))
1820         {
1821             Degree100 nAngle = pPoolItem->GetValue();
1822             aAny <<= nAngle.get();
1823         }
1824         break;
1825     }
1826
1827     case SDRATTR_CIRCENDANGLE:
1828     {
1829         if (const SdrAngleItem* pPoolItem = aSet.GetItemIfSet(SDRATTR_CIRCENDANGLE,false))
1830         {
1831             Degree100 nAngle = pPoolItem->GetValue();
1832             aAny <<= nAngle.get();
1833         }
1834         break;
1835     }
1836
1837     case SDRATTR_CIRCKIND:
1838     {
1839         if( GetSdrObject()->GetObjInventor() == SdrInventor::Default)
1840         {
1841             drawing::CircleKind eKind;
1842             switch(GetSdrObject()->GetObjIdentifier())
1843             {
1844             case SdrObjKind::CircleOrEllipse:          // circle, ellipse
1845                 eKind = drawing::CircleKind_FULL;
1846                 break;
1847             case SdrObjKind::CircleCut:          // segment of circle
1848                 eKind = drawing::CircleKind_CUT;
1849                 break;
1850             case SdrObjKind::CircleArc:          // arc of circle
1851                 eKind = drawing::CircleKind_ARC;
1852                 break;
1853             case SdrObjKind::CircleSection:          // sector
1854                 eKind = drawing::CircleKind_SECTION;
1855                 break;
1856             default:
1857                 break;
1858             }
1859             aAny <<= eKind;
1860         }
1861         break;
1862     }
1863     default:
1864     {
1865         // get value from ItemSet
1866         aAny = SvxItemPropertySet_getPropertyValue( pMap, aSet );
1867
1868         if( pMap->aType != aAny.getValueType() )
1869         {
1870             // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
1871             if( ( pMap->aType == ::cppu::UnoType<sal_Int16>::get()) && aAny.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
1872             {
1873                 sal_Int32 nValue = 0;
1874                 aAny >>= nValue;
1875                 aAny <<= static_cast<sal_Int16>(nValue);
1876             }
1877             else
1878             {
1879                 OSL_FAIL("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
1880             }
1881         }
1882
1883     }
1884     }
1885
1886     return aAny;
1887 }
1888
1889
1890 // XPropertyState
1891 beans::PropertyState SAL_CALL SvxShape::getPropertyState( const OUString& PropertyName )
1892 {
1893     if( mpImpl->mpMaster )
1894     {
1895         return mpImpl->mpMaster->getPropertyState( PropertyName );
1896     }
1897     else
1898     {
1899         return _getPropertyState( PropertyName );
1900     }
1901 }
1902
1903 beans::PropertyState SvxShape::_getPropertyState( const OUString& PropertyName )
1904 {
1905     ::SolarMutexGuard aGuard;
1906
1907     const SfxItemPropertyMapEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1908
1909     if( !HasSdrObject() || pMap == nullptr )
1910         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1911
1912     beans::PropertyState eState;
1913     if( !getPropertyStateImpl( pMap, eState ) )
1914     {
1915         const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet();
1916
1917         switch( rSet.GetItemState( pMap->nWID, false ) )
1918         {
1919         case SfxItemState::SET:
1920             eState = beans::PropertyState_DIRECT_VALUE;
1921             break;
1922         case SfxItemState::DEFAULT:
1923             eState = beans::PropertyState_DEFAULT_VALUE;
1924             break;
1925         default:
1926             eState = beans::PropertyState_AMBIGUOUS_VALUE;
1927             break;
1928         }
1929
1930         // if an item is set, this doesn't mean we want it :)
1931         if( beans::PropertyState_DIRECT_VALUE == eState )
1932         {
1933             switch( pMap->nWID )
1934             {
1935             // the following items are disabled by changing the
1936             // fill style or the line style. so there is no need
1937             // to export items without names which should be empty
1938             case XATTR_FILLBITMAP:
1939             case XATTR_FILLGRADIENT:
1940             case XATTR_FILLHATCH:
1941             case XATTR_LINEDASH:
1942                 {
1943                     const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID);
1944                     if( ( pItem == nullptr ) || pItem->GetName().isEmpty() )
1945                         eState = beans::PropertyState_DEFAULT_VALUE;
1946                 }
1947                 break;
1948
1949             // #i36115#
1950             // If e.g. the LineStart is on NONE and thus the string has length 0, it still
1951             // may be a hard attribute covering the set LineStart of the parent (Style).
1952             // #i37644#
1953             // same is for fill float transparency
1954             case XATTR_LINEEND:
1955             case XATTR_LINESTART:
1956             case XATTR_FILLFLOATTRANSPARENCE:
1957                 {
1958                     const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID);
1959                     if ( pItem == nullptr )
1960                         eState = beans::PropertyState_DEFAULT_VALUE;
1961                 }
1962                 break;
1963             case XATTR_FILLCOLOR:
1964                 if (pMap->nMemberId == MID_COLOR_THEME_INDEX)
1965                 {
1966                     const XFillColorItem* pColor = rSet.GetItem<XFillColorItem>(pMap->nWID);
1967                     if (pColor->getComplexColor().getType() == model::ColorType::Unused ||
1968                         pColor->getComplexColor().getSchemeType() == model::ThemeColorType::Unknown)
1969                     {
1970                         eState = beans::PropertyState_DEFAULT_VALUE;
1971                     }
1972                 }
1973                 else if (pMap->nMemberId == MID_COLOR_LUM_MOD)
1974                 {
1975                     const XFillColorItem* pColor = rSet.GetItem<XFillColorItem>(pMap->nWID);
1976                     sal_Int16 nLumMod = 10000;
1977                     for (auto const& rTransform : pColor->getComplexColor().getTransformations())
1978                     {
1979                         if (rTransform.meType == model::TransformationType::LumMod)
1980                             nLumMod = rTransform.mnValue;
1981                     }
1982                     if (nLumMod == 10000)
1983                     {
1984                         eState = beans::PropertyState_DEFAULT_VALUE;
1985                     }
1986                 }
1987                 else if (pMap->nMemberId == MID_COLOR_LUM_OFF)
1988                 {
1989                     const XFillColorItem* pColor = rSet.GetItem<XFillColorItem>(pMap->nWID);
1990                     sal_Int16 nLumOff = 0;
1991                     for (auto const& rTransform : pColor->getComplexColor().getTransformations())
1992                     {
1993                         if (rTransform.meType == model::TransformationType::LumOff)
1994                             nLumOff = rTransform.mnValue;
1995                     }
1996                     if (nLumOff == 0)
1997                     {
1998                         eState = beans::PropertyState_DEFAULT_VALUE;
1999                     }
2000                 }
2001                 else if (pMap->nMemberId == MID_COMPLEX_COLOR)
2002                 {
2003                     auto const* pColor = rSet.GetItem<XFillColorItem>(pMap->nWID);
2004                     if (pColor->getComplexColor().getType() == model::ColorType::Unused)
2005                     {
2006                         eState = beans::PropertyState_DEFAULT_VALUE;
2007                     }
2008                 }
2009                 break;
2010             case XATTR_LINECOLOR:
2011                 if (pMap->nMemberId == MID_COMPLEX_COLOR)
2012                 {
2013                     auto const* pColor = rSet.GetItem<XLineColorItem>(pMap->nWID);
2014                     if (pColor->getComplexColor().getType() == model::ColorType::Unused)
2015                     {
2016                         eState = beans::PropertyState_DEFAULT_VALUE;
2017                     }
2018                 }
2019                 break;
2020             }
2021         }
2022     }
2023     return eState;
2024 }
2025
2026 bool SvxShape::setPropertyValueImpl( const OUString&, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
2027 {
2028     rtl::Reference<SdrObject> pSdrObject = GetSdrObject();
2029     switch( pProperty->nWID )
2030     {
2031     case OWN_ATTR_CAPTION_POINT:
2032     {
2033         awt::Point aPnt;
2034         if( rValue >>= aPnt )
2035         {
2036             Point aVclPoint( aPnt.X, aPnt.Y );
2037
2038             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
2039             // Need to adapt aVclPoint from 100thmm to app-specific
2040             ForceMetricToItemPoolMetric(aVclPoint);
2041
2042             // #90763# position is relative to top left, make it absolute
2043             basegfx::B2DPolyPolygon aNewPolyPolygon;
2044             basegfx::B2DHomMatrix aNewHomogenMatrix;
2045             pSdrObject->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2046
2047             aVclPoint.AdjustX(basegfx::fround(aNewHomogenMatrix.get(0, 2)) );
2048             aVclPoint.AdjustY(basegfx::fround(aNewHomogenMatrix.get(1, 2)) );
2049
2050             // #88491# position relative to anchor
2051             if( pSdrObject->getSdrModelFromSdrObject().IsWriter() )
2052             {
2053                 aVclPoint += pSdrObject->GetAnchorPos();
2054             }
2055
2056             static_cast<SdrCaptionObj*>(pSdrObject.get())->SetTailPos(aVclPoint);
2057
2058             return true;
2059         }
2060         break;
2061     }
2062     case OWN_ATTR_TRANSFORMATION:
2063     {
2064         drawing::HomogenMatrix3 aMatrix;
2065         if(rValue >>= aMatrix)
2066         {
2067             basegfx::B2DPolyPolygon aNewPolyPolygon;
2068             basegfx::B2DHomMatrix aNewHomogenMatrix;
2069
2070             // tdf#117145 SdrModel data is app-specific
2071             pSdrObject->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2072
2073             aNewHomogenMatrix.set(0, 0, aMatrix.Line1.Column1);
2074             aNewHomogenMatrix.set(0, 1, aMatrix.Line1.Column2);
2075             aNewHomogenMatrix.set(0, 2, aMatrix.Line1.Column3);
2076             aNewHomogenMatrix.set(1, 0, aMatrix.Line2.Column1);
2077             aNewHomogenMatrix.set(1, 1, aMatrix.Line2.Column2);
2078             aNewHomogenMatrix.set(1, 2, aMatrix.Line2.Column3);
2079             // For this to be a valid 2D transform matrix, the last row must be [0,0,1]
2080             assert( aMatrix.Line3.Column1 == 0 );
2081             assert( aMatrix.Line3.Column2 == 0 );
2082             assert( aMatrix.Line3.Column3 == 1 );
2083
2084             // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
2085             // Need to adapt aNewHomogenMatrix from 100thmm to app-specific
2086             ForceMetricToItemPoolMetric(aNewHomogenMatrix);
2087
2088             pSdrObject->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2089             return true;
2090         }
2091         break;
2092     }
2093
2094     case OWN_ATTR_ZORDER:
2095     {
2096         sal_Int32 nNewOrdNum = 0;
2097         if(rValue >>= nNewOrdNum)
2098         {
2099             SdrObjList* pObjList = pSdrObject->getParentSdrObjListFromSdrObject();
2100             if( pObjList )
2101                 pObjList->SetExistingObjectOrdNum( pSdrObject.get(), static_cast<size_t>(nNewOrdNum) );
2102             return true;
2103         }
2104         break;
2105     }
2106     case OWN_ATTR_FRAMERECT:
2107     {
2108         awt::Rectangle aUnoRect;
2109         if(rValue >>= aUnoRect)
2110         {
2111             Point aTopLeft( aUnoRect.X, aUnoRect.Y );
2112             Size aObjSize( aUnoRect.Width, aUnoRect.Height );
2113             ForceMetricToItemPoolMetric(aTopLeft);
2114             ForceMetricToItemPoolMetric(aObjSize);
2115             tools::Rectangle aRect;
2116             aRect.SetPos(aTopLeft);
2117             aRect.SetSize(aObjSize);
2118             pSdrObject->SetSnapRect(aRect);
2119             return true;
2120         }
2121         break;
2122     }
2123     case OWN_ATTR_MIRRORED:
2124     {
2125         bool bMirror;
2126         if(rValue >>= bMirror )
2127         {
2128             SdrGrafObj* pObj = dynamic_cast< SdrGrafObj* >( pSdrObject.get() );
2129             if( pObj )
2130                 pObj->SetMirrored(bMirror);
2131             return true;
2132         }
2133         break;
2134     }
2135     case OWN_ATTR_EDGE_START_OBJ:
2136     case OWN_ATTR_EDGE_END_OBJ:
2137     case OWN_ATTR_GLUEID_HEAD:
2138     case OWN_ATTR_GLUEID_TAIL:
2139     case OWN_ATTR_EDGE_START_POS:
2140     case OWN_ATTR_EDGE_END_POS:
2141     case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2142     {
2143         SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >(pSdrObject.get());
2144         if(pEdgeObj)
2145         {
2146             switch(pProperty->nWID)
2147             {
2148             case OWN_ATTR_EDGE_START_OBJ:
2149             case OWN_ATTR_EDGE_END_OBJ:
2150                 {
2151                     Reference< drawing::XShape > xShape;
2152                     if( rValue >>= xShape )
2153                     {
2154                         SdrObject* pNode = SdrObject::getSdrObjectFromXShape(xShape);
2155                         if( pNode )
2156                         {
2157                             pEdgeObj->ConnectToNode( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ, pNode );
2158                             pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ );
2159                             return true;
2160                         }
2161                     }
2162                     break;
2163                 }
2164
2165             case OWN_ATTR_EDGE_START_POS:
2166             case OWN_ATTR_EDGE_END_POS:
2167                 {
2168                     awt::Point aUnoPoint;
2169                     if( rValue >>= aUnoPoint )
2170                     {
2171                         Point aPoint( aUnoPoint.X, aUnoPoint.Y );
2172
2173                         // Reintroduction of fix for issue i59051 (#i108851#)
2174                         // perform metric change before applying anchor position,
2175                         // because the anchor position is in pool metric.
2176                         ForceMetricToItemPoolMetric( aPoint );
2177                         if( pSdrObject->getSdrModelFromSdrObject().IsWriter() )
2178                             aPoint += pSdrObject->GetAnchorPos();
2179
2180                         pEdgeObj->SetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS, aPoint );
2181                         return true;
2182                     }
2183                     break;
2184                 }
2185
2186             case OWN_ATTR_GLUEID_HEAD:
2187             case OWN_ATTR_GLUEID_TAIL:
2188                 {
2189                     sal_Int32 nId = 0;
2190                     if( rValue >>= nId )
2191                     {
2192                         pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD, nId );
2193                         return true;
2194                     }
2195                     break;
2196                 }
2197             case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2198                 {
2199                     basegfx::B2DPolyPolygon aNewPolyPolygon;
2200
2201                     // #123616# be a little bit more flexible regarding the data type used
2202                     if( auto s = o3tl::tryAccess<drawing::PointSequenceSequence>(rValue) )
2203                     {
2204                         // get polygpon data from PointSequenceSequence
2205                         aNewPolyPolygon = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(
2206                             *s);
2207                     }
2208                     else if( auto cs = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rValue) )
2209                     {
2210                         // get polygpon data from PolyPolygonBezierCoords
2211                         aNewPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
2212                             *cs);
2213                     }
2214
2215                     if(aNewPolyPolygon.count())
2216                     {
2217                         // Reintroduction of fix for issue i59051 (#i108851#)
2218                         ForceMetricToItemPoolMetric( aNewPolyPolygon );
2219                         if( pSdrObject->getSdrModelFromSdrObject().IsWriter() )
2220                         {
2221                             Point aPoint( pSdrObject->GetAnchorPos() );
2222                             aNewPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(aPoint.X(), aPoint.Y()));
2223                         }
2224                         pEdgeObj->SetEdgeTrackPath( aNewPolyPolygon );
2225                         return true;
2226                     }
2227                 }
2228             }
2229         }
2230         break;
2231     }
2232     case OWN_ATTR_MEASURE_START_POS:
2233     case OWN_ATTR_MEASURE_END_POS:
2234     {
2235         SdrMeasureObj* pMeasureObj = dynamic_cast< SdrMeasureObj* >(pSdrObject.get());
2236         awt::Point aUnoPoint;
2237         if(pMeasureObj && ( rValue >>= aUnoPoint ) )
2238         {
2239             Point aPoint( aUnoPoint.X, aUnoPoint.Y );
2240
2241             // Reintroduction of fix for issue #i59051# (#i108851#)
2242             ForceMetricToItemPoolMetric( aPoint );
2243             if( pSdrObject->getSdrModelFromSdrObject().IsWriter() )
2244                 aPoint += pSdrObject->GetAnchorPos();
2245
2246             pMeasureObj->NbcSetPoint( aPoint, pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 );
2247             pMeasureObj->SetChanged();
2248             pMeasureObj->BroadcastObjectChange();
2249             return true;
2250         }
2251         break;
2252     }
2253     case OWN_ATTR_FILLBMP_MODE:
2254         {
2255             drawing::BitmapMode eMode;
2256             if(!(rValue >>= eMode) )
2257             {
2258                 sal_Int32 nMode = 0;
2259                 if(!(rValue >>= nMode))
2260                     break;
2261
2262                 eMode = static_cast<drawing::BitmapMode>(nMode);
2263             }
2264             pSdrObject->SetMergedItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
2265             pSdrObject->SetMergedItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
2266             return true;
2267         }
2268
2269     case SDRATTR_LAYERID:
2270     {
2271         sal_Int16 nLayerId = sal_Int16();
2272         if( rValue >>= nLayerId )
2273         {
2274             SdrLayer* pLayer = pSdrObject->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(SdrLayerID(nLayerId));
2275             if( pLayer )
2276             {
2277                 pSdrObject->SetLayer(SdrLayerID(nLayerId));
2278                 return true;
2279             }
2280         }
2281         break;
2282     }
2283
2284     case SDRATTR_LAYERNAME:
2285     {
2286         OUString aLayerName;
2287         if( rValue >>= aLayerName )
2288         {
2289             const SdrLayer* pLayer = pSdrObject->getSdrModelFromSdrObject().GetLayerAdmin().GetLayer(aLayerName);
2290             if( pLayer != nullptr )
2291             {
2292                 pSdrObject->SetLayer( pLayer->GetID() );
2293                 return true;
2294             }
2295         }
2296         break;
2297     }
2298     case SDRATTR_ROTATEANGLE:
2299     {
2300         sal_Int32 nTmp = 0;
2301         if( rValue >>= nTmp )
2302         {
2303             Degree100 nAngle(nTmp);
2304             Point aRef1(pSdrObject->GetSnapRect().Center());
2305             nAngle -= pSdrObject->GetRotateAngle();
2306             if (nAngle)
2307             {
2308                 double nSin = sin(toRadians(nAngle));
2309                 double nCos = cos(toRadians(nAngle));
2310                 pSdrObject->Rotate(aRef1,nAngle,nSin,nCos);
2311             }
2312             return true;
2313         }
2314
2315         break;
2316     }
2317
2318     case SDRATTR_SHEARANGLE:
2319     {
2320         sal_Int32 nTmp = 0;
2321         if( rValue >>= nTmp )
2322         {
2323             Degree100 nShear(nTmp);
2324             nShear -= pSdrObject->GetShearAngle();
2325             if(nShear)
2326             {
2327                 Point aRef1(pSdrObject->GetSnapRect().Center());
2328                 double nTan = tan(toRadians(nShear));
2329                 pSdrObject->Shear(aRef1,nShear,nTan,false);
2330                 return true;
2331             }
2332         }
2333
2334         break;
2335     }
2336
2337     case OWN_ATTR_INTEROPGRABBAG:
2338     {
2339         pSdrObject->SetGrabBagItem(rValue);
2340         return true;
2341     }
2342
2343     case SDRATTR_OBJMOVEPROTECT:
2344     {
2345         bool bMoveProtect;
2346         if( rValue >>= bMoveProtect )
2347         {
2348             pSdrObject->SetMoveProtect(bMoveProtect);
2349             return true;
2350         }
2351         break;
2352     }
2353     case SDRATTR_OBJECTNAME:
2354     {
2355         OUString aName;
2356         if( rValue >>= aName )
2357         {
2358             pSdrObject->SetName( aName );
2359             return true;
2360         }
2361         break;
2362     }
2363
2364     case OWN_ATTR_TEXTFITTOSIZESCALE:
2365     {
2366         double nMaxScale = 0.0;
2367         if (rValue >>= nMaxScale)
2368         {
2369             SdrTextFitToSizeTypeItem aItem(pSdrObject->GetMergedItem(SDRATTR_TEXT_FITTOSIZE));
2370             aItem.SetMaxScale(nMaxScale);
2371             pSdrObject->SetMergedItem(aItem);
2372             return true;
2373         }
2374         break;
2375     }
2376
2377     // #i68101#
2378     case OWN_ATTR_MISC_OBJ_TITLE:
2379     {
2380         OUString aTitle;
2381         if( rValue >>= aTitle )
2382         {
2383             pSdrObject->SetTitle( aTitle );
2384             return true;
2385         }
2386         break;
2387     }
2388     case OWN_ATTR_MISC_OBJ_DESCRIPTION:
2389     {
2390         OUString aDescription;
2391         if( rValue >>= aDescription )
2392         {
2393             pSdrObject->SetDescription( aDescription );
2394             return true;
2395         }
2396         break;
2397     }
2398     case OWN_ATTR_MISC_OBJ_DECORATIVE:
2399     {
2400         bool isDecorative;
2401         if (rValue >>= isDecorative)
2402         {
2403             pSdrObject->SetDecorative(isDecorative);
2404             return true;
2405         }
2406         break;
2407     }
2408
2409     case SDRATTR_OBJPRINTABLE:
2410     {
2411         bool bPrintable;
2412         if( rValue >>= bPrintable )
2413         {
2414             pSdrObject->SetPrintable(bPrintable);
2415             return true;
2416         }
2417         break;
2418     }
2419     case SDRATTR_OBJVISIBLE:
2420     {
2421         bool bVisible;
2422         if( rValue >>= bVisible )
2423         {
2424             pSdrObject->SetVisible(bVisible);
2425             return true;
2426         }
2427         break;
2428     }
2429     case SDRATTR_OBJSIZEPROTECT:
2430     {
2431         bool bResizeProtect;
2432         if( rValue >>= bResizeProtect )
2433         {
2434             pSdrObject->SetResizeProtect(bResizeProtect);
2435             return true;
2436         }
2437         break;
2438     }
2439     case OWN_ATTR_PAGE_NUMBER:
2440     {
2441         sal_Int32 nPageNum = 0;
2442         if( (rValue >>= nPageNum) && ( nPageNum >= 0 ) && ( nPageNum <= 0xffff ) )
2443         {
2444             SdrPageObj* pPageObj = dynamic_cast< SdrPageObj* >(pSdrObject.get());
2445             if( pPageObj )
2446             {
2447                 SdrModel& rModel(pPageObj->getSdrModelFromSdrObject());
2448                 SdrPage* pNewPage = nullptr;
2449                 const sal_uInt16 nDestinationPageNum(static_cast<sal_uInt16>((nPageNum << 1) - 1));
2450
2451                 if(nDestinationPageNum < rModel.GetPageCount())
2452                 {
2453                     pNewPage = rModel.GetPage(nDestinationPageNum);
2454                 }
2455
2456                 pPageObj->SetReferencedPage(pNewPage);
2457             }
2458
2459             return true;
2460         }
2461         break;
2462     }
2463     case XATTR_FILLBITMAP:
2464     case XATTR_FILLGRADIENT:
2465     case XATTR_FILLHATCH:
2466     case XATTR_FILLFLOATTRANSPARENCE:
2467     case XATTR_LINEEND:
2468     case XATTR_LINESTART:
2469     case XATTR_LINEDASH:
2470     {
2471         if( pProperty->nMemberId == MID_NAME )
2472         {
2473             OUString aApiName;
2474             if( rValue >>= aApiName )
2475             {
2476                 if( SetFillAttribute( pProperty->nWID, aApiName ) )
2477                     return true;
2478             }
2479             break;
2480         }
2481         else
2482         {
2483             return false;
2484         }
2485     }
2486
2487     case OWN_ATTR_TEXTCOLUMNS:
2488     {
2489         if (auto pTextObj = DynCastSdrTextObj(pSdrObject.get()))
2490         {
2491             css::uno::Reference<css::text::XTextColumns> xTextColumns;
2492             if (rValue >>= xTextColumns)
2493             {
2494                 pTextObj->SetTextColumnsNumber(xTextColumns->getColumnCount());
2495                 if (css::uno::Reference<css::beans::XPropertySet> xPropSet{ xTextColumns,
2496                                                                             css::uno::UNO_QUERY })
2497                 {
2498                     auto aVal = xPropSet->getPropertyValue("AutomaticDistance");
2499                     if (sal_Int32 nSpacing; aVal >>= nSpacing)
2500                         pTextObj->SetTextColumnsSpacing(nSpacing);
2501                 }
2502             }
2503         }
2504         return true;
2505     }
2506
2507     case OWN_ATTR_HYPERLINK:
2508     {
2509         OUString sHyperlink;
2510         if (rValue >>= sHyperlink)
2511         {
2512             pSdrObject->setHyperlink(sHyperlink);
2513             return true;
2514         }
2515         break;
2516     }
2517
2518     case SDRATTR_WRITINGMODE2:
2519     {
2520         SvxFrameDirectionItem aItem(SvxFrameDirection::Environment, SDRATTR_WRITINGMODE2);
2521         aItem.PutValue(rValue, 0);
2522         GetSdrObject()->SetMergedItem(aItem);
2523         return true;
2524         break;
2525     }
2526
2527     default:
2528     {
2529         return false;
2530     }
2531     }
2532
2533     OUString sExceptionMessage(
2534         "IllegalArgumentException in SvxShape::setPropertyValueImpl."
2535         " Property Type: "
2536         + pProperty->aType.getTypeName() + " Property Name: " + pProperty->aName
2537         + " Property nWID: " + OUString::number(pProperty->nWID)
2538         + " Value Type: " + (rValue.hasValue() ? rValue.getValueTypeName() : "void (no value)"));
2539
2540     throw lang::IllegalArgumentException(sExceptionMessage, nullptr, 1);
2541 }
2542
2543
2544 bool SvxShape::getPropertyValueImpl( const OUString&, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
2545 {
2546     switch( pProperty->nWID )
2547     {
2548     case OWN_ATTR_CAPTION_POINT:
2549     {
2550         Point aVclPoint = static_cast<SdrCaptionObj*>(GetSdrObject())->GetTailPos();
2551
2552         // #88491# make pos relative to anchor
2553         if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
2554         {
2555             aVclPoint -= GetSdrObject()->GetAnchorPos();
2556         }
2557
2558         // #90763# pos is absolute, make it relative to top left
2559         basegfx::B2DPolyPolygon aNewPolyPolygon;
2560         basegfx::B2DHomMatrix aNewHomogenMatrix;
2561         GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2562
2563         aVclPoint.AdjustX( -(basegfx::fround(aNewHomogenMatrix.get(0, 2))) );
2564         aVclPoint.AdjustY( -(basegfx::fround(aNewHomogenMatrix.get(1, 2))) );
2565
2566         // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
2567         // Need to adapt aVclPoint from app-specific to 100thmm
2568         ForceMetricTo100th_mm(aVclPoint);
2569
2570         awt::Point aPnt( aVclPoint.X(), aVclPoint.Y() );
2571         rValue <<= aPnt;
2572         break;
2573     }
2574
2575     case OWN_ATTR_TRANSFORMATION:
2576     {
2577         basegfx::B2DPolyPolygon aNewPolyPolygon;
2578         basegfx::B2DHomMatrix aNewHomogenMatrix;
2579         GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2580         drawing::HomogenMatrix3 aMatrix;
2581
2582         // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
2583         // Need to adapt aNewHomogenMatrix from app-specific to 100thmm
2584         ForceMetricTo100th_mm(aNewHomogenMatrix);
2585
2586         aMatrix.Line1.Column1 = aNewHomogenMatrix.get(0, 0);
2587         aMatrix.Line1.Column2 = aNewHomogenMatrix.get(0, 1);
2588         aMatrix.Line1.Column3 = aNewHomogenMatrix.get(0, 2);
2589         aMatrix.Line2.Column1 = aNewHomogenMatrix.get(1, 0);
2590         aMatrix.Line2.Column2 = aNewHomogenMatrix.get(1, 1);
2591         aMatrix.Line2.Column3 = aNewHomogenMatrix.get(1, 2);
2592         aMatrix.Line3.Column1 = 0;
2593         aMatrix.Line3.Column2 = 0;
2594         aMatrix.Line3.Column3 = 1;
2595
2596         rValue <<= aMatrix;
2597
2598         break;
2599     }
2600
2601     case OWN_ATTR_ZORDER:
2602     {
2603         rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetOrdNum());
2604         break;
2605     }
2606
2607     case OWN_ATTR_BITMAP:
2608     {
2609         rValue = GetBitmap();
2610         if(!rValue.hasValue())
2611             throw uno::RuntimeException();
2612
2613         break;
2614     }
2615
2616     case OWN_ATTR_ISFONTWORK:
2617     {
2618         bool bIsFontwork = false;
2619         if (const SdrTextObj* pTextObj = DynCastSdrTextObj(GetSdrObject()))
2620             bIsFontwork = pTextObj->IsFontwork();
2621         rValue <<= bIsFontwork;
2622         break;
2623     }
2624
2625     case OWN_ATTR_FRAMERECT:
2626     {
2627         tools::Rectangle aRect( GetSdrObject()->GetSnapRect() );
2628         Point aTopLeft( aRect.TopLeft() );
2629         Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
2630         ForceMetricTo100th_mm(aTopLeft);
2631         ForceMetricTo100th_mm(aObjSize);
2632         css::awt::Rectangle aUnoRect(
2633             aTopLeft.X(), aTopLeft.Y(),
2634             aObjSize.getWidth(), aObjSize.getHeight() );
2635         rValue <<= aUnoRect;
2636         break;
2637     }
2638
2639     case OWN_ATTR_BOUNDRECT:
2640     {
2641         tools::Rectangle aRect( GetSdrObject()->GetCurrentBoundRect() );
2642         Point aTopLeft( aRect.TopLeft() );
2643         Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
2644         ForceMetricTo100th_mm(aTopLeft);
2645         ForceMetricTo100th_mm(aObjSize);
2646         css::awt::Rectangle aUnoRect(
2647             aTopLeft.X(), aTopLeft.Y(),
2648             aObjSize.getWidth(), aObjSize.getHeight() );
2649         rValue <<= aUnoRect;
2650         break;
2651     }
2652
2653     case OWN_ATTR_LDNAME:
2654     {
2655         OUString aName( GetSdrObject()->GetName() );
2656         rValue <<= aName;
2657         break;
2658     }
2659
2660     case OWN_ATTR_LDBITMAP:
2661     {
2662         OUString sId;
2663         if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == SdrObjKind::OLE2 )
2664         {
2665             sId = RID_UNODRAW_OLE2;
2666         }
2667         else if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == SdrObjKind::Graphic )
2668         {
2669             sId = RID_UNODRAW_GRAPHICS;
2670         }
2671         else
2672         {
2673             sId = RID_UNODRAW_OBJECTS;
2674         }
2675
2676         BitmapEx aBmp(sId);
2677         Reference<awt::XBitmap> xBmp(VCLUnoHelper::CreateBitmap(aBmp));
2678
2679         rValue <<= xBmp;
2680         break;
2681     }
2682
2683     case OWN_ATTR_MIRRORED:
2684     {
2685         bool bMirror = false;
2686         if( HasSdrObject() )
2687             if (auto pGrafObj = dynamic_cast<SdrGrafObj*>(GetSdrObject()) )
2688                 bMirror = pGrafObj->IsMirrored();
2689
2690         rValue <<= bMirror;
2691         break;
2692     }
2693
2694     case OWN_ATTR_EDGE_START_OBJ:
2695     case OWN_ATTR_EDGE_START_POS:
2696     case OWN_ATTR_EDGE_END_POS:
2697     case OWN_ATTR_EDGE_END_OBJ:
2698     case OWN_ATTR_GLUEID_HEAD:
2699     case OWN_ATTR_GLUEID_TAIL:
2700     case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2701     {
2702         SdrEdgeObj* pEdgeObj = dynamic_cast<SdrEdgeObj*>(GetSdrObject());
2703         if(pEdgeObj)
2704         {
2705             switch(pProperty->nWID)
2706             {
2707             case OWN_ATTR_EDGE_START_OBJ:
2708             case OWN_ATTR_EDGE_END_OBJ:
2709                 {
2710                     SdrObject* pNode = pEdgeObj->GetConnectedNode(pProperty->nWID == OWN_ATTR_EDGE_START_OBJ);
2711                     if(pNode)
2712                     {
2713                         Reference< drawing::XShape > xShape( GetXShapeForSdrObject( pNode ) );
2714                         if(xShape.is())
2715                             rValue <<= xShape;
2716
2717                     }
2718                     break;
2719                 }
2720
2721             case OWN_ATTR_EDGE_START_POS:
2722             case OWN_ATTR_EDGE_END_POS:
2723                 {
2724                     Point aPoint( pEdgeObj->GetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS ) );
2725                     if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
2726                         aPoint -= GetSdrObject()->GetAnchorPos();
2727
2728                     ForceMetricTo100th_mm( aPoint );
2729                     awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
2730
2731                     rValue <<= aUnoPoint;
2732                     break;
2733                 }
2734             case OWN_ATTR_GLUEID_HEAD:
2735             case OWN_ATTR_GLUEID_TAIL:
2736                 {
2737                     rValue <<= pEdgeObj->getGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD );
2738                     break;
2739                 }
2740             case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2741                 {
2742                     basegfx::B2DPolyPolygon aPolyPoly( pEdgeObj->GetEdgeTrackPath() );
2743                     if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
2744                     {
2745                         Point aPoint( GetSdrObject()->GetAnchorPos() );
2746                         aPolyPoly.transform(basegfx::utils::createTranslateB2DHomMatrix(-aPoint.X(), -aPoint.Y()));
2747                     }
2748                     // Reintroduction of fix for issue #i59051# (#i108851#)
2749                     ForceMetricTo100th_mm( aPolyPoly );
2750                     drawing::PolyPolygonBezierCoords aRetval;
2751                     basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( aPolyPoly, aRetval);
2752                     rValue <<= aRetval;
2753                     break;
2754                 }
2755             }
2756         }
2757         break;
2758     }
2759
2760     case OWN_ATTR_MEASURE_START_POS:
2761     case OWN_ATTR_MEASURE_END_POS:
2762     {
2763         SdrMeasureObj* pMeasureObj = dynamic_cast<SdrMeasureObj*>(GetSdrObject());
2764         if(pMeasureObj)
2765         {
2766             Point aPoint( pMeasureObj->GetPoint( pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 ) );
2767             if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
2768                 aPoint -= GetSdrObject()->GetAnchorPos();
2769
2770             // Reintroduction of fix for issue #i59051# (#i108851#)
2771             ForceMetricTo100th_mm( aPoint );
2772             awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
2773
2774             rValue <<= aUnoPoint;
2775             break;
2776         }
2777         break;
2778     }
2779
2780     case OWN_ATTR_FILLBMP_MODE:
2781     {
2782         const SfxItemSet& rObjItemSet = GetSdrObject()->GetMergedItemSet();
2783
2784         if (rObjItemSet.Get(XATTR_FILLBMP_TILE).GetValue())
2785         {
2786             rValue <<= drawing::BitmapMode_REPEAT;
2787         }
2788         else if (rObjItemSet.Get(XATTR_FILLBMP_STRETCH).GetValue())
2789         {
2790             rValue <<= drawing::BitmapMode_STRETCH;
2791         }
2792         else
2793         {
2794             rValue <<= drawing::BitmapMode_NO_REPEAT;
2795         }
2796         break;
2797     }
2798     case SDRATTR_LAYERID:
2799         rValue <<= GetSdrObject()->GetLayer().get();
2800         break;
2801
2802     case SDRATTR_LAYERNAME:
2803     {
2804         SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(GetSdrObject()->GetLayer());
2805         if( pLayer )
2806         {
2807             rValue <<= pLayer->GetName();
2808         }
2809         break;
2810     }
2811
2812     case SDRATTR_ROTATEANGLE:
2813         rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetRotateAngle());
2814         break;
2815
2816     case SDRATTR_SHEARANGLE:
2817         rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetShearAngle());
2818         break;
2819
2820     case OWN_ATTR_INTEROPGRABBAG:
2821     {
2822         GetSdrObject()->GetGrabBagItem(rValue);
2823         break;
2824     }
2825
2826     case SDRATTR_OBJMOVEPROTECT:
2827         rValue <<= GetSdrObject()->IsMoveProtect();
2828         break;
2829
2830     case SDRATTR_OBJECTNAME:
2831     {
2832         OUString aName( GetSdrObject()->GetName() );
2833         rValue <<= aName;
2834         break;
2835     }
2836
2837     // #i68101#
2838     case OWN_ATTR_MISC_OBJ_TITLE:
2839     {
2840         OUString aTitle( GetSdrObject()->GetTitle() );
2841         rValue <<= aTitle;
2842         break;
2843     }
2844
2845     case OWN_ATTR_MISC_OBJ_DESCRIPTION:
2846     {
2847         OUString aDescription( GetSdrObject()->GetDescription() );
2848         rValue <<= aDescription;
2849         break;
2850     }
2851
2852     case OWN_ATTR_MISC_OBJ_DECORATIVE:
2853     {
2854         bool const isDecorative(GetSdrObject()->IsDecorative());
2855         rValue <<= isDecorative;
2856         break;
2857     }
2858
2859     case SDRATTR_OBJPRINTABLE:
2860         rValue <<= GetSdrObject()->IsPrintable();
2861         break;
2862
2863     case SDRATTR_OBJVISIBLE:
2864         rValue <<= GetSdrObject()->IsVisible();
2865         break;
2866
2867     case SDRATTR_OBJSIZEPROTECT:
2868         rValue <<= GetSdrObject()->IsResizeProtect();
2869         break;
2870
2871     case OWN_ATTR_PAGE_NUMBER:
2872     {
2873         SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(GetSdrObject());
2874         if(pPageObj)
2875         {
2876             SdrPage* pPage = pPageObj->GetReferencedPage();
2877             sal_Int32 nPageNumber = pPage ? pPage->GetPageNum() : 0;
2878             nPageNumber++;
2879             nPageNumber >>= 1;
2880             rValue <<= nPageNumber;
2881         }
2882         break;
2883     }
2884
2885     case OWN_ATTR_UINAME_SINGULAR:
2886     {
2887         rValue <<= GetSdrObject()->TakeObjNameSingul();
2888         break;
2889     }
2890
2891     case OWN_ATTR_TEXTFITTOSIZESCALE:
2892     {
2893         double nScale = GetTextFitToSizeScale(GetSdrObject());
2894         rValue <<= nScale;
2895         break;
2896     }
2897
2898     case OWN_ATTR_UINAME_PLURAL:
2899     {
2900         rValue <<= GetSdrObject()->TakeObjNamePlural();
2901         break;
2902     }
2903     case OWN_ATTR_METAFILE:
2904     {
2905         SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
2906         if( pObj )
2907         {
2908             const Graphic* pGraphic = pObj->GetGraphic();
2909             if( pGraphic )
2910             {
2911                 bool bIsWMF = false;
2912                 if ( pGraphic->IsGfxLink() )
2913                 {
2914                     GfxLink aLnk = pGraphic->GetGfxLink();
2915                     if ( aLnk.GetType() == GfxLinkType::NativeWmf )
2916                     {
2917                         bIsWMF = true;
2918                         uno::Sequence<sal_Int8> aSeq(reinterpret_cast<sal_Int8 const *>(aLnk.GetData()), static_cast<sal_Int32>(aLnk.GetDataSize()));
2919                         rValue <<= aSeq;
2920                     }
2921                 }
2922                 if ( !bIsWMF )
2923                 {
2924                     // #119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically
2925                     GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile());
2926                     SvMemoryStream aDestStrm( 65535, 65535 );
2927                     ConvertGDIMetaFileToWMF( aMtf, aDestStrm, nullptr, false );
2928                     const uno::Sequence<sal_Int8> aSeq(
2929                         static_cast< const sal_Int8* >(aDestStrm.GetData()),
2930                         aDestStrm.GetEndOfData());
2931                     rValue <<= aSeq;
2932                 }
2933             }
2934         }
2935         else
2936         {
2937             rValue = GetBitmap( true );
2938         }
2939         break;
2940     }
2941
2942     case OWN_ATTR_TEXTCOLUMNS:
2943     {
2944         if (auto pTextObj = DynCastSdrTextObj(GetSdrObject()))
2945         {
2946             if (pTextObj->HasTextColumnsNumber() || pTextObj->HasTextColumnsSpacing())
2947             {
2948                 auto xIf = SvxXTextColumns_createInstance();
2949                 css::uno::Reference<css::text::XTextColumns> xCols(xIf, css::uno::UNO_QUERY_THROW);
2950                 xCols->setColumnCount(pTextObj->GetTextColumnsNumber());
2951                 css::uno::Reference<css::beans::XPropertySet> xProp(xIf, css::uno::UNO_QUERY_THROW);
2952                 xProp->setPropertyValue("AutomaticDistance",
2953                                         css::uno::Any(pTextObj->GetTextColumnsSpacing()));
2954                 rValue <<= xIf;
2955             }
2956         }
2957         break;
2958     }
2959
2960     case OWN_ATTR_HYPERLINK:
2961     {
2962         rValue <<= GetSdrObject()->getHyperlink();
2963         break;
2964     }
2965
2966     default:
2967         return false;
2968     }
2969     return true;
2970 }
2971
2972
2973 bool SvxShape::getPropertyStateImpl( const SfxItemPropertyMapEntry* pProperty, css::beans::PropertyState& rState )
2974 {
2975     if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
2976     {
2977         const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet();
2978
2979         if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SfxItemState::SET ||
2980             rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SfxItemState::SET )
2981         {
2982             rState = beans::PropertyState_DIRECT_VALUE;
2983         }
2984         else
2985         {
2986             rState = beans::PropertyState_AMBIGUOUS_VALUE;
2987         }
2988     }
2989     else if((( pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
2990        ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST )) && ( pProperty->nWID != SDRATTR_TEXTDIRECTION ) )
2991     {
2992         rState = beans::PropertyState_DIRECT_VALUE;
2993     }
2994     else
2995     {
2996         return false;
2997     }
2998
2999     return true;
3000 }
3001
3002
3003 bool SvxShape::setPropertyToDefaultImpl( const SfxItemPropertyMapEntry* pProperty )
3004 {
3005     if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
3006     {
3007         GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_STRETCH );
3008         GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_TILE );
3009         return true;
3010     }
3011     else if((pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
3012        ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST ))
3013     {
3014         return true;
3015     }
3016     else
3017     {
3018         return false;
3019     }
3020 }
3021
3022
3023 uno::Sequence< beans::PropertyState > SAL_CALL SvxShape::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
3024 {
3025     const sal_Int32 nCount = aPropertyName.getLength();
3026     uno::Sequence< beans::PropertyState > aRet( nCount );
3027
3028     std::transform(aPropertyName.begin(), aPropertyName.end(), aRet.getArray(),
3029         [this](const OUString& rName) -> beans::PropertyState { return getPropertyState(rName); });
3030
3031     return aRet;
3032 }
3033
3034
3035 void SAL_CALL SvxShape::setPropertyToDefault( const OUString& PropertyName )
3036 {
3037     if( mpImpl->mpMaster )
3038     {
3039         mpImpl->mpMaster->setPropertyToDefault( PropertyName );
3040     }
3041     else
3042     {
3043         _setPropertyToDefault( PropertyName );
3044     }
3045 }
3046
3047 void SvxShape::_setPropertyToDefault( const OUString& PropertyName )
3048 {
3049     ::SolarMutexGuard aGuard;
3050
3051     const SfxItemPropertyMapEntry* pProperty = mpPropSet->getPropertyMapEntry(PropertyName);
3052
3053     if( !HasSdrObject() || pProperty == nullptr )
3054         throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
3055
3056     if( !setPropertyToDefaultImpl( pProperty ) )
3057     {
3058         GetSdrObject()->ClearMergedItem( pProperty->nWID );
3059     }
3060
3061     GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
3062 }
3063
3064
3065 uno::Any SAL_CALL SvxShape::getPropertyDefault( const OUString& aPropertyName )
3066 {
3067     if( mpImpl->mpMaster )
3068     {
3069         return mpImpl->mpMaster->getPropertyDefault( aPropertyName );
3070     }
3071     else
3072     {
3073         return _getPropertyDefault( aPropertyName );
3074     }
3075 }
3076
3077 uno::Any SvxShape::_getPropertyDefault( const OUString& aPropertyName )
3078 {
3079     ::SolarMutexGuard aGuard;
3080
3081     const SfxItemPropertyMapEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
3082
3083     if( !HasSdrObject() || pMap == nullptr )
3084         throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
3085
3086     if(( pMap->nWID >= OWN_ATTR_VALUE_START && pMap->nWID <= OWN_ATTR_VALUE_END ) ||
3087        ( pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST ))
3088     {
3089         return getPropertyValue( aPropertyName );
3090     }
3091
3092     // get default from ItemPool
3093     if(!SfxItemPool::IsWhich(pMap->nWID))
3094         throw beans::UnknownPropertyException( "No WhichID " + OUString::number(pMap->nWID) + " for " + aPropertyName, static_cast<cppu::OWeakObject*>(this));
3095
3096     SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), pMap->nWID, pMap->nWID );
3097     aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
3098
3099     return GetAnyForItem( aSet, pMap );
3100 }
3101
3102 // XMultiPropertyStates
3103 void SvxShape::setAllPropertiesToDefault()
3104 {
3105     ::SolarMutexGuard aGuard;
3106
3107     SdrObject* pSdrObj = GetSdrObject();
3108     if( !pSdrObj )
3109         throw lang::DisposedException();
3110     pSdrObj->ClearMergedItem(); // nWhich == 0 => all
3111
3112     const SdrObjKind nObjId = pSdrObj->GetObjIdentifier();
3113     if(nObjId == SdrObjKind::Graphic) // SdrGrafObj
3114     {
3115         // defaults for graphic objects have changed:
3116         pSdrObj->SetMergedItem( XFillStyleItem( drawing::FillStyle_NONE ) );
3117         pSdrObj->SetMergedItem( XLineStyleItem( drawing::LineStyle_NONE ) );
3118     }
3119
3120     // #i68523# special handling for Svx3DCharacterModeItem, this is not saved
3121     // but needs to be sal_True in svx, pool default (false) in sch. Since sch
3122     // does not load lathe or extrude objects, it is possible to set the items
3123     // here.
3124     // For other solution possibilities, see task description.
3125     if( nObjId == SdrObjKind::E3D_Lathe /*E3dLatheObj*/ || nObjId == SdrObjKind::E3D_Extrusion /*E3dExtrudeObj*/ )
3126     {
3127         pSdrObj->SetMergedItem(Svx3DCharacterModeItem(true));
3128     }
3129
3130     pSdrObj->getSdrModelFromSdrObject().SetChanged();
3131 }
3132
3133 void SvxShape::setPropertiesToDefault(
3134     const uno::Sequence<OUString>& aPropertyNames )
3135 {
3136     for ( const auto& rPropertyName : aPropertyNames )
3137         setPropertyToDefault( rPropertyName );
3138 }
3139
3140 uno::Sequence<uno::Any> SvxShape::getPropertyDefaults(
3141     const uno::Sequence<OUString>& aPropertyNames )
3142 {
3143     ::std::vector<uno::Any> ret;
3144     ret.reserve(aPropertyNames.getLength());
3145     std::transform(aPropertyNames.begin(), aPropertyNames.end(), std::back_inserter(ret),
3146         [this](const OUString& rName) -> uno::Any { return getPropertyDefault(rName); });
3147     return uno::Sequence<uno::Any>( ret.data(), ret.size() );
3148 }
3149
3150
3151 // XServiceInfo
3152
3153 OUString SAL_CALL SvxShape::getImplementationName()
3154 {
3155     return "SvxShape";
3156 }
3157
3158 constexpr OUStringLiteral sUNO_service_style_ParagraphProperties = u"com.sun.star.style.ParagraphProperties";
3159 constexpr OUStringLiteral sUNO_service_style_ParagraphPropertiesComplex = u"com.sun.star.style.ParagraphPropertiesComplex";
3160 constexpr OUStringLiteral sUNO_service_style_ParagraphPropertiesAsian = u"com.sun.star.style.ParagraphPropertiesAsian";
3161 constexpr OUStringLiteral sUNO_service_style_CharacterProperties = u"com.sun.star.style.CharacterProperties";
3162 constexpr OUStringLiteral sUNO_service_style_CharacterPropertiesComplex = u"com.sun.star.style.CharacterPropertiesComplex";
3163 constexpr OUStringLiteral sUNO_service_style_CharacterPropertiesAsian = u"com.sun.star.style.CharacterPropertiesAsian";
3164
3165 constexpr OUStringLiteral sUNO_service_drawing_FillProperties    = u"com.sun.star.drawing.FillProperties";
3166 constexpr OUStringLiteral sUNO_service_drawing_TextProperties    = u"com.sun.star.drawing.TextProperties";
3167 constexpr OUStringLiteral sUNO_service_drawing_LineProperties    = u"com.sun.star.drawing.LineProperties";
3168 constexpr OUStringLiteral sUNO_service_drawing_ConnectorProperties = u"com.sun.star.drawing.ConnectorProperties";
3169 constexpr OUStringLiteral sUNO_service_drawing_MeasureProperties = u"com.sun.star.drawing.MeasureProperties";
3170 constexpr OUStringLiteral sUNO_service_drawing_ShadowProperties  = u"com.sun.star.drawing.ShadowProperties";
3171
3172 constexpr OUStringLiteral sUNO_service_drawing_RotationDescriptor = u"com.sun.star.drawing.RotationDescriptor";
3173
3174 constexpr OUStringLiteral sUNO_service_drawing_Text              = u"com.sun.star.drawing.Text";
3175 constexpr OUStringLiteral sUNO_service_drawing_GroupShape        = u"com.sun.star.drawing.GroupShape";
3176
3177 constexpr OUStringLiteral sUNO_service_drawing_CustomShapeProperties = u"com.sun.star.drawing.CustomShapeProperties";
3178 constexpr OUStringLiteral sUNO_service_drawing_CustomShape       = u"com.sun.star.drawing.CustomShape";
3179
3180 constexpr OUStringLiteral sUNO_service_drawing_PolyPolygonDescriptor = u"com.sun.star.drawing.PolyPolygonDescriptor";
3181 constexpr OUStringLiteral sUNO_service_drawing_PolyPolygonBezierDescriptor= u"com.sun.star.drawing.PolyPolygonBezierDescriptor";
3182
3183 constexpr OUStringLiteral sUNO_service_drawing_LineShape         = u"com.sun.star.drawing.LineShape";
3184 constexpr OUStringLiteral sUNO_service_drawing_Shape             = u"com.sun.star.drawing.Shape";
3185 constexpr OUStringLiteral sUNO_service_drawing_RectangleShape    = u"com.sun.star.drawing.RectangleShape";
3186 constexpr OUStringLiteral sUNO_service_drawing_EllipseShape      = u"com.sun.star.drawing.EllipseShape";
3187 constexpr OUStringLiteral sUNO_service_drawing_PolyPolygonShape  = u"com.sun.star.drawing.PolyPolygonShape";
3188 constexpr OUStringLiteral sUNO_service_drawing_PolyLineShape     = u"com.sun.star.drawing.PolyLineShape";
3189 constexpr OUStringLiteral sUNO_service_drawing_OpenBezierShape   = u"com.sun.star.drawing.OpenBezierShape";
3190 constexpr OUStringLiteral sUNO_service_drawing_ClosedBezierShape = u"com.sun.star.drawing.ClosedBezierShape";
3191 constexpr OUStringLiteral sUNO_service_drawing_TextShape         = u"com.sun.star.drawing.TextShape";
3192 constexpr OUStringLiteral sUNO_service_drawing_GraphicObjectShape = u"com.sun.star.drawing.GraphicObjectShape";
3193 constexpr OUStringLiteral sUNO_service_drawing_OLE2Shape         = u"com.sun.star.drawing.OLE2Shape";
3194 constexpr OUStringLiteral sUNO_service_drawing_PageShape         = u"com.sun.star.drawing.PageShape";
3195 constexpr OUStringLiteral sUNO_service_drawing_CaptionShape      = u"com.sun.star.drawing.CaptionShape";
3196 constexpr OUStringLiteral sUNO_service_drawing_MeasureShape      = u"com.sun.star.drawing.MeasureShape";
3197 constexpr OUStringLiteral sUNO_service_drawing_FrameShape        = u"com.sun.star.drawing.FrameShape";
3198 constexpr OUStringLiteral sUNO_service_drawing_ControlShape      = u"com.sun.star.drawing.ControlShape";
3199 constexpr OUStringLiteral sUNO_service_drawing_ConnectorShape    = u"com.sun.star.drawing.ConnectorShape";
3200 constexpr OUStringLiteral sUNO_service_drawing_MediaShape        = u"com.sun.star.drawing.MediaShape";
3201
3202
3203 uno::Sequence< OUString > SAL_CALL SvxShape::getSupportedServiceNames()
3204 {
3205     if( mpImpl->mpMaster )
3206     {
3207         return mpImpl->mpMaster->getSupportedServiceNames();
3208     }
3209     else
3210     {
3211         return _getSupportedServiceNames();
3212     }
3213 }
3214
3215 uno::Sequence< OUString > SvxShape::_getSupportedServiceNames()
3216 {
3217     ::SolarMutexGuard aGuard;
3218
3219     if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::Default)
3220     {
3221         const SdrObjKind nIdent = GetSdrObject()->GetObjIdentifier();
3222
3223         switch(nIdent)
3224         {
3225         case SdrObjKind::Group:
3226             {
3227                 static const uno::Sequence<OUString> aSvxShape_GroupServices
3228                         = { sUNO_service_drawing_GroupShape,
3229                             sUNO_service_drawing_Shape };
3230                 return aSvxShape_GroupServices;
3231             }
3232         case SdrObjKind::CustomShape:
3233             {
3234                 static const uno::Sequence<OUString> aSvxShape_CustomShapeServices
3235                         = { sUNO_service_drawing_CustomShape,
3236                             sUNO_service_drawing_Shape,
3237                             sUNO_service_drawing_CustomShapeProperties,
3238                             sUNO_service_drawing_FillProperties,
3239                             sUNO_service_drawing_LineProperties,
3240                             sUNO_service_drawing_Text,
3241                             sUNO_service_drawing_TextProperties,
3242                             sUNO_service_style_ParagraphProperties,
3243                             sUNO_service_style_ParagraphPropertiesComplex,
3244                             sUNO_service_style_ParagraphPropertiesAsian,
3245                             sUNO_service_style_CharacterProperties,
3246                             sUNO_service_style_CharacterPropertiesComplex,
3247                             sUNO_service_style_CharacterPropertiesAsian,
3248                             sUNO_service_drawing_ShadowProperties,
3249                             sUNO_service_drawing_RotationDescriptor };
3250                 return aSvxShape_CustomShapeServices;
3251             }
3252         case SdrObjKind::Line:
3253             {
3254                 static const uno::Sequence<OUString> aSvxShape_LineServices
3255                         = { sUNO_service_drawing_LineShape,
3256
3257                             sUNO_service_drawing_Shape,
3258                             sUNO_service_drawing_LineProperties,
3259
3260                             sUNO_service_drawing_Text,
3261                             sUNO_service_drawing_TextProperties,
3262                             sUNO_service_style_ParagraphProperties,
3263                             sUNO_service_style_ParagraphPropertiesComplex,
3264                             sUNO_service_style_ParagraphPropertiesAsian,
3265                             sUNO_service_style_CharacterProperties,
3266                             sUNO_service_style_CharacterPropertiesComplex,
3267                             sUNO_service_style_CharacterPropertiesAsian,
3268
3269                             sUNO_service_drawing_PolyPolygonDescriptor,
3270                             sUNO_service_drawing_ShadowProperties,
3271                             sUNO_service_drawing_RotationDescriptor };
3272                 return aSvxShape_LineServices;
3273             }
3274
3275         case SdrObjKind::Rectangle:
3276             {
3277                 static const uno::Sequence<OUString> aSvxShape_RectServices
3278                         = { sUNO_service_drawing_RectangleShape,
3279
3280                             sUNO_service_drawing_Shape,
3281                             sUNO_service_drawing_FillProperties,
3282                             sUNO_service_drawing_LineProperties,
3283                             sUNO_service_drawing_Text,
3284                             sUNO_service_drawing_TextProperties,
3285                             sUNO_service_style_ParagraphProperties,
3286                             sUNO_service_style_ParagraphPropertiesComplex,
3287                             sUNO_service_style_ParagraphPropertiesAsian,
3288                             sUNO_service_style_CharacterProperties,
3289                             sUNO_service_style_CharacterPropertiesComplex,
3290                             sUNO_service_style_CharacterPropertiesAsian,
3291
3292                             sUNO_service_drawing_ShadowProperties,
3293                             sUNO_service_drawing_RotationDescriptor };
3294                 return aSvxShape_RectServices;
3295             }
3296
3297         case SdrObjKind::CircleOrEllipse:
3298         case SdrObjKind::CircleSection:
3299         case SdrObjKind::CircleArc:
3300         case SdrObjKind::CircleCut:
3301             {
3302                 static const uno::Sequence<OUString> aSvxShape_CircServices
3303                         = { sUNO_service_drawing_EllipseShape,
3304
3305                             sUNO_service_drawing_Shape,
3306                             sUNO_service_drawing_FillProperties,
3307                             sUNO_service_drawing_LineProperties,
3308
3309                             sUNO_service_drawing_Text,
3310                             sUNO_service_drawing_TextProperties,
3311                             sUNO_service_style_ParagraphProperties,
3312                             sUNO_service_style_ParagraphPropertiesComplex,
3313                             sUNO_service_style_ParagraphPropertiesAsian,
3314                             sUNO_service_style_CharacterProperties,
3315                             sUNO_service_style_CharacterPropertiesComplex,
3316                             sUNO_service_style_CharacterPropertiesAsian,
3317
3318                             sUNO_service_drawing_ShadowProperties,
3319                             sUNO_service_drawing_RotationDescriptor };
3320                 return aSvxShape_CircServices;
3321             }
3322
3323         case SdrObjKind::PathPolyLine:
3324         case SdrObjKind::PolyLine:
3325             {
3326                 static const uno::Sequence<OUString> aSvxShape_PathServices
3327                         = { sUNO_service_drawing_PolyLineShape,
3328
3329                             sUNO_service_drawing_Shape,
3330                             sUNO_service_drawing_LineProperties,
3331
3332                             sUNO_service_drawing_PolyPolygonDescriptor,
3333
3334                             sUNO_service_drawing_Text,
3335                             sUNO_service_drawing_TextProperties,
3336                             sUNO_service_style_ParagraphProperties,
3337                             sUNO_service_style_ParagraphPropertiesComplex,
3338                             sUNO_service_style_ParagraphPropertiesAsian,
3339                             sUNO_service_style_CharacterProperties,
3340                             sUNO_service_style_CharacterPropertiesComplex,
3341                             sUNO_service_style_CharacterPropertiesAsian,
3342
3343                             sUNO_service_drawing_ShadowProperties,
3344                             sUNO_service_drawing_RotationDescriptor };
3345                 return aSvxShape_PathServices;
3346             }
3347
3348         case SdrObjKind::PathPoly:
3349         case SdrObjKind::Polygon:
3350             {
3351                 static const uno::Sequence<OUString> aSvxShape_PolyServices
3352                         = { sUNO_service_drawing_PolyPolygonShape,
3353
3354                             sUNO_service_drawing_Shape,
3355                             sUNO_service_drawing_LineProperties,
3356                             sUNO_service_drawing_FillProperties,
3357
3358                             sUNO_service_drawing_PolyPolygonDescriptor,
3359
3360                             sUNO_service_drawing_Text,
3361                             sUNO_service_drawing_TextProperties,
3362                             sUNO_service_style_ParagraphProperties,
3363                             sUNO_service_style_ParagraphPropertiesComplex,
3364                             sUNO_service_style_ParagraphPropertiesAsian,
3365                             sUNO_service_style_CharacterProperties,
3366                             sUNO_service_style_CharacterPropertiesComplex,
3367                             sUNO_service_style_CharacterPropertiesAsian,
3368
3369                             sUNO_service_drawing_ShadowProperties,
3370                             sUNO_service_drawing_RotationDescriptor };
3371                 return aSvxShape_PolyServices;
3372             }
3373
3374         case SdrObjKind::FreehandLine:
3375         case SdrObjKind::PathLine:
3376             {
3377                 static const uno::Sequence<OUString> aSvxShape_FreeLineServices
3378                         = { sUNO_service_drawing_OpenBezierShape,
3379
3380                             sUNO_service_drawing_Shape,
3381                             sUNO_service_drawing_LineProperties,
3382                             sUNO_service_drawing_FillProperties,
3383
3384                             sUNO_service_drawing_PolyPolygonBezierDescriptor,
3385
3386                             sUNO_service_drawing_Text,
3387                             sUNO_service_drawing_TextProperties,
3388                             sUNO_service_style_ParagraphProperties,
3389                             sUNO_service_style_ParagraphPropertiesComplex,
3390                             sUNO_service_style_ParagraphPropertiesAsian,
3391                             sUNO_service_style_CharacterProperties,
3392                             sUNO_service_style_CharacterPropertiesComplex,
3393                             sUNO_service_style_CharacterPropertiesAsian,
3394
3395                             sUNO_service_drawing_ShadowProperties,
3396                             sUNO_service_drawing_RotationDescriptor };
3397                 return aSvxShape_FreeLineServices;
3398             }
3399
3400         case SdrObjKind::FreehandFill:
3401         case SdrObjKind::PathFill:
3402             {
3403                 static const uno::Sequence<OUString> aSvxShape_FreeFillServices
3404                         = { sUNO_service_drawing_ClosedBezierShape,
3405
3406                             sUNO_service_drawing_Shape,
3407                             sUNO_service_drawing_LineProperties,
3408                             sUNO_service_drawing_FillProperties,
3409
3410                             sUNO_service_drawing_PolyPolygonBezierDescriptor,
3411
3412                             sUNO_service_drawing_Text,
3413                             sUNO_service_drawing_TextProperties,
3414                             sUNO_service_style_ParagraphProperties,
3415                             sUNO_service_style_ParagraphPropertiesComplex,
3416                             sUNO_service_style_ParagraphPropertiesAsian,
3417                             sUNO_service_style_CharacterProperties,
3418                             sUNO_service_style_CharacterPropertiesComplex,
3419                             sUNO_service_style_CharacterPropertiesAsian,
3420
3421                             sUNO_service_drawing_ShadowProperties,
3422                             sUNO_service_drawing_RotationDescriptor };
3423                 return aSvxShape_FreeFillServices;
3424             }
3425
3426         case SdrObjKind::OutlineText:
3427         case SdrObjKind::TitleText:
3428         case SdrObjKind::Text:
3429             {
3430                 static const uno::Sequence<OUString> aSvxShape_TextServices
3431                         = { sUNO_service_drawing_TextShape,
3432
3433                             sUNO_service_drawing_Shape,
3434                             sUNO_service_drawing_FillProperties,
3435                             sUNO_service_drawing_LineProperties,
3436
3437                             sUNO_service_drawing_Text,
3438                             sUNO_service_drawing_TextProperties,
3439                             sUNO_service_style_ParagraphProperties,
3440                             sUNO_service_style_ParagraphPropertiesComplex,
3441                             sUNO_service_style_ParagraphPropertiesAsian,
3442                             sUNO_service_style_CharacterProperties,
3443                             sUNO_service_style_CharacterPropertiesComplex,
3444                             sUNO_service_style_CharacterPropertiesAsian,
3445
3446                             sUNO_service_drawing_ShadowProperties,
3447                             sUNO_service_drawing_RotationDescriptor };
3448                 return aSvxShape_TextServices;
3449             }
3450
3451         case SdrObjKind::Graphic:
3452             {
3453                 static const uno::Sequence<OUString> aSvxShape_GrafServices
3454                         = { sUNO_service_drawing_GraphicObjectShape,
3455
3456                             sUNO_service_drawing_Shape,
3457
3458                             sUNO_service_drawing_Text,
3459                             sUNO_service_drawing_TextProperties,
3460                             sUNO_service_style_ParagraphProperties,
3461                             sUNO_service_style_ParagraphPropertiesComplex,
3462                             sUNO_service_style_ParagraphPropertiesAsian,
3463                             sUNO_service_style_CharacterProperties,
3464                             sUNO_service_style_CharacterPropertiesComplex,
3465                             sUNO_service_style_CharacterPropertiesAsian,
3466
3467                             sUNO_service_drawing_ShadowProperties,
3468                             sUNO_service_drawing_RotationDescriptor};
3469                 return aSvxShape_GrafServices;
3470             }
3471
3472         case SdrObjKind::OLE2:
3473             {
3474                 static const uno::Sequence<OUString> aSvxShape_Ole2Services
3475                         = { sUNO_service_drawing_OLE2Shape,
3476                             sUNO_service_drawing_Shape,
3477
3478                             // #i118485# Added Text, Shadow and Rotation
3479                             sUNO_service_drawing_Text,
3480                             sUNO_service_drawing_TextProperties,
3481                             sUNO_service_style_ParagraphProperties,
3482                             sUNO_service_style_ParagraphPropertiesComplex,
3483                             sUNO_service_style_ParagraphPropertiesAsian,
3484                             sUNO_service_style_CharacterProperties,
3485                             sUNO_service_style_CharacterPropertiesComplex,
3486                             sUNO_service_style_CharacterPropertiesAsian,
3487
3488                             sUNO_service_drawing_ShadowProperties,
3489                             sUNO_service_drawing_RotationDescriptor };
3490                 return aSvxShape_Ole2Services;
3491             }
3492
3493         case SdrObjKind::Caption:
3494             {
3495                 static const uno::Sequence<OUString> aSvxShape_CaptionServices
3496                         = { sUNO_service_drawing_CaptionShape,
3497
3498                             sUNO_service_drawing_Shape,
3499                             sUNO_service_drawing_FillProperties,
3500                             sUNO_service_drawing_LineProperties,
3501
3502                             sUNO_service_drawing_Text,
3503                             sUNO_service_drawing_TextProperties,
3504                             sUNO_service_style_ParagraphProperties,
3505                             sUNO_service_style_ParagraphPropertiesComplex,
3506                             sUNO_service_style_ParagraphPropertiesAsian,
3507                             sUNO_service_style_CharacterProperties,
3508                             sUNO_service_style_CharacterPropertiesComplex,
3509                             sUNO_service_style_CharacterPropertiesAsian,
3510
3511                             sUNO_service_drawing_ShadowProperties,
3512                             sUNO_service_drawing_RotationDescriptor };
3513                 return aSvxShape_CaptionServices;
3514             }
3515
3516         case SdrObjKind::Page:
3517             {
3518                 static const uno::Sequence<OUString> aSvxShape_PageServices
3519                         = { sUNO_service_drawing_PageShape,
3520                             sUNO_service_drawing_Shape };
3521                 return aSvxShape_PageServices;
3522             }
3523
3524         case SdrObjKind::Measure:
3525             {
3526                 static const uno::Sequence<OUString> aSvxShape_MeasureServices
3527                         = { sUNO_service_drawing_MeasureShape,
3528
3529                             sUNO_service_drawing_MeasureProperties,
3530
3531                             sUNO_service_drawing_Shape,
3532                             sUNO_service_drawing_LineProperties,
3533
3534                             sUNO_service_drawing_Text,
3535                             sUNO_service_drawing_TextProperties,
3536                             sUNO_service_style_ParagraphProperties,
3537                             sUNO_service_style_ParagraphPropertiesComplex,
3538                             sUNO_service_style_ParagraphPropertiesAsian,
3539                             sUNO_service_style_CharacterProperties,
3540                             sUNO_service_style_CharacterPropertiesComplex,
3541                             sUNO_service_style_CharacterPropertiesAsian,
3542
3543                             sUNO_service_drawing_PolyPolygonDescriptor,
3544                             sUNO_service_drawing_ShadowProperties,
3545                             sUNO_service_drawing_RotationDescriptor };
3546                 return aSvxShape_MeasureServices;
3547             }
3548
3549         case SdrObjKind::OLEPluginFrame:
3550             {
3551                 static const uno::Sequence<OUString> aSvxShape_FrameServices
3552                         = { sUNO_service_drawing_FrameShape,
3553                             sUNO_service_drawing_Shape };
3554                 return aSvxShape_FrameServices;
3555             }
3556
3557         case SdrObjKind::UNO:
3558             {
3559                 static const uno::Sequence<OUString> aSvxShape_UnoServices
3560                         = { sUNO_service_drawing_ControlShape,
3561                             sUNO_service_drawing_Shape };
3562                 return aSvxShape_UnoServices;
3563             }
3564
3565         case SdrObjKind::Edge:
3566             {
3567                 static const uno::Sequence<OUString> aSvxShape_EdgeServices
3568                         = { sUNO_service_drawing_ConnectorShape,
3569                             sUNO_service_drawing_ConnectorProperties,
3570
3571                             sUNO_service_drawing_Shape,
3572                             sUNO_service_drawing_LineProperties,
3573
3574                             sUNO_service_drawing_Text,
3575                             sUNO_service_drawing_TextProperties,
3576                             sUNO_service_style_ParagraphProperties,
3577                             sUNO_service_style_ParagraphPropertiesComplex,
3578                             sUNO_service_style_ParagraphPropertiesAsian,
3579                             sUNO_service_style_CharacterProperties,
3580                             sUNO_service_style_CharacterPropertiesComplex,
3581                             sUNO_service_style_CharacterPropertiesAsian,
3582
3583                             sUNO_service_drawing_PolyPolygonDescriptor,
3584                             sUNO_service_drawing_ShadowProperties,
3585                             sUNO_service_drawing_RotationDescriptor };
3586                 return aSvxShape_EdgeServices;
3587             }
3588         case SdrObjKind::Media:
3589             {
3590                 static const uno::Sequence<OUString> aSvxShape_MediaServices
3591                         = { sUNO_service_drawing_MediaShape,
3592                             sUNO_service_drawing_Shape };
3593                 return aSvxShape_MediaServices;
3594             }
3595         default: ;
3596         }
3597     }
3598     else if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::FmForm)
3599     {
3600 #if OSL_DEBUG_LEVEL > 0
3601         const SdrObjKind nIdent = GetSdrObject()->GetObjIdentifier();
3602         OSL_ENSURE( nIdent == SdrObjKind::UNO, "SvxShape::_getSupportedServiceNames: SdrInventor::FmForm, but no UNO object?" );
3603 #endif
3604         static const uno::Sequence<OUString> aSvxShape_UnoServices
3605                 = { sUNO_service_drawing_ControlShape,
3606                     sUNO_service_drawing_Shape };
3607         return aSvxShape_UnoServices;
3608     }
3609     OSL_FAIL( "SvxShape::_getSupportedServiceNames: could not determine object type!" );
3610     uno::Sequence< OUString > aSeq;
3611     return aSeq;
3612 }
3613
3614 sal_Bool SAL_CALL SvxShape::supportsService( const OUString& ServiceName )
3615 {
3616     return cppu::supportsService(this, ServiceName);
3617 }
3618
3619 // XGluePointsSupplier
3620 uno::Reference< container::XIndexContainer > SAL_CALL SvxShape::getGluePoints()
3621 {
3622     ::SolarMutexGuard aGuard;
3623     uno::Reference< container::XIndexContainer > xGluePoints( mxGluePoints );
3624
3625     if( HasSdrObject() && !xGluePoints.is() )
3626     {
3627         uno::Reference< container::XIndexContainer > xNew( SvxUnoGluePointAccess_createInstance( GetSdrObject() ), uno::UNO_QUERY );
3628         mxGluePoints = xGluePoints = xNew;
3629     }
3630
3631     return xGluePoints;
3632 }
3633
3634 // XChild
3635 uno::Reference<uno::XInterface> SAL_CALL SvxShape::getParent()
3636 {
3637     ::SolarMutexGuard aGuard;
3638     const SdrObject* pSdrObject(GetSdrObject());
3639
3640     if(nullptr != pSdrObject)
3641     {
3642         const SdrObjList* pParentSdrObjList(GetSdrObject()->getParentSdrObjListFromSdrObject());
3643
3644         if(nullptr != pParentSdrObjList)
3645         {
3646             // SdrObject is member of a SdrObjList. That may be a SdrObject
3647             // (SdrObjGroup or E3dScene) or a SdrPage.
3648             // Check for SdrObject first - using getSdrPageFromSdrObjList
3649             // *will* get the SdrPage even when the SdrObject is deep buried
3650             // in a construct of SdrObjGroup.
3651             // We want to ask for the direct parent here...
3652             SdrObject* pParentSdrObject(pParentSdrObjList->getSdrObjectFromSdrObjList());
3653
3654             if(nullptr != pParentSdrObject)
3655             {
3656                 // SdrObject is member of a SdrObject-based Group (SdrObjGroup or E3dScene).
3657                 return pParentSdrObject->getUnoShape();
3658             }
3659             else
3660             {
3661                 SdrPage* pParentSdrPage(pParentSdrObjList->getSdrPageFromSdrObjList());
3662
3663                 if(nullptr != pParentSdrPage)
3664                 {
3665                     // SdrObject is inserted to a SdrPage. Since
3666                     // we checked for getSdrObjectFromSdrObjList first,
3667                     // we can even say that it is directly member of that
3668                     // SdrPage.
3669                     return pParentSdrPage->getUnoPage();
3670                 }
3671             }
3672
3673             // not member of any SdrObjList, no parent
3674             OSL_FAIL( "SvxShape::getParent(  ): unexpected Parent SdrObjList" );
3675         }
3676     }
3677
3678     // no SdrObject, no parent
3679     return uno::Reference<uno::XInterface>();
3680 }
3681
3682 void SAL_CALL SvxShape::setParent( const css::uno::Reference< css::uno::XInterface >& )
3683 {
3684     throw lang::NoSupportException();
3685 }
3686
3687
3688 /** called from the XActionLockable interface methods on initial locking */
3689 void SvxShape::lock()
3690 {
3691 }
3692
3693
3694 /** called from the XActionLockable interface methods on final unlock */
3695 void SvxShape::unlock()
3696 {
3697 }
3698
3699
3700 // XActionLockable
3701 sal_Bool SAL_CALL SvxShape::isActionLocked(  )
3702 {
3703     ::SolarMutexGuard aGuard;
3704
3705     return mnLockCount != 0;
3706 }
3707
3708
3709 void SAL_CALL SvxShape::addActionLock(  )
3710 {
3711     ::SolarMutexGuard aGuard;
3712
3713     DBG_ASSERT( mnLockCount < 0xffff, "lock overflow in SvxShape!" );
3714     mnLockCount++;
3715
3716     if( mnLockCount == 1 )
3717         lock();
3718 }
3719
3720
3721 void SAL_CALL SvxShape::removeActionLock(  )
3722 {
3723     ::SolarMutexGuard aGuard;
3724
3725     DBG_ASSERT( mnLockCount > 0, "lock underflow in SvxShape!" );
3726     mnLockCount--;
3727
3728     if( mnLockCount == 0 )
3729         unlock();
3730 }
3731
3732
3733 void SAL_CALL SvxShape::setActionLocks( sal_Int16 nLock )
3734 {
3735     ::SolarMutexGuard aGuard;
3736
3737     if( (mnLockCount == 0) && (nLock != 0) )
3738         unlock();
3739
3740     if( (mnLockCount != 0) && (nLock == 0) )
3741         lock();
3742
3743     mnLockCount = static_cast<sal_uInt16>(nLock);
3744 }
3745
3746
3747 sal_Int16 SAL_CALL SvxShape::resetActionLocks(  )
3748 {
3749     ::SolarMutexGuard aGuard;
3750
3751     if( mnLockCount != 0 )
3752         unlock();
3753
3754     sal_Int16 nOldLocks = static_cast<sal_Int16>(mnLockCount);
3755     mnLockCount = 0;
3756
3757     return nOldLocks;
3758 }
3759
3760
3761 /** since polygon shapes can change their kind during editing, we have
3762     to recheck it here.
3763     Circle shapes also change their kind, but they are all treated equal
3764     so no update is necessary.
3765 */
3766 void SvxShape::updateShapeKind()
3767 {
3768     switch( mpImpl->mnObjId )
3769     {
3770         case SdrObjKind::Line:
3771         case SdrObjKind::Polygon:
3772         case SdrObjKind::PolyLine:
3773         case SdrObjKind::PathLine:
3774         case SdrObjKind::PathFill:
3775         case SdrObjKind::FreehandLine:
3776         case SdrObjKind::FreehandFill:
3777         case SdrObjKind::PathPoly:
3778         case SdrObjKind::PathPolyLine:
3779         {
3780             const SdrObjKind nId = GetSdrObject()->GetObjIdentifier();
3781
3782             if( nId != mpImpl->mnObjId )
3783             {
3784                 mpImpl->mnObjId = nId;
3785
3786             }
3787             break;
3788         }
3789         default: ;
3790     }
3791 }
3792
3793 SvxShapeText::SvxShapeText(SdrObject* pObject)
3794 : SvxShape( pObject, getSvxMapProvider().GetMap(SVXMAP_TEXT), getSvxMapProvider().GetPropertySet(SVXMAP_TEXT, SdrObject::GetGlobalDrawObjectItemPool()) ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
3795 {
3796     if( pObject )
3797         SetEditSource( new SvxTextEditSource( pObject, nullptr ) );
3798 }
3799
3800
3801 SvxShapeText::SvxShapeText(SdrObject* pObject, o3tl::span<const SfxItemPropertyMapEntry> pPropertyMap, const SvxItemPropertySet* pPropertySet)
3802 : SvxShape( pObject, pPropertyMap, pPropertySet ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
3803 {
3804     if( pObject )
3805         SetEditSource( new SvxTextEditSource( pObject, nullptr ) );
3806 }
3807
3808
3809 SvxShapeText::~SvxShapeText() noexcept
3810 {
3811     // check if only this instance is registered at the ranges
3812     DBG_ASSERT( (nullptr == GetEditSource()) || (GetEditSource()->getRanges().size()==1),
3813         "svx::SvxShapeText::~SvxShapeText(), text shape with living text ranges destroyed!");
3814 }
3815
3816 void SvxShapeText::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
3817 {
3818     if( pNewObj && (nullptr == GetEditSource()))
3819         SetEditSource( new SvxTextEditSource( pNewObj, nullptr ) );
3820     SvxShape::Create( pNewObj, pNewPage );
3821 }
3822
3823 // XInterface
3824
3825 uno::Any SAL_CALL SvxShapeText::queryInterface( const uno::Type & rType )
3826 {
3827     return SvxShape::queryInterface( rType );
3828 }
3829
3830
3831 uno::Any SAL_CALL SvxShapeText::queryAggregation( const uno::Type & rType )
3832 {
3833     uno::Any aAny( SvxShape::queryAggregation( rType ) );
3834     if( aAny.hasValue() )
3835         return aAny;
3836
3837     return SvxUnoTextBase::queryAggregation( rType );
3838 }
3839
3840
3841 // XServiceInfo
3842
3843 OUString SAL_CALL SvxShapeText::getImplementationName()
3844 {
3845     return "SvxShapeText";
3846 }
3847
3848
3849 uno::Sequence< OUString > SAL_CALL SvxShapeText::getSupportedServiceNames()
3850 {
3851     return SvxShape::getSupportedServiceNames();
3852 }
3853
3854
3855 sal_Bool SAL_CALL SvxShapeText::supportsService( const OUString& ServiceName )
3856 {
3857     return cppu::supportsService(static_cast<SvxShape*>(this), ServiceName);
3858 }
3859
3860     // XTypeProvider
3861
3862 uno::Sequence< uno::Type > SAL_CALL SvxShapeText::getTypes()
3863 {
3864     return SvxShape::getTypes();
3865 }
3866
3867 sal_Int64 SAL_CALL SvxShapeText::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
3868 {
3869     const sal_Int64 nReturn = SvxShape::getSomething( rId );
3870     if( nReturn )
3871         return nReturn;
3872
3873     return SvxUnoTextBase::getSomething( rId );
3874 }
3875
3876
3877 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeText::getImplementationId()
3878 {
3879     return css::uno::Sequence<sal_Int8>();
3880 }
3881
3882
3883 /** called from the XActionLockable interface methods on initial locking */
3884 void SvxShapeText::lock()
3885 {
3886     SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource());
3887     if( pEditSource )
3888         pEditSource->lock();
3889 }
3890
3891
3892 /** called from the XActionLockable interface methods on final unlock */
3893 void SvxShapeText::unlock()
3894 {
3895     SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource());
3896     if( pEditSource )
3897         pEditSource->unlock();
3898 }
3899
3900 // css::text::XTextRange
3901 uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getStart()
3902 {
3903     ::SolarMutexGuard aGuard;
3904     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
3905     if( pForwarder )
3906         ::GetSelection( maSelection, pForwarder );
3907     return SvxUnoTextBase::getStart();
3908
3909 }
3910
3911 uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getEnd()
3912 {
3913     ::SolarMutexGuard aGuard;
3914     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
3915     if( pForwarder )
3916         ::GetSelection( maSelection, pForwarder );
3917     return SvxUnoTextBase::getEnd();
3918 }
3919
3920 OUString SAL_CALL SvxShapeText::getString()
3921 {
3922     ::SolarMutexGuard aGuard;
3923     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
3924     if( pForwarder )
3925         ::GetSelection( maSelection, pForwarder );
3926     return SvxUnoTextBase::getString();
3927 }
3928
3929
3930 void SAL_CALL SvxShapeText::setString( const OUString& aString )
3931 {
3932     ::SolarMutexGuard aGuard;
3933     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
3934     if( pForwarder )
3935         ::GetSelection( maSelection, pForwarder );
3936     SvxUnoTextBase::setString( aString );
3937 }
3938
3939 // override these for special property handling in subcasses. Return true if property is handled
3940 bool SvxShapeText::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
3941 {
3942     // HACK-fix #99090#
3943     // since SdrTextObj::SetVerticalWriting exchanges
3944     // SDRATTR_TEXT_AUTOGROWWIDTH and SDRATTR_TEXT_AUTOGROWHEIGHT,
3945     // we have to set the textdirection here
3946
3947     if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
3948     {
3949         SdrTextObj* pTextObj = DynCastSdrTextObj( GetSdrObject() );
3950         if( pTextObj )
3951         {
3952             css::text::WritingMode eMode;
3953             if( rValue >>= eMode )
3954             {
3955                 pTextObj->SetVerticalWriting( eMode == css::text::WritingMode_TB_RL );
3956             }
3957         }
3958         return true;
3959     }
3960     return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
3961 }
3962
3963 bool SvxShapeText::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
3964 {
3965     if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
3966     {
3967         SdrTextObj* pTextObj = DynCastSdrTextObj( GetSdrObject() );
3968         if( pTextObj && pTextObj->IsVerticalWriting() )
3969             rValue <<= css::text::WritingMode_TB_RL;
3970         else
3971             rValue <<= css::text::WritingMode_LR_TB;
3972         return true;
3973     }
3974
3975     return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
3976 }
3977
3978 bool SvxShapeText::getPropertyStateImpl( const SfxItemPropertyMapEntry* pProperty, css::beans::PropertyState& rState )
3979 {
3980     return SvxShape::getPropertyStateImpl( pProperty, rState );
3981 }
3982
3983 bool SvxShapeText::setPropertyToDefaultImpl( const SfxItemPropertyMapEntry* pProperty )
3984 {
3985     return SvxShape::setPropertyToDefaultImpl( pProperty );
3986 }
3987
3988 SvxShapeRect::SvxShapeRect(SdrObject* pObj)
3989 : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_SHAPE), getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
3990 {
3991 }
3992
3993 SvxShapeRect::~SvxShapeRect() noexcept
3994 {
3995 }
3996
3997 uno::Any SAL_CALL SvxShapeRect::queryInterface( const uno::Type & rType )
3998 {
3999     return SvxShapeText::queryInterface( rType );
4000 }
4001
4002 uno::Any SAL_CALL SvxShapeRect::queryAggregation( const uno::Type & rType )
4003 {
4004     return SvxShapeText::queryAggregation( rType );
4005 }
4006
4007 // XServiceInfo
4008
4009 uno::Sequence< OUString > SvxShapeRect::getSupportedServiceNames()
4010 {
4011     return SvxShape::getSupportedServiceNames();
4012 }
4013
4014 /** returns a StarOffice API wrapper for the given SdrObject */
4015 uno::Reference< drawing::XShape > GetXShapeForSdrObject( SdrObject* pObj ) noexcept
4016 {
4017     uno::Reference< drawing::XShape > xShape( pObj->getUnoShape(), uno::UNO_QUERY );
4018     return xShape;
4019 }
4020
4021
4022 SdrObject* SdrObject::getSdrObjectFromXShape( const css::uno::Reference< css::uno::XInterface >& xInt )
4023 {
4024     SvxShape* pSvxShape = comphelper::getFromUnoTunnel<SvxShape>( xInt );
4025     return pSvxShape ? pSvxShape->GetSdrObject() : nullptr;
4026 }
4027
4028 uno::Any SvxItemPropertySet_getPropertyValue( const SfxItemPropertyMapEntry* pMap, const SfxItemSet& rSet )
4029 {
4030     if(!pMap || !pMap->nWID)
4031         return uno::Any();
4032
4033     // Check is for items that store either metric values if they are positive or percentage if they are negative.
4034     bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
4035     return SvxItemPropertySet::getPropertyValue( pMap, rSet, (pMap->nWID != SDRATTR_XMLATTRIBUTES), bDontConvertNegativeValues );
4036 }
4037
4038 void SvxItemPropertySet_setPropertyValue( const SfxItemPropertyMapEntry* pMap, const uno::Any& rVal, SfxItemSet& rSet )
4039 {
4040     if(!pMap || !pMap->nWID)
4041         return;
4042
4043     bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
4044     SvxItemPropertySet::setPropertyValue( pMap, rVal, rSet, bDontConvertNegativeValues );
4045 }
4046
4047 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */