/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx
Warning:	line 2498, column 16 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name svdobj.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <svx/svdobj.hxx>
21#include <config_features.h>

23#include <sal/config.h>
24#include <sal/log.hxx>
25#include <rtl/ustrbuf.hxx>

27#include <com/sun/star/lang/XComponent.hpp>
28#include <com/sun/star/text/RelOrientation.hpp>

30#include <basegfx/matrix/b2dhommatrix.hxx>
31#include <basegfx/matrix/b2dhommatrixtools.hxx>
32#include <basegfx/polygon/b2dpolygon.hxx>
33#include <basegfx/polygon/b2dpolygontools.hxx>
34#include <basegfx/polygon/b2dpolypolygoncutter.hxx>
35#include <basegfx/polygon/b2dpolypolygontools.hxx>
36#include <basegfx/range/b2drange.hxx>
37#include <drawinglayer/processor2d/contourextractor2d.hxx>
38#include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
39#include <editeng/editeng.hxx>
40#include <editeng/outlobj.hxx>
41#include <o3tl/deleter.hxx>
42#include <math.h>
43#include <svl/grabbagitem.hxx>
44#include <tools/bigint.hxx>
45#include <tools/diagnose_ex.h>
46#include <tools/helpers.hxx>
47#include <unotools/configmgr.hxx>
48#include <vcl/canvastools.hxx>
49#include <vcl/ptrstyle.hxx>
50#include <vector>

52#include <svx/shapepropertynotifier.hxx>
53#include <svx/svdotable.hxx>

55#include <svx/sdr/contact/displayinfo.hxx>
56#include <sdr/contact/objectcontactofobjlistpainter.hxx>
57#include <svx/sdr/contact/viewcontactofsdrobj.hxx>
58#include <sdr/properties/emptyproperties.hxx>
59#include <svx/sdrhittesthelper.hxx>
60#include <svx/sdrobjectuser.hxx>
61#include <svx/sdrobjectfilter.hxx>
62#include <svx/svddrag.hxx>
63#include <svx/svdetc.hxx>
64#include <svx/svdhdl.hxx>
65#include <svx/svditer.hxx>
66#include <svx/svdmodel.hxx>
67#include <svx/svdoashp.hxx>
68#include <svx/svdocapt.hxx>
69#include <svx/svdocirc.hxx>
70#include <svx/svdoedge.hxx>
71#include <svx/svdograf.hxx>
72#include <svx/svdogrp.hxx>
73#include <svx/svdomeas.hxx>
74#include <svx/svdomedia.hxx>
75#include <svx/svdoole2.hxx>
76#include <svx/svdopage.hxx>
77#include <svx/svdopath.hxx>
78#include <svx/svdorect.hxx>
79#include <svx/svdotext.hxx>
80#include <svx/svdouno.hxx>
81#include <svx/svdovirt.hxx>
82#include <svx/svdpage.hxx>
83#include <svx/svdpool.hxx>
84#include <svx/strings.hrc>
85#include <svx/dialmgr.hxx>
86#include <svx/svdtrans.hxx>
87#include <svx/svdundo.hxx>
88#include <svx/svdview.hxx>
89#include <sxlayitm.hxx>
90#include <sxlogitm.hxx>
91#include <sxmovitm.hxx>
92#include <sxoneitm.hxx>
93#include <sxopitm.hxx>
94#include <sxreoitm.hxx>
95#include <sxrooitm.hxx>
96#include <sxsaitm.hxx>
97#include <sxsoitm.hxx>
98#include <sxtraitm.hxx>
99#include <svx/unopage.hxx>
100#include <svx/unoshape.hxx>
101#include <svx/xfillit0.hxx>
102#include <svx/xflclit.hxx>
103#include <svx/xfltrit.hxx>
104#include <svx/xlineit0.hxx>
105#include <svx/xlnclit.hxx>
106#include <svx/xlnedwit.hxx>
107#include <svx/xlnstwit.hxx>
108#include <svx/xlntrit.hxx>
109#include <svx/xlnwtit.hxx>
110#include <svx/svdglue.hxx>
111#include <svx/svdsob.hxx>
112#include <svdobjplusdata.hxx>
113#include <svdobjuserdatalist.hxx>

115#include <unordered_set>

117#include <optional>
118#include <libxml/xmlwriter.h>
119#include <memory>

121using namespace ::com::sun::star;


124SdrObjUserCall::~SdrObjUserCall()
125{
126}

128void SdrObjUserCall::Changed(const SdrObject& /*rObj*/, SdrUserCallType /*eType*/, const tools::Rectangle& /*rOldBoundRect*/)
129{
130}

132SdrObjMacroHitRec::SdrObjMacroHitRec() :
  pVisiLayer(nullptr),
  pPageView(nullptr),
  nTol(0) {}


138SdrObjUserData::SdrObjUserData(SdrInventor nInv, sal_uInt16 nId) :
  nInventor(nInv),
  nIdentifier(nId) {}

142SdrObjUserData::SdrObjUserData(const SdrObjUserData& rData) :
  nInventor(rData.nInventor),
  nIdentifier(rData.nIdentifier) {}

146SdrObjUserData::~SdrObjUserData() {}

148SdrObjGeoData::SdrObjGeoData():
  bMovProt(false),
  bSizProt(false),
  bNoPrint(false),
  bClosedObj(false),
  mbVisible(true),
  mnLayerID(0)
155{
156}

158SdrObjGeoData::~SdrObjGeoData()
159{
160}

162SdrObjTransformInfoRec::SdrObjTransformInfoRec() :
  bMoveAllowed(true),
  bResizeFreeAllowed(true),
  bResizePropAllowed(true),
  bRotateFreeAllowed(true),
  bRotate90Allowed(true),
  bMirrorFreeAllowed(true),
  bMirror45Allowed(true),
  bMirror90Allowed(true),
  bTransparenceAllowed(true),
  bShearAllowed(true),
  bEdgeRadiusAllowed(true),
  bNoOrthoDesired(true),
  bNoContortion(true),
  bCanConvToPath(true),
  bCanConvToPoly(true),
  bCanConvToContour(false),
  bCanConvToPathLineToArea(true),
  bCanConvToPolyLineToArea(true) {}

182struct SdrObject::Impl
183{
  sdr::ObjectUserVector maObjectUsers;
  std::shared_ptr<DiagramDataInterface> mpDiagramData;
  std::optional<double> mnRelativeWidth;
  std::optional<double> mnRelativeHeight;
  sal_Int16               meRelativeWidthRelation;
  sal_Int16               meRelativeHeightRelation;

  Impl() :
      meRelativeWidthRelation(text::RelOrientation::PAGE_FRAME),
      meRelativeHeightRelation(text::RelOrientation::PAGE_FRAME) {}
194};


197// BaseProperties section

199std::unique_ptr<sdr::properties::BaseProperties> SdrObject::CreateObjectSpecificProperties()
200{
  return std::make_unique<sdr::properties::EmptyProperties>(*this);
202}

204sdr::properties::BaseProperties& SdrObject::GetProperties() const
205{
  if(!mpProperties)
  {
      // CAUTION(!) Do *not* call this during SdrObject construction,
      // that will lead to wrong type-casts (dependent on constructor-level)
      // and thus eventually create the wrong sdr::properties (!). Is there
      // a way to check if on the stack is a SdrObject-constructor (?)
      const_cast< SdrObject* >(this)->mpProperties =
          const_cast< SdrObject* >(this)->CreateObjectSpecificProperties();
  }

  return *mpProperties;
217}


220// ObjectUser section

222void SdrObject::AddObjectUser(sdr::ObjectUser& rNewUser)
223{
  mpImpl->maObjectUsers.push_back(&rNewUser);
225}

227void SdrObject::RemoveObjectUser(sdr::ObjectUser& rOldUser)
228{
  const sdr::ObjectUserVector::iterator aFindResult =
      std::find(mpImpl->maObjectUsers.begin(), mpImpl->maObjectUsers.end(), &rOldUser);
  if (aFindResult != mpImpl->maObjectUsers.end())
  {
      mpImpl->maObjectUsers.erase(aFindResult);
  }
235}


238// DrawContact section

240std::unique_ptr<sdr::contact::ViewContact> SdrObject::CreateObjectSpecificViewContact()
241{
  return std::make_unique<sdr::contact::ViewContactOfSdrObj>(*this);
243}

245sdr::contact::ViewContact& SdrObject::GetViewContact() const
246{
  if(!mpViewContact)
  {
      const_cast< SdrObject* >(this)->mpViewContact =
          const_cast< SdrObject* >(this)->CreateObjectSpecificViewContact();
  }

  return *mpViewContact;
254}

256// DrawContact support: Methods for handling Object changes
257void SdrObject::ActionChanged() const
258{
  // Do necessary ViewContact actions
  GetViewContact().ActionChanged();
261}

263SdrPage* SdrObject::getSdrPageFromSdrObject() const
264{
  if(getParentSdrObjListFromSdrObject())
  {
      return getParentSdrObjListFromSdrObject()->getSdrPageFromSdrObjList();
  }

  return nullptr;
271}

273SdrModel& SdrObject::getSdrModelFromSdrObject() const
274{
  return mrSdrModelFromSdrObject;
276}

278void SdrObject::setParentOfSdrObject(SdrObjList* pNewObjList)
279{
  if(getParentSdrObjListFromSdrObject() == pNewObjList)
      return;

  // remember current page
  SdrPage* pOldPage(getSdrPageFromSdrObject());

  // set new parent
  mpParentOfSdrObject = pNewObjList;

  // get new page
  SdrPage* pNewPage(getSdrPageFromSdrObject());

  // broadcast page change over objects if needed
  if(pOldPage != pNewPage)
  {
      handlePageChange(pOldPage, pNewPage);
  }
297}

299SdrObjList* SdrObject::getParentSdrObjListFromSdrObject() const
300{
  return mpParentOfSdrObject;
302}

304SdrObjList* SdrObject::getChildrenOfSdrObject() const
305{
  // default has no children
  return nullptr;
308}

310void SdrObject::SetBoundRectDirty()
311{
  aOutRect = tools::Rectangle();
313}

315#ifdef DBG_UTIL
316// SdrObjectLifetimeWatchDog:
317void impAddIncarnatedSdrObjectToSdrModel(const SdrObject& rSdrObject, SdrModel& rSdrModel)
318{
  rSdrModel.maAllIncarnatedObjects.insert(&rSdrObject);
320}
321void impRemoveIncarnatedSdrObjectToSdrModel(const SdrObject& rSdrObject, SdrModel& rSdrModel)
322{
  if(!rSdrModel.maAllIncarnatedObjects.erase(&rSdrObject))
  {
      SAL_WARN("svx","SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "325" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"),
 ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "325" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "325" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SdrObject::~SdrObject: Destructed incarnation of SdrObject not member of this SdrModel (!)"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx"),
 ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "325" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
327}
328#endif

330SdrObject::SdrObject(SdrModel& rSdrModel)
  mpFillGeometryDefiningShape(nullptr)
  ,mrSdrModelFromSdrObject(rSdrModel)
  ,pUserCall(nullptr)
  ,mpImpl(new Impl)
  ,mpParentOfSdrObject(nullptr)
  ,nOrdNum(0)
  ,mnNavigationPosition(SAL_MAX_UINT32((sal_uInt32) 0xFFFFFFFF))
  ,mnLayerID(0)
  ,mpSvxShape( nullptr )
  ,maWeakUnoShape()
  ,mbDoNotInsertIntoPageAutomatically(false)
342{
  bVirtObj         =false;
  bSnapRectDirty   =true;
  bMovProt         =false;
  bSizProt         =false;
  bNoPrint         =false;
  bEmptyPresObj    =false;
  bNotVisibleAsMaster=false;
  bClosedObj       =false;
  mbVisible        = true;

  // #i25616#
  mbLineIsOutsideGeometry = false;

  // #i25616#
  mbSupportTextIndentingOnLineWidthChange = false;

  bIsEdge=false;
  bIs3DObj=false;
  bMarkProt=false;
  bIsUnoObj=false;
363#ifdef DBG_UTIL
  // SdrObjectLifetimeWatchDog:
  impAddIncarnatedSdrObjectToSdrModel(*this, getSdrModelFromSdrObject());
366#endif
367}

369SdrObject::~SdrObject()
370{
  // Tell all the registered ObjectUsers that the page is in destruction.
  // And clear the vector. This means that user do not need to call RemoveObjectUser()
  // when they get called from ObjectInDestruction().
  sdr::ObjectUserVector aList;
  aList.swap(mpImpl->maObjectUsers);
  for(sdr::ObjectUser* pObjectUser : aList)
  {
      DBG_ASSERT(pObjectUser, "SdrObject::~SdrObject: corrupt ObjectUser list (!)")do { if (true && (!(pObjectUser))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "378" ": "), "%s", "SdrObject::~SdrObject: corrupt ObjectUser list (!)"
); } } while (false);
      pObjectUser->ObjectInDestruction(*this);
  }

  // UserCall
  SendUserCall(SdrUserCallType::Delete, GetLastBoundRect());
  o3tl::reset_preserve_ptr_during(pPlusData);

  pGrabBagItem.reset();
  mpProperties.reset();
  mpViewContact.reset();

390#ifdef DBG_UTIL
  // SdrObjectLifetimeWatchDog:
  impRemoveIncarnatedSdrObjectToSdrModel(*this, getSdrModelFromSdrObject());
393#endif
394}

396void SdrObject::Free( SdrObject*& _rpObject )
397{
  SdrObject* pObject = _rpObject; _rpObject = nullptr;

  if(nullptr == pObject)
  {
      // nothing to do
      return;
  }

  SvxShape* pShape(pObject->getSvxShape());

  if(pShape)
  {
      if(pShape->HasSdrObjectOwnership())
      {
          // only the SvxShape is allowed to delete me, and will reset
          // the ownership before doing so
          return;
      }
      else
      {
          // not only delete pObject, but also need to dispose uno shape
          try
          {
              pShape->InvalidateSdrObject();
              uno::Reference< lang::XComponent > xShapeComp( pObject->getWeakUnoShape(), uno::UNO_QUERY_THROW );
              xShapeComp->dispose();
          }
          catch( const uno::Exception& )
          {
              DBG_UNHANDLED_EXCEPTION("svx")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "427" ": ", "svx" );;
          }
      }
  }

  delete pObject;
433}

435void SdrObject::SetRectsDirty(bool bNotMyself, bool bRecursive)
436{
  if (!bNotMyself)
  {
      SetBoundRectDirty();
      bSnapRectDirty=true;
  }

  if (bRecursive && nullptr != getParentSdrObjListFromSdrObject())
  {
      getParentSdrObjListFromSdrObject()->SetSdrObjListRectsDirty();
  }
447}

449void SdrObject::handlePageChange(SdrPage* pOldPage, SdrPage* pNewPage)
450{
  // The creation of the UNO shape in SdrObject::getUnoShape is influenced
  // by pPage, so when the page changes we need to discard the cached UNO
  // shape so that a new one will be created.
  // If the page is changing to another page with the same model, we
  // assume they create compatible UNO shape objects so we shouldn't have
  // to invalidate.
  // TTTT: This causes quite some problems in SvxDrawPage::add when used
  // e.g. from Writer - the SdrObject may be cloned to target model, and
  // the xShape was added to it by purpose (see there). Thus it will be
  // good to think about if this is really needed - it *seems* to be intended
  // for a xShape being a on-demand-creatable resource - with the argument that
  // the SdrPage/UnoPage used influences the SvxShape creation. This uses
  // resources and would be nice to get rid of anyways.
  if(nullptr == pOldPage || nullptr == pNewPage)
  {
      SvxShape* const pShape(getSvxShape());

      if (pShape && !pShape->HasSdrObjectOwnership())
      {
          setUnoShape(nullptr);
      }
  }
473}

475// init global static itempool
476SdrItemPool* SdrObject::mpGlobalItemPool = nullptr;

478SdrItemPool& SdrObject::GetGlobalDrawObjectItemPool()
479{
  if(!mpGlobalItemPool)
  {
      mpGlobalItemPool = new SdrItemPool();
      SfxItemPool* pGlobalOutlPool = EditEngine::CreatePool();
      mpGlobalItemPool->SetSecondaryPool(pGlobalOutlPool);
      mpGlobalItemPool->SetDefaultMetric(SdrEngineDefaults::GetMapUnit());
      mpGlobalItemPool->FreezeIdRanges();
  }

  return *mpGlobalItemPool;
490}

492void SdrObject::SetRelativeWidth( double nValue )
493{
  mpImpl->mnRelativeWidth = nValue;
495}

497void SdrObject::SetRelativeWidthRelation( sal_Int16 eValue )
498{
  mpImpl->meRelativeWidthRelation = eValue;
500}

502void SdrObject::SetRelativeHeight( double nValue )
503{
  mpImpl->mnRelativeHeight = nValue;
505}

507void SdrObject::SetRelativeHeightRelation( sal_Int16 eValue )
508{
  mpImpl->meRelativeHeightRelation = eValue;
510}

512const double* SdrObject::GetRelativeWidth( ) const
513{
  if (!mpImpl->mnRelativeWidth)
      return nullptr;

  return &*mpImpl->mnRelativeWidth;
518}

520sal_Int16 SdrObject::GetRelativeWidthRelation() const
521{
  return mpImpl->meRelativeWidthRelation;
523}

525const double* SdrObject::GetRelativeHeight( ) const
526{
  if (!mpImpl->mnRelativeHeight)
      return nullptr;

  return &*mpImpl->mnRelativeHeight;
531}

533sal_Int16 SdrObject::GetRelativeHeightRelation() const
534{
  return mpImpl->meRelativeHeightRelation;
536}

538void SdrObject::SetDiagramData(std::shared_ptr<DiagramDataInterface> pDiagramData)
539{
  mpImpl->mpDiagramData = pDiagramData;
541}

543std::shared_ptr<DiagramDataInterface> SdrObject::GetDiagramData() const
544{
  return mpImpl->mpDiagramData;
546}

548SfxItemPool& SdrObject::GetObjectItemPool() const
549{
  return getSdrModelFromSdrObject().GetItemPool();
551}

553SdrInventor SdrObject::GetObjInventor()   const
554{
  return SdrInventor::Default;
556}

558sal_uInt16 SdrObject::GetObjIdentifier() const
559{
  return sal_uInt16(OBJ_NONE);
561}

563void SdrObject::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
564{
  rInfo.bRotateFreeAllowed=false;
  rInfo.bMirrorFreeAllowed=false;
  rInfo.bTransparenceAllowed = false;
  rInfo.bShearAllowed     =false;
  rInfo.bEdgeRadiusAllowed=false;
  rInfo.bCanConvToPath    =false;
  rInfo.bCanConvToPoly    =false;
  rInfo.bCanConvToContour = false;
  rInfo.bCanConvToPathLineToArea=false;
  rInfo.bCanConvToPolyLineToArea=false;
575}

577SdrLayerID SdrObject::GetLayer() const
578{
  return mnLayerID;
580}

582void SdrObject::getMergedHierarchySdrLayerIDSet(SdrLayerIDSet& rSet) const
583{
  rSet.Set(GetLayer());
  SdrObjList* pOL=GetSubList();
  if (pOL!=nullptr) {
      const size_t nObjCount = pOL->GetObjCount();
      for (size_t nObjNum = 0; nObjNum<nObjCount; ++nObjNum) {
          pOL->GetObj(nObjNum)->getMergedHierarchySdrLayerIDSet(rSet);
      }
  }
592}

594void SdrObject::NbcSetLayer(SdrLayerID nLayer)
595{
  mnLayerID = nLayer;
597}

599void SdrObject::SetLayer(SdrLayerID nLayer)
600{
  NbcSetLayer(nLayer);
  SetChanged();
  BroadcastObjectChange();
604}

606void SdrObject::AddListener(SfxListener& rListener)
607{
  ImpForcePlusData();
  if (pPlusData->pBroadcast==nullptr) pPlusData->pBroadcast.reset(new SfxBroadcaster);

  // SdrEdgeObj may be connected to same SdrObject on both ends so allow it
  // to listen twice
  SdrEdgeObj const*const pEdge(dynamic_cast<SdrEdgeObj const*>(&rListener));
  rListener.StartListening(*pPlusData->pBroadcast, pEdge ? DuplicateHandling::Allow : DuplicateHandling::Unexpected);
615}

617void SdrObject::RemoveListener(SfxListener& rListener)
618{
  if (pPlusData!=nullptr && pPlusData->pBroadcast!=nullptr) {
      rListener.EndListening(*pPlusData->pBroadcast);
      if (!pPlusData->pBroadcast->HasListeners()) {
          pPlusData->pBroadcast.reset();
      }
  }
625}

627const SfxBroadcaster* SdrObject::GetBroadcaster() const
628{
  return pPlusData!=nullptr ? pPlusData->pBroadcast.get() : nullptr;
630}

632void SdrObject::AddReference(SdrVirtObj& rVrtObj)
633{
  AddListener(rVrtObj);
635}

637void SdrObject::DelReference(SdrVirtObj& rVrtObj)
638{
  RemoveListener(rVrtObj);
640}

642bool SdrObject::IsGroupObject() const
643{
  return GetSubList()!=nullptr;
645}

647SdrObjList* SdrObject::GetSubList() const
648{
  return nullptr;
650}

652SdrObject* SdrObject::getParentSdrObjectFromSdrObject() const
653{
  SdrObjList* pParent(getParentSdrObjListFromSdrObject());

  if(nullptr == pParent)
  {
      return nullptr;
  }

  return pParent->getSdrObjectFromSdrObjList();
662}

664void SdrObject::SetName(const OUString& rStr)
665{
  if (!rStr.isEmpty() && !pPlusData)
  {
      ImpForcePlusData();
  }

  if(!(pPlusData && pPlusData->aObjName != rStr))
      return;

  // Undo/Redo for setting object's name (#i73249#)
  bool bUndo( false );
  if ( getSdrModelFromSdrObject().IsUndoEnabled() )
  {
      bUndo = true;
      std::unique_ptr<SdrUndoAction> pUndoAction =
              SdrUndoFactory::CreateUndoObjectStrAttr(
                                              *this,
                                              SdrUndoObjStrAttr::ObjStrAttrType::Name,
                                              GetName(),
                                              rStr );
      getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() );
      getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) );
  }
  pPlusData->aObjName = rStr;
  // Undo/Redo for setting object's name (#i73249#)
  if ( bUndo )
  {
      getSdrModelFromSdrObject().EndUndo();
  }
  SetChanged();
  BroadcastObjectChange();
696}

698OUString SdrObject::GetName() const
699{
  if(pPlusData)
  {
      return pPlusData->aObjName;
  }

  return OUString();
706}

708void SdrObject::SetTitle(const OUString& rStr)
709{
  if (!rStr.isEmpty() && !pPlusData)
  {
      ImpForcePlusData();
  }

  if(!(pPlusData && pPlusData->aObjTitle != rStr))
      return;

  // Undo/Redo for setting object's title (#i73249#)
  bool bUndo( false );
  if ( getSdrModelFromSdrObject().IsUndoEnabled() )
  {
      bUndo = true;
      std::unique_ptr<SdrUndoAction> pUndoAction =
              SdrUndoFactory::CreateUndoObjectStrAttr(
                                              *this,
                                              SdrUndoObjStrAttr::ObjStrAttrType::Title,
                                              GetTitle(),
                                              rStr );
      getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() );
      getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) );
  }
  pPlusData->aObjTitle = rStr;
  // Undo/Redo for setting object's title (#i73249#)
  if ( bUndo )
  {
      getSdrModelFromSdrObject().EndUndo();
  }
  SetChanged();
  BroadcastObjectChange();
740}

742OUString SdrObject::GetTitle() const
743{
  if(pPlusData)
  {
      return pPlusData->aObjTitle;
  }

  return OUString();
750}

752void SdrObject::SetDescription(const OUString& rStr)
753{
  if (!rStr.isEmpty() && !pPlusData)
  {
      ImpForcePlusData();
  }

  if(!(pPlusData && pPlusData->aObjDescription != rStr))
      return;

  // Undo/Redo for setting object's description (#i73249#)
  bool bUndo( false );
  if ( getSdrModelFromSdrObject().IsUndoEnabled() )
  {
      bUndo = true;
      std::unique_ptr<SdrUndoAction> pUndoAction =
              SdrUndoFactory::CreateUndoObjectStrAttr(
                                              *this,
                                              SdrUndoObjStrAttr::ObjStrAttrType::Description,
                                              GetDescription(),
                                              rStr );
      getSdrModelFromSdrObject().BegUndo( pUndoAction->GetComment() );
      getSdrModelFromSdrObject().AddUndo( std::move(pUndoAction) );
  }
  pPlusData->aObjDescription = rStr;
  // Undo/Redo for setting object's description (#i73249#)
  if ( bUndo )
  {
      getSdrModelFromSdrObject().EndUndo();
  }
  SetChanged();
  BroadcastObjectChange();
784}

786OUString SdrObject::GetDescription() const
787{
  if(pPlusData)
  {
      return pPlusData->aObjDescription;
  }

  return OUString();
794}

796sal_uInt32 SdrObject::GetOrdNum() const
797{
  if (nullptr != getParentSdrObjListFromSdrObject())
  {
      if (getParentSdrObjListFromSdrObject()->IsObjOrdNumsDirty())
      {
          getParentSdrObjListFromSdrObject()->RecalcObjOrdNums();
      }
  } else const_cast<SdrObject*>(this)->nOrdNum=0;
  return nOrdNum;
806}


809void SdrObject::SetOrdNum(sal_uInt32 nNum)
810{
  nOrdNum = nNum;
812}

814void SdrObject::GetGrabBagItem(css::uno::Any& rVal) const
815{
  if (pGrabBagItem != nullptr)
      pGrabBagItem->QueryValue(rVal);
  else
      rVal <<= uno::Sequence<beans::PropertyValue>();
820}

822void SdrObject::SetGrabBagItem(const css::uno::Any& rVal)
823{
  if (pGrabBagItem == nullptr)
      pGrabBagItem.reset(new SfxGrabBagItem);

  pGrabBagItem->PutValue(rVal, 0);

  SetChanged();
  BroadcastObjectChange();
831}

833sal_uInt32 SdrObject::GetNavigationPosition() const
834{
  if (nullptr != getParentSdrObjListFromSdrObject() && getParentSdrObjListFromSdrObject()->RecalcNavigationPositions())
  {
      return mnNavigationPosition;
  }
  else
      return GetOrdNum();
841}


844void SdrObject::SetNavigationPosition (const sal_uInt32 nNewPosition)
845{
  mnNavigationPosition = nNewPosition;
847}


850// To make clearer that this method may trigger RecalcBoundRect and thus may be
851// expensive and sometimes problematic (inside a bigger object change you will get
852// non-useful BoundRects sometimes) I rename that method from GetBoundRect() to
853// GetCurrentBoundRect().
854const tools::Rectangle& SdrObject::GetCurrentBoundRect() const
855{
  if(aOutRect.IsEmpty())
  {
      const_cast< SdrObject* >(this)->RecalcBoundRect();
  }

  return aOutRect;
862}

864// To have a possibility to get the last calculated BoundRect e.g for producing
865// the first rectangle for repaints (old and new need to be used) without forcing
866// a RecalcBoundRect (which may be problematical and expensive sometimes) I add here
867// a new method for accessing the last BoundRect.
868const tools::Rectangle& SdrObject::GetLastBoundRect() const
869{
  return aOutRect;
871}

873void SdrObject::RecalcBoundRect()
874{
  // #i101680# suppress BoundRect calculations on import(s)
  if ((getSdrModelFromSdrObject().isLocked()) || utl::ConfigManager::IsFuzzing())
      return;

  // central new method which will calculate the BoundRect using primitive geometry
  if(!aOutRect.IsEmpty())
      return;

  // Use view-independent data - we do not want any connections
  // to e.g. GridOffset in SdrObject-level
  const drawinglayer::primitive2d::Primitive2DContainer& xPrimitives(GetViewContact().getViewIndependentPrimitive2DContainer());

  if(xPrimitives.empty())
      return;

  // use neutral ViewInformation and get the range of the primitives
  const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
  const basegfx::B2DRange aRange(xPrimitives.getB2DRange(aViewInformation2D));

  if(!aRange.isEmpty())
  {
      aOutRect = tools::Rectangle(
          static_cast<long>(floor(aRange.getMinX())),
          static_cast<long>(floor(aRange.getMinY())),
          static_cast<long>(ceil(aRange.getMaxX())),
          static_cast<long>(ceil(aRange.getMaxY())));
      return;
  }
903}

905void SdrObject::BroadcastObjectChange() const
906{
  if ((getSdrModelFromSdrObject().isLocked()) || utl::ConfigManager::IsFuzzing())
      return;

  bool bPlusDataBroadcast(pPlusData && pPlusData->pBroadcast);
  bool bObjectChange(IsInserted());

  if(!(bPlusDataBroadcast || bObjectChange))
      return;

  SdrHint aHint(SdrHintKind::ObjectChange, *this);

  if(bPlusDataBroadcast)
  {
      pPlusData->pBroadcast->Broadcast(aHint);
  }

  if(bObjectChange)
  {
      getSdrModelFromSdrObject().Broadcast(aHint);
  }
927}

929void SdrObject::SetChanged()
930{
  // For testing purposes, use the new ViewContact for change
  // notification now.
  ActionChanged();

  // TTTT Need to check meaning/usage of IsInserted in one
  // of the next changes. It should not mean to have a SdrModel
  // set (this is guaranteed now), but should be connected to
  // being added to a SdrPage (?)
  // TTTT tdf#120066 Indeed - This triggers e.g. by CustomShape
  // geometry-presenting SdrObjects that are in a SdrObjGroup,
  // but the SdrObjGroup is *by purpose* not inserted.
  // Need to check deeper and maybe identify all ::IsInserted()
  // calls by rename and let the compiler work...
  if(nullptr != getSdrPageFromSdrObject())
  {
      getSdrModelFromSdrObject().SetChanged();
  }
948}

950// tooling for painting a single object to an OutputDevice.
951void SdrObject::SingleObjectPainter(OutputDevice& rOut) const
952{
  sdr::contact::SdrObjectVector aObjectVector;
  aObjectVector.push_back(const_cast< SdrObject* >(this));

  sdr::contact::ObjectContactOfObjListPainter aPainter(rOut, aObjectVector, getSdrPageFromSdrObject());
  sdr::contact::DisplayInfo aDisplayInfo;

  aPainter.ProcessDisplay(aDisplayInfo);
960}

962bool SdrObject::LineGeometryUsageIsNecessary() const
963{
  drawing::LineStyle eXLS = GetMergedItem(XATTR_LINESTYLE).GetValue();
  return (eXLS != drawing::LineStyle_NONE);
966}

968bool SdrObject::HasLimitedRotation() const
969{
  // RotGrfFlyFrame: Default is false, support full rotation
  return false;
972}

974SdrObject* SdrObject::CloneSdrObject(SdrModel& rTargetModel) const
975{
  return CloneHelper< SdrObject >(rTargetModel);
977}

979SdrObject& SdrObject::operator=(const SdrObject& rObj)
980{
  if( this == &rObj )
      return *this;

  mpProperties.reset();
  mpViewContact.reset();

  // The CloneSdrObject() method uses the local copy constructor from the individual
  // sdr::properties::BaseProperties class. Since the target class maybe for another
  // draw object, an SdrObject needs to be provided, as in the normal constructor.
  mpProperties = rObj.GetProperties().Clone(*this);

  aOutRect=rObj.aOutRect;
  mnLayerID = rObj.mnLayerID;
  aAnchor =rObj.aAnchor;
  bVirtObj=rObj.bVirtObj;
  bSizProt=rObj.bSizProt;
  bMovProt=rObj.bMovProt;
  bNoPrint=rObj.bNoPrint;
  mbVisible=rObj.mbVisible;
  bMarkProt=rObj.bMarkProt;
  bEmptyPresObj =rObj.bEmptyPresObj;
  bNotVisibleAsMaster=rObj.bNotVisibleAsMaster;
  bSnapRectDirty=true;
  pPlusData.reset();
  if (rObj.pPlusData!=nullptr) {
      pPlusData.reset(rObj.pPlusData->Clone(this));
  }
  if (pPlusData!=nullptr && pPlusData->pBroadcast!=nullptr) {
      pPlusData->pBroadcast.reset(); // broadcaster isn't copied
  }

  pGrabBagItem.reset();
  if (rObj.pGrabBagItem!=nullptr)
      pGrabBagItem.reset(rObj.pGrabBagItem->Clone());
  return *this;
1016}

1018OUString SdrObject::TakeObjNameSingul() const
1019{
  OUStringBuffer sName(SvxResId(STR_ObjNameSingulNONEreinterpret_cast<char const *>("STR_ObjNameSingulNONE" "\004"
 u8"Drawing object")));

  OUString aName(GetName());
  if (!aName.isEmpty())
  {
      sName.append(' ');
      sName.append('\'');
      sName.append(aName);
      sName.append('\'');
  }
  return sName.makeStringAndClear();
1031}

1033OUString SdrObject::TakeObjNamePlural() const
1034{
  return SvxResId(STR_ObjNamePluralNONEreinterpret_cast<char const *>("STR_ObjNamePluralNONE" "\004"
 u8"Drawing objects"));
1036}

1038OUString SdrObject::ImpGetDescriptionStr(const char* pStrCacheID) const
1039{
  OUString aStr = SvxResId(pStrCacheID);
  sal_Int32 nPos = aStr.indexOf("%1");
  if (nPos >= 0)
  {
      // Replace '%1' with the object name.
      OUString aObjName(TakeObjNameSingul());
      aStr = aStr.replaceAt(nPos, 2, aObjName);
  }

  nPos = aStr.indexOf("%2");
  if (nPos >= 0)
      // Replace '%2' with the passed value.
      aStr = aStr.replaceAt(nPos, 2, "0");
  return aStr;
1054}

1056void SdrObject::ImpForcePlusData()
1057{
  if (!pPlusData)
      pPlusData.reset( new SdrObjPlusData );
1060}

1062OUString SdrObject::GetMetrStr(long nVal) const
1063{
  return getSdrModelFromSdrObject().GetMetricString(nVal);
1065}

1067basegfx::B2DPolyPolygon SdrObject::TakeXorPoly() const
1068{
  basegfx::B2DPolyPolygon aRetval;
  const tools::Rectangle aR(GetCurrentBoundRect());
  aRetval.append(basegfx::utils::createPolygonFromRect(vcl::unotools::b2DRectangleFromRectangle(aR)));

  return aRetval;
1074}

1076basegfx::B2DPolyPolygon SdrObject::TakeContour() const
1077{
  basegfx::B2DPolyPolygon aRetval;

  // create cloned object without text, but with drawing::LineStyle_SOLID,
  // COL_BLACK as line color and drawing::FillStyle_NONE
  SdrObject* pClone(CloneSdrObject(getSdrModelFromSdrObject()));

  if(pClone)
  {
      const SdrTextObj* pTextObj = dynamic_cast< const SdrTextObj* >(this);

      if(pTextObj)
      {
          // no text and no text animation
          pClone->SetMergedItem(SdrTextAniKindItem(SdrTextAniKind::NONE));
          pClone->SetOutlinerParaObject(nullptr);
      }

      const SdrEdgeObj* pEdgeObj = dynamic_cast< const SdrEdgeObj* >(this);

      if(pEdgeObj)
      {
          // create connections if connector, will be cleaned up when
          // deleting the connector again
          SdrObject* pLeft = pEdgeObj->GetConnectedNode(true);
          SdrObject* pRight = pEdgeObj->GetConnectedNode(false);

          if(pLeft)
          {
              pClone->ConnectToNode(true, pLeft);
          }

          if(pRight)
          {
              pClone->ConnectToNode(false, pRight);
          }
      }

      SfxItemSet aNewSet(GetObjectItemPool());

      // #i101980# ignore LineWidth; that's what the old implementation
      // did. With line width, the result may be huge due to fat/thick
      // line decompositions
      aNewSet.Put(XLineWidthItem(0));

      // solid black lines and no fill
      aNewSet.Put(XLineStyleItem(drawing::LineStyle_SOLID));
      aNewSet.Put(XLineColorItem(OUString(), COL_BLACK));
      aNewSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
      pClone->SetMergedItemSet(aNewSet);

      // get sequence from clone
      const sdr::contact::ViewContact& rVC(pClone->GetViewContact());
      const drawinglayer::primitive2d::Primitive2DContainer& xSequence(rVC.getViewIndependentPrimitive2DContainer());

      if(!xSequence.empty())
      {
          // use neutral ViewInformation
          const drawinglayer::geometry::ViewInformation2D aViewInformation2D;

          // create extractor, process and get result (with hairlines as opened polygons)
          drawinglayer::processor2d::ContourExtractor2D aExtractor(aViewInformation2D, false);
          aExtractor.process(xSequence);
          const basegfx::B2DPolyPolygonVector& rResult(aExtractor.getExtractedContour());
          const sal_uInt32 nSize(rResult.size());

          // when count is one, it is implied that the object has only its normal
          // contour anyways and TakeContour() is to return an empty PolyPolygon
          // (see old implementation for historical reasons)
          if(nSize > 1)
          {
              // the topology for contour is correctly a vector of PolyPolygons; for
              // historical reasons cut it back to a single tools::PolyPolygon here
              for(sal_uInt32 a(0); a < nSize; a++)
              {
                  aRetval.append(rResult[a]);
              }
          }
      }

      // Always use SdrObject::Free to delete SdrObjects (!)
      SdrObject::Free(pClone);
  }

  return aRetval;
1162}

1164sal_uInt32 SdrObject::GetHdlCount() const
1165{
  return 8;
1167}

1169void SdrObject::AddToHdlList(SdrHdlList& rHdlList) const
1170{
  const tools::Rectangle& rR=GetSnapRect();
  for (sal_uInt32 nHdlNum=0; nHdlNum<8; ++nHdlNum)
  {
      std::unique_ptr<SdrHdl> pH;
      switch (nHdlNum) {
          case 0: pH.reset(new SdrHdl(rR.TopLeft(),     SdrHdlKind::UpperLeft)); break;
          case 1: pH.reset(new SdrHdl(rR.TopCenter(),   SdrHdlKind::Upper)); break;
          case 2: pH.reset(new SdrHdl(rR.TopRight(),    SdrHdlKind::UpperRight)); break;
          case 3: pH.reset(new SdrHdl(rR.LeftCenter(),  SdrHdlKind::Left )); break;
          case 4: pH.reset(new SdrHdl(rR.RightCenter(), SdrHdlKind::Right)); break;
          case 5: pH.reset(new SdrHdl(rR.BottomLeft(),  SdrHdlKind::LowerLeft)); break;
          case 6: pH.reset(new SdrHdl(rR.BottomCenter(),SdrHdlKind::Lower)); break;
          case 7: pH.reset(new SdrHdl(rR.BottomRight(), SdrHdlKind::LowerRight)); break;
      }
      rHdlList.AddHdl(std::move(pH));
  }
1187}

1189void SdrObject::AddToPlusHdlList(SdrHdlList&, SdrHdl&) const
1190{
1191}

1193void SdrObject::addCropHandles(SdrHdlList& /*rTarget*/) const
1194{
  // Default implementation, does nothing. Overloaded in
  // SdrGrafObj and SwVirtFlyDrawObj
1197}

1199tools::Rectangle SdrObject::ImpDragCalcRect(const SdrDragStat& rDrag) const
1200{
  tools::Rectangle aTmpRect(GetSnapRect());
  tools::Rectangle aRect(aTmpRect);
  const SdrHdl* pHdl=rDrag.GetHdl();
  SdrHdlKind eHdl=pHdl==nullptr ? SdrHdlKind::Move : pHdl->GetKind();
  bool bEcke=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::LowerLeft || eHdl==SdrHdlKind::LowerRight);
  bool bOrtho=rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho();
  bool bBigOrtho=bEcke && bOrtho && rDrag.GetView()->IsBigOrtho();
  Point aPos(rDrag.GetNow());
  bool bLft=(eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::Left  || eHdl==SdrHdlKind::LowerLeft);
  bool bRgt=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Right || eHdl==SdrHdlKind::LowerRight);
  bool bTop=(eHdl==SdrHdlKind::UpperRight || eHdl==SdrHdlKind::Upper || eHdl==SdrHdlKind::UpperLeft);
  bool bBtm=(eHdl==SdrHdlKind::LowerRight || eHdl==SdrHdlKind::Lower || eHdl==SdrHdlKind::LowerLeft);
  if (bLft) aTmpRect.SetLeft(aPos.X() );
  if (bRgt) aTmpRect.SetRight(aPos.X() );
  if (bTop) aTmpRect.SetTop(aPos.Y() );
  if (bBtm) aTmpRect.SetBottom(aPos.Y() );
  if (bOrtho) { // Ortho
      long nWdt0=aRect.Right() -aRect.Left();
      long nHgt0=aRect.Bottom()-aRect.Top();
      long nXMul=aTmpRect.Right() -aTmpRect.Left();
      long nYMul=aTmpRect.Bottom()-aTmpRect.Top();
      long nXDiv=nWdt0;
      long nYDiv=nHgt0;
      bool bXNeg=(nXMul<0)!=(nXDiv<0);
      bool bYNeg=(nYMul<0)!=(nYDiv<0);
      nXMul=std::abs(nXMul);
      nYMul=std::abs(nYMul);
      nXDiv=std::abs(nXDiv);
      nYDiv=std::abs(nYDiv);
      Fraction aXFact(nXMul,nXDiv); // fractions for canceling
      Fraction aYFact(nYMul,nYDiv); // and for comparing
      nXMul=aXFact.GetNumerator();
      nYMul=aYFact.GetNumerator();
      nXDiv=aXFact.GetDenominator();
      nYDiv=aYFact.GetDenominator();
      if (bEcke) { // corner point handles
          bool bUseX=(aXFact<aYFact) != bBigOrtho;
          if (bUseX) {
              long nNeed=long(BigInt(nHgt0)*BigInt(nXMul)/BigInt(nXDiv));
              if (bYNeg) nNeed=-nNeed;
              if (bTop) aTmpRect.SetTop(aTmpRect.Bottom()-nNeed );
              if (bBtm) aTmpRect.SetBottom(aTmpRect.Top()+nNeed );
          } else {
              long nNeed=long(BigInt(nWdt0)*BigInt(nYMul)/BigInt(nYDiv));
              if (bXNeg) nNeed=-nNeed;
              if (bLft) aTmpRect.SetLeft(aTmpRect.Right()-nNeed );
              if (bRgt) aTmpRect.SetRight(aTmpRect.Left()+nNeed );
          }
      } else { // apex handles
          if ((bLft || bRgt) && nXDiv!=0) {
              long nHgt0b=aRect.Bottom()-aRect.Top();
              long nNeed=long(BigInt(nHgt0b)*BigInt(nXMul)/BigInt(nXDiv));
              aTmpRect.AdjustTop( -((nNeed-nHgt0b)/2) );
              aTmpRect.SetBottom(aTmpRect.Top()+nNeed );
          }
          if ((bTop || bBtm) && nYDiv!=0) {
              long nWdt0b=aRect.Right()-aRect.Left();
              long nNeed=long(BigInt(nWdt0b)*BigInt(nYMul)/BigInt(nYDiv));
              aTmpRect.AdjustLeft( -((nNeed-nWdt0b)/2) );
              aTmpRect.SetRight(aTmpRect.Left()+nNeed );
          }
      }
  }
  aTmpRect.Justify();
  return aTmpRect;
1266}


1269bool SdrObject::hasSpecialDrag() const
1270{
  return false;
1272}

1274bool SdrObject::supportsFullDrag() const
1275{
  return true;
1277}

1279SdrObjectUniquePtr SdrObject::getFullDragClone() const
1280{
  // default uses simple clone
  return SdrObjectUniquePtr(CloneSdrObject(getSdrModelFromSdrObject()));
1283}

1285bool SdrObject::beginSpecialDrag(SdrDragStat& rDrag) const
1286{
  const SdrHdl* pHdl = rDrag.GetHdl();

  SdrHdlKind eHdl = (pHdl == nullptr) ? SdrHdlKind::Move : pHdl->GetKind();

  return eHdl==SdrHdlKind::UpperLeft || eHdl==SdrHdlKind::Upper || eHdl==SdrHdlKind::UpperRight ||
      eHdl==SdrHdlKind::Left || eHdl==SdrHdlKind::Right || eHdl==SdrHdlKind::LowerLeft ||
      eHdl==SdrHdlKind::Lower || eHdl==SdrHdlKind::LowerRight;
1294}

1296bool SdrObject::applySpecialDrag(SdrDragStat& rDrag)
1297{
  tools::Rectangle aNewRect(ImpDragCalcRect(rDrag));

  if(aNewRect != GetSnapRect())
  {
         NbcSetSnapRect(aNewRect);
  }

  return true;
1306}

1308OUString SdrObject::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const
1309{
  return OUString();
1311}

1313basegfx::B2DPolyPolygon SdrObject::getSpecialDragPoly(const SdrDragStat& /*rDrag*/) const
1314{
  // default has nothing to add
  return basegfx::B2DPolyPolygon();
1317}


1320// Create
1321bool SdrObject::BegCreate(SdrDragStat& rStat)
1322{
  rStat.SetOrtho4Possible();
  tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
  aRect1.Justify();
  rStat.SetActionRect(aRect1);
  aOutRect = aRect1;
  return true;
1329}

1331bool SdrObject::MovCreate(SdrDragStat& rStat)
1332{
  rStat.TakeCreateRect(aOutRect);
  rStat.SetActionRect(aOutRect);
  aOutRect.Justify();

  return true;
1338}

1340bool SdrObject::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1341{
  rStat.TakeCreateRect(aOutRect);
  aOutRect.Justify();

  return (eCmd==SdrCreateCmd::ForceEnd || rStat.GetPointCount()>=2);
1346}

1348void SdrObject::BrkCreate(SdrDragStat& /*rStat*/)
1349{
1350}

1352bool SdrObject::BckCreate(SdrDragStat& /*rStat*/)
1353{
  return false;
1355}

1357basegfx::B2DPolyPolygon SdrObject::TakeCreatePoly(const SdrDragStat& rDrag) const
1358{
  tools::Rectangle aRect1;
  rDrag.TakeCreateRect(aRect1);
  aRect1.Justify();

  basegfx::B2DPolyPolygon aRetval;
  aRetval.append(basegfx::utils::createPolygonFromRect(vcl::unotools::b2DRectangleFromRectangle(aRect1)));
  return aRetval;
1366}

1368PointerStyle SdrObject::GetCreatePointer() const
1369{
  return PointerStyle::Cross;
1371}

1373// transformations
1374void SdrObject::NbcMove(const Size& rSiz)
1375{
  aOutRect.Move(rSiz);
  SetRectsDirty();
1378}

1380void SdrObject::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
1381{
  bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0);
  bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0);
  if (bXMirr || bYMirr) {
      Point aRef1(GetSnapRect().Center());
      if (bXMirr) {
          Point aRef2(aRef1);
          aRef2.AdjustY( 1 );
          NbcMirrorGluePoints(aRef1,aRef2);
      }
      if (bYMirr) {
          Point aRef2(aRef1);
          aRef2.AdjustX( 1 );
          NbcMirrorGluePoints(aRef1,aRef2);
      }
  }
  ResizeRect(aOutRect,rRef,xFact,yFact);
  SetRectsDirty();
1399}

1401void SdrObject::NbcRotate(const Point& rRef, long nAngle, double sn, double cs)
1402{
  SetGlueReallyAbsolute(true);
  aOutRect.Move(-rRef.X(),-rRef.Y());
  tools::Rectangle R(aOutRect);
  if (sn==1.0 && cs==0.0) { // 90deg
      aOutRect.SetLeft(-R.Bottom() );
      aOutRect.SetRight(-R.Top() );
      aOutRect.SetTop(R.Left() );
      aOutRect.SetBottom(R.Right() );
  } else if (sn==0.0 && cs==-1.0) { // 180deg
      aOutRect.SetLeft(-R.Right() );
      aOutRect.SetRight(-R.Left() );
      aOutRect.SetTop(-R.Bottom() );
      aOutRect.SetBottom(-R.Top() );
  } else if (sn==-1.0 && cs==0.0) { // 270deg
      aOutRect.SetLeft(R.Top() );
      aOutRect.SetRight(R.Bottom() );
      aOutRect.SetTop(-R.Right() );
      aOutRect.SetBottom(-R.Left() );
  }
  aOutRect.Move(rRef.X(),rRef.Y());
  aOutRect.Justify(); // just in case
  SetRectsDirty();
  NbcRotateGluePoints(rRef,nAngle,sn,cs);
  SetGlueReallyAbsolute(false);
1427}

1429void SdrObject::NbcMirror(const Point& rRef1, const Point& rRef2)
1430{
  SetGlueReallyAbsolute(true);
  aOutRect.Move(-rRef1.X(),-rRef1.Y());
  tools::Rectangle R(aOutRect);
  long dx=rRef2.X()-rRef1.X();
  long dy=rRef2.Y()-rRef1.Y();
  if (dx==0) {          // vertical axis
      aOutRect.SetLeft(-R.Right() );
      aOutRect.SetRight(-R.Left() );
  } else if (dy==0) {   // horizontal axis
      aOutRect.SetTop(-R.Bottom() );
      aOutRect.SetBottom(-R.Top() );
  } else if (dx==dy) {  // 45deg axis
      aOutRect.SetLeft(R.Top() );
      aOutRect.SetRight(R.Bottom() );
      aOutRect.SetTop(R.Left() );
      aOutRect.SetBottom(R.Right() );
  } else if (dx==-dy) { // 45deg axis
      aOutRect.SetLeft(-R.Bottom() );
      aOutRect.SetRight(-R.Top() );
      aOutRect.SetTop(-R.Right() );
      aOutRect.SetBottom(-R.Left() );
  }
  aOutRect.Move(rRef1.X(),rRef1.Y());
  aOutRect.Justify(); // just in case
  SetRectsDirty();
  NbcMirrorGluePoints(rRef1,rRef2);
  SetGlueReallyAbsolute(false);
1458}

1460void SdrObject::NbcShear(const Point& rRef, long /*nAngle*/, double tn, bool bVShear)
1461{
  SetGlueReallyAbsolute(true);
  NbcShearGluePoints(rRef,tn,bVShear);
  SetGlueReallyAbsolute(false);
1465}

1467void SdrObject::Move(const Size& rSiz)
1468{
  if (rSiz.Width()!=0 || rSiz.Height()!=0) {
      tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
      NbcMove(rSiz);
      SetChanged();
      BroadcastObjectChange();
      SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0);
  }
1476}

1478void SdrObject::NbcCrop(const basegfx::B2DPoint& /*aRef*/, double /*fxFact*/, double /*fyFact*/)
1479{
  // Default: does nothing. Real behaviour in SwVirtFlyDrawObj and SdrDragCrop::EndSdrDrag.
  // Where SwVirtFlyDrawObj is the only real user of it to do something local
1482}

1484void SdrObject::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative)
1485{
  if (xFact.GetNumerator() == xFact.GetDenominator() && yFact.GetNumerator() == yFact.GetDenominator())
      return;

  if (bUnsetRelative)
  {
      mpImpl->mnRelativeWidth.reset();
      mpImpl->meRelativeWidthRelation = text::RelOrientation::PAGE_FRAME;
      mpImpl->meRelativeHeightRelation = text::RelOrientation::PAGE_FRAME;
      mpImpl->mnRelativeHeight.reset();
  }
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcResize(rRef,xFact,yFact);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1501}

1503void SdrObject::Crop(const basegfx::B2DPoint& rRef, double fxFact, double fyFact)
1504{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcCrop(rRef, fxFact, fyFact);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1510}

1512void SdrObject::Rotate(const Point& rRef, long nAngle, double sn, double cs)
1513{
  if (nAngle!=0) {
      tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
      NbcRotate(rRef,nAngle,sn,cs);
      SetChanged();
      BroadcastObjectChange();
      SendUserCall(SdrUserCallType::Resize,aBoundRect0);
  }
1521}

1523void SdrObject::Mirror(const Point& rRef1, const Point& rRef2)
1524{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcMirror(rRef1,rRef2);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1530}

1532void SdrObject::Shear(const Point& rRef, long nAngle, double tn, bool bVShear)
1533{
  if (nAngle!=0) {
      tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
      NbcShear(rRef,nAngle,tn,bVShear);
      SetChanged();
      BroadcastObjectChange();
      SendUserCall(SdrUserCallType::Resize,aBoundRect0);
  }
1541}

1543void SdrObject::NbcSetRelativePos(const Point& rPnt)
1544{
  Point aRelPos0(GetSnapRect().TopLeft()-aAnchor);
  Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y());
  NbcMove(aSiz); // This also calls SetRectsDirty()
1548}

1550void SdrObject::SetRelativePos(const Point& rPnt)
1551{
  if (rPnt!=GetRelativePos()) {
      tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
      NbcSetRelativePos(rPnt);
      SetChanged();
      BroadcastObjectChange();
      SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0);
  }
1559}

1561Point SdrObject::GetRelativePos() const
1562{
  return GetSnapRect().TopLeft()-aAnchor;
1564}

1566void SdrObject::ImpSetAnchorPos(const Point& rPnt)
1567{
  aAnchor = rPnt;
1569}

1571void SdrObject::NbcSetAnchorPos(const Point& rPnt)
1572{
  Size aSiz(rPnt.X()-aAnchor.X(),rPnt.Y()-aAnchor.Y());
  aAnchor=rPnt;
  NbcMove(aSiz); // This also calls SetRectsDirty()
1576}

1578void SdrObject::SetAnchorPos(const Point& rPnt)
1579{
  if (rPnt!=aAnchor) {
      tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
      NbcSetAnchorPos(rPnt);
      SetChanged();
      BroadcastObjectChange();
      SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0);
  }
1587}

1589const Point& SdrObject::GetAnchorPos() const
1590{
  return aAnchor;
1592}

1594void SdrObject::RecalcSnapRect()
1595{
1596}

1598const tools::Rectangle& SdrObject::GetSnapRect() const
1599{
  return aOutRect;
1601}

1603void SdrObject::NbcSetSnapRect(const tools::Rectangle& rRect)
1604{
  aOutRect=rRect;
1606}

1608const tools::Rectangle& SdrObject::GetLogicRect() const
1609{
  return GetSnapRect();
1611}

1613void SdrObject::NbcSetLogicRect(const tools::Rectangle& rRect)
1614{
  NbcSetSnapRect(rRect);
1616}

1618void SdrObject::AdjustToMaxRect( const tools::Rectangle& rMaxRect, bool /* bShrinkOnly = false */ )
1619{
  SetLogicRect( rMaxRect );
1621}

1623void SdrObject::SetSnapRect(const tools::Rectangle& rRect)
1624{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcSetSnapRect(rRect);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1630}

1632void SdrObject::SetLogicRect(const tools::Rectangle& rRect)
1633{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcSetLogicRect(rRect);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1639}

1641long SdrObject::GetRotateAngle() const
1642{
  return 0;
1644}

1646long SdrObject::GetShearAngle(bool /*bVertical*/) const
1647{
  return 0;
1649}

1651sal_uInt32 SdrObject::GetSnapPointCount() const
1652{
  return GetPointCount();
1654}

1656Point SdrObject::GetSnapPoint(sal_uInt32 i) const
1657{
  return GetPoint(i);
1659}

1661bool SdrObject::IsPolyObj() const
1662{
  return false;
1664}

1666sal_uInt32 SdrObject::GetPointCount() const
1667{
  return 0;
1669}

1671Point SdrObject::GetPoint(sal_uInt32 /*i*/) const
1672{
  return Point();
1674}

1676void SdrObject::SetPoint(const Point& rPnt, sal_uInt32 i)
1677{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcSetPoint(rPnt, i);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1683}

1685void SdrObject::NbcSetPoint(const Point& /*rPnt*/, sal_uInt32 /*i*/)
1686{
1687}

1689bool SdrObject::HasTextEdit() const
1690{
  return false;
1692}

1694bool SdrObject::Equals(const SdrObject& rOtherObj) const
1695{
  return (aAnchor.X() == rOtherObj.aAnchor.X() && aAnchor.Y() == rOtherObj.aAnchor.Y() &&
          nOrdNum == rOtherObj.nOrdNum && mnNavigationPosition == rOtherObj.mnNavigationPosition &&
          mbSupportTextIndentingOnLineWidthChange == rOtherObj.mbSupportTextIndentingOnLineWidthChange &&
          mbLineIsOutsideGeometry == rOtherObj.mbLineIsOutsideGeometry && bMarkProt == rOtherObj.bMarkProt &&
          bIs3DObj == rOtherObj.bIs3DObj && bIsEdge == rOtherObj.bIsEdge && bClosedObj == rOtherObj.bClosedObj &&
          bNotVisibleAsMaster == rOtherObj.bNotVisibleAsMaster && bEmptyPresObj == rOtherObj.bEmptyPresObj &&
          mbVisible == rOtherObj.mbVisible && bNoPrint == rOtherObj.bNoPrint && bSizProt == rOtherObj.bSizProt &&
          bMovProt == rOtherObj.bMovProt && bVirtObj == rOtherObj.bVirtObj &&
          mnLayerID == rOtherObj.mnLayerID && GetMergedItemSet().Equals(rOtherObj.GetMergedItemSet(), false) );
1705}

1707void SdrObject::dumpAsXml(xmlTextWriterPtr pWriter) const
1708{
  xmlTextWriterStartElement(pWriter, BAD_CAST(xmlChar *)("SdrObject"));
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("ptr"), "%p", this);
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("symbol"), "%s", BAD_CAST(xmlChar *)(typeid(*this).name()));
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("name"), "%s", BAD_CAST(xmlChar *)(GetName().toUtf8().getStr()));
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("title"), "%s", BAD_CAST(xmlChar *)(GetTitle().toUtf8().getStr()));
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("description"), "%s", BAD_CAST(xmlChar *)(GetDescription().toUtf8().getStr()));
  xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST(xmlChar *)("nOrdNum"), "%" SAL_PRIuUINT32"u", GetOrdNumDirect());
  xmlTextWriterWriteAttribute(pWriter, BAD_CAST(xmlChar *)("aOutRect"), BAD_CAST(xmlChar *)(aOutRect.toString().getStr()));

  if (pGrabBagItem)
  {
      pGrabBagItem->dumpAsXml(pWriter);
  }

  if (mpProperties)
  {
      mpProperties->dumpAsXml(pWriter);
  }

  if (const OutlinerParaObject* pOutliner = GetOutlinerParaObject())
      pOutliner->dumpAsXml(pWriter);

  xmlTextWriterEndElement(pWriter);
1732}

1734void SdrObject::SetOutlinerParaObject(std::unique_ptr<OutlinerParaObject> pTextObject)
1735{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcSetOutlinerParaObject(std::move(pTextObject));
  SetChanged();
  BroadcastObjectChange();
  if (GetCurrentBoundRect()!=aBoundRect0) {
      SendUserCall(SdrUserCallType::Resize,aBoundRect0);
  }
1743}

1745void SdrObject::NbcSetOutlinerParaObject(std::unique_ptr<OutlinerParaObject> /*pTextObject*/)
1746{
1747}

1749OutlinerParaObject* SdrObject::GetOutlinerParaObject() const
1750{
  return nullptr;
1752}

1754void SdrObject::NbcReformatText()
1755{
1756}

1758void SdrObject::BurnInStyleSheetAttributes()
1759{
  GetProperties().ForceStyleToHardAttributes();
1761}

1763bool SdrObject::HasMacro() const
1764{
  return false;
1766}

1768SdrObject* SdrObject::CheckMacroHit(const SdrObjMacroHitRec& rRec) const
1769{
  if(rRec.pPageView)
  {
      return SdrObjectPrimitiveHit(*this, rRec.aPos, rRec.nTol, *rRec.pPageView, rRec.pVisiLayer, false);
  }

  return nullptr;
1776}

1778PointerStyle SdrObject::GetMacroPointer(const SdrObjMacroHitRec&) const
1779{
  return PointerStyle::RefHand;
1781}

1783void SdrObject::PaintMacro(OutputDevice& rOut, const tools::Rectangle& , const SdrObjMacroHitRec& ) const
1784{
  const RasterOp eRop(rOut.GetRasterOp());
  const basegfx::B2DPolyPolygon aPolyPolygon(TakeXorPoly());

  rOut.SetLineColor(COL_BLACK);
  rOut.SetFillColor();
  rOut.SetRasterOp(RasterOp::Invert);

  for(auto const& rPolygon : aPolyPolygon)
  {
      rOut.DrawPolyLine(rPolygon);
  }

  rOut.SetRasterOp(eRop);
1798}

1800bool SdrObject::DoMacro(const SdrObjMacroHitRec&)
1801{
  return false;
1803}

1805bool SdrObject::IsMacroHit(const SdrObjMacroHitRec& rRec) const
1806{
  return CheckMacroHit(rRec) != nullptr;
1808}


1811SdrObjGeoData* SdrObject::NewGeoData() const
1812{
  return new SdrObjGeoData;
1814}

1816void SdrObject::SaveGeoData(SdrObjGeoData& rGeo) const
1817{
  rGeo.aBoundRect    =GetCurrentBoundRect();
  rGeo.aAnchor       =aAnchor       ;
  rGeo.bMovProt      =bMovProt      ;
  rGeo.bSizProt      =bSizProt      ;
  rGeo.bNoPrint      =bNoPrint      ;
  rGeo.mbVisible     =mbVisible     ;
  rGeo.bClosedObj    =bClosedObj    ;
  rGeo.mnLayerID = mnLayerID;

  // user-defined glue points
  if (pPlusData!=nullptr && pPlusData->pGluePoints!=nullptr) {
      if (rGeo.pGPL!=nullptr) {
          *rGeo.pGPL=*pPlusData->pGluePoints;
      } else {
          rGeo.pGPL.reset( new SdrGluePointList(*pPlusData->pGluePoints) );
      }
  } else {
      rGeo.pGPL.reset();
  }
1837}

1839void SdrObject::RestGeoData(const SdrObjGeoData& rGeo)
1840{
  SetRectsDirty();
  aOutRect      =rGeo.aBoundRect    ;
  aAnchor       =rGeo.aAnchor       ;
  bMovProt      =rGeo.bMovProt      ;
  bSizProt      =rGeo.bSizProt      ;
  bNoPrint      =rGeo.bNoPrint      ;
  mbVisible     =rGeo.mbVisible     ;
  bClosedObj    =rGeo.bClosedObj    ;
  mnLayerID = rGeo.mnLayerID;

  // user-defined glue points
  if (rGeo.pGPL!=nullptr) {
      ImpForcePlusData();
      if (pPlusData->pGluePoints!=nullptr) {
          *pPlusData->pGluePoints=*rGeo.pGPL;
      } else {
          pPlusData->pGluePoints.reset(new SdrGluePointList(*rGeo.pGPL));
      }
  } else {
      if (pPlusData!=nullptr && pPlusData->pGluePoints!=nullptr) {
          pPlusData->pGluePoints.reset();
      }
  }
1864}

1866SdrObjGeoData* SdrObject::GetGeoData() const
1867{
  SdrObjGeoData* pGeo=NewGeoData();
  SaveGeoData(*pGeo);
  return pGeo;
1871}

1873void SdrObject::SetGeoData(const SdrObjGeoData& rGeo)
1874{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  RestGeoData(rGeo);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1880}


1883// ItemSet access

1885const SfxItemSet& SdrObject::GetObjectItemSet() const
1886{
  return GetProperties().GetObjectItemSet();
1888}

1890const SfxItemSet& SdrObject::GetMergedItemSet() const
1891{
  return GetProperties().GetMergedItemSet();
1893}

1895void SdrObject::SetObjectItem(const SfxPoolItem& rItem)
1896{
  GetProperties().SetObjectItem(rItem);
1898}

1900void SdrObject::SetMergedItem(const SfxPoolItem& rItem)
1901{
  GetProperties().SetMergedItem(rItem);
1903}

1905void SdrObject::ClearMergedItem(const sal_uInt16 nWhich)
1906{
  GetProperties().ClearMergedItem(nWhich);
1908}

1910void SdrObject::SetObjectItemSet(const SfxItemSet& rSet)
1911{
  GetProperties().SetObjectItemSet(rSet);
1913}

1915void SdrObject::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems)
1916{
  GetProperties().SetMergedItemSet(rSet, bClearAllItems);
1918}

1920const SfxPoolItem& SdrObject::GetObjectItem(const sal_uInt16 nWhich) const
1921{
  return GetObjectItemSet().Get(nWhich);
1923}

1925const SfxPoolItem& SdrObject::GetMergedItem(const sal_uInt16 nWhich) const
1926{
  return GetMergedItemSet().Get(nWhich);
1928}

1930void SdrObject::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, bool bClearAllItems)
1931{
  GetProperties().SetMergedItemSetAndBroadcast(rSet, bClearAllItems);
1933}

1935void SdrObject::ApplyNotPersistAttr(const SfxItemSet& rAttr)
1936{
  tools::Rectangle aBoundRect0; if (pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
  NbcApplyNotPersistAttr(rAttr);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::Resize,aBoundRect0);
1942}

1944void SdrObject::NbcApplyNotPersistAttr(const SfxItemSet& rAttr)
1945{
  const tools::Rectangle& rSnap=GetSnapRect();
  const tools::Rectangle& rLogic=GetLogicRect();
  Point aRef1(rSnap.Center());
  const SfxPoolItem *pPoolItem=nullptr;
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1X,true,&pPoolItem)==SfxItemState::SET) {
      aRef1.setX(static_cast<const SdrTransformRef1XItem*>(pPoolItem)->GetValue() );
  }
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1Y,true,&pPoolItem)==SfxItemState::SET) {
      aRef1.setY(static_cast<const SdrTransformRef1YItem*>(pPoolItem)->GetValue() );
  }

  tools::Rectangle aNewSnap(rSnap);
  if (rAttr.GetItemState(SDRATTR_MOVEX,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrMoveXItem*>(pPoolItem)->GetValue();
      aNewSnap.Move(n,0);
  }
  if (rAttr.GetItemState(SDRATTR_MOVEY,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrMoveYItem*>(pPoolItem)->GetValue();
      aNewSnap.Move(0,n);
  }
  if (rAttr.GetItemState(SDRATTR_ONEPOSITIONX,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrOnePositionXItem*>(pPoolItem)->GetValue();
      aNewSnap.Move(n-aNewSnap.Left(),0);
  }
  if (rAttr.GetItemState(SDRATTR_ONEPOSITIONY,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrOnePositionYItem*>(pPoolItem)->GetValue();
      aNewSnap.Move(0,n-aNewSnap.Top());
  }
  if (rAttr.GetItemState(SDRATTR_ONESIZEWIDTH,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrOneSizeWidthItem*>(pPoolItem)->GetValue();
      aNewSnap.SetRight(aNewSnap.Left()+n );
  }
  if (rAttr.GetItemState(SDRATTR_ONESIZEHEIGHT,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrOneSizeHeightItem*>(pPoolItem)->GetValue();
      aNewSnap.SetBottom(aNewSnap.Top()+n );
  }
  if (aNewSnap!=rSnap) {
      if (aNewSnap.GetSize()==rSnap.GetSize()) {
          NbcMove(Size(aNewSnap.Left()-rSnap.Left(),aNewSnap.Top()-rSnap.Top()));
      } else {
          NbcSetSnapRect(aNewSnap);
      }
  }

  if (rAttr.GetItemState(SDRATTR_SHEARANGLE,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrShearAngleItem*>(pPoolItem)->GetValue();
      n-=GetShearAngle();
      if (n!=0) {
          double nTan = tan(n * F_PI18000(3.14159265358979323846/18000.0));
          NbcShear(aRef1,n,nTan,false);
      }
  }
  if (rAttr.GetItemState(SDRATTR_ROTATEANGLE,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrAngleItem*>(pPoolItem)->GetValue();
      n-=GetRotateAngle();
      if (n!=0) {
          double nSin = sin(n * F_PI18000(3.14159265358979323846/18000.0));
          double nCos = cos(n * F_PI18000(3.14159265358979323846/18000.0));
          NbcRotate(aRef1,n,nSin,nCos);
      }
  }
  if (rAttr.GetItemState(SDRATTR_ROTATEONE,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrRotateOneItem*>(pPoolItem)->GetValue();
      double nSin = sin(n * F_PI18000(3.14159265358979323846/18000.0));
      double nCos = cos(n * F_PI18000(3.14159265358979323846/18000.0));
      NbcRotate(aRef1,n,nSin,nCos);
  }
  if (rAttr.GetItemState(SDRATTR_HORZSHEARONE,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrHorzShearOneItem*>(pPoolItem)->GetValue();
      double nTan = tan(n * F_PI18000(3.14159265358979323846/18000.0));
      NbcShear(aRef1,n,nTan,false);
  }
  if (rAttr.GetItemState(SDRATTR_VERTSHEARONE,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrVertShearOneItem*>(pPoolItem)->GetValue();
      double nTan = tan(n * F_PI18000(3.14159265358979323846/18000.0));
      NbcShear(aRef1,n,nTan,true);
  }

  if (rAttr.GetItemState(SDRATTR_OBJMOVEPROTECT,true,&pPoolItem)==SfxItemState::SET) {
      bool b=static_cast<const SdrYesNoItem*>(pPoolItem)->GetValue();
      SetMoveProtect(b);
  }
  if (rAttr.GetItemState(SDRATTR_OBJSIZEPROTECT,true,&pPoolItem)==SfxItemState::SET) {
      bool b=static_cast<const SdrYesNoItem*>(pPoolItem)->GetValue();
      SetResizeProtect(b);
  }

  /* move protect always sets size protect */
  if( IsMoveProtect() )
      SetResizeProtect( true );

  if (rAttr.GetItemState(SDRATTR_OBJPRINTABLE,true,&pPoolItem)==SfxItemState::SET) {
      bool b=static_cast<const SdrObjPrintableItem*>(pPoolItem)->GetValue();
      SetPrintable(b);
  }

  if (rAttr.GetItemState(SDRATTR_OBJVISIBLE,true,&pPoolItem)==SfxItemState::SET) {
      bool b=static_cast<const SdrObjVisibleItem*>(pPoolItem)->GetValue();
      SetVisible(b);
  }

  SdrLayerID nLayer=SDRLAYER_NOTFOUND;
  if (rAttr.GetItemState(SDRATTR_LAYERID,true,&pPoolItem)==SfxItemState::SET) {
      nLayer=static_cast<const SdrLayerIdItem*>(pPoolItem)->GetValue();
  }
  if (rAttr.GetItemState(SDRATTR_LAYERNAME,true,&pPoolItem)==SfxItemState::SET)
  {
      OUString aLayerName = static_cast<const SdrLayerNameItem*>(pPoolItem)->GetValue();
      const SdrLayerAdmin& rLayAd(nullptr != getSdrPageFromSdrObject()
          ? getSdrPageFromSdrObject()->GetLayerAdmin()
          : getSdrModelFromSdrObject().GetLayerAdmin());
      const SdrLayer* pLayer = rLayAd.GetLayer(aLayerName);

      if(nullptr != pLayer)
      {
          nLayer=pLayer->GetID();
      }
  }
  if (nLayer!=SDRLAYER_NOTFOUND) {
      NbcSetLayer(nLayer);
  }

  if (rAttr.GetItemState(SDRATTR_OBJECTNAME,true,&pPoolItem)==SfxItemState::SET) {
      OUString aName=static_cast<const SfxStringItem*>(pPoolItem)->GetValue();
      SetName(aName);
  }
  tools::Rectangle aNewLogic(rLogic);
  if (rAttr.GetItemState(SDRATTR_LOGICSIZEWIDTH,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrLogicSizeWidthItem*>(pPoolItem)->GetValue();
      aNewLogic.SetRight(aNewLogic.Left()+n );
  }
  if (rAttr.GetItemState(SDRATTR_LOGICSIZEHEIGHT,true,&pPoolItem)==SfxItemState::SET) {
      long n=static_cast<const SdrLogicSizeHeightItem*>(pPoolItem)->GetValue();
      aNewLogic.SetBottom(aNewLogic.Top()+n );
  }
  if (aNewLogic!=rLogic) {
      NbcSetLogicRect(aNewLogic);
  }
  Fraction aResizeX(1,1);
  Fraction aResizeY(1,1);
  if (rAttr.GetItemState(SDRATTR_RESIZEXONE,true,&pPoolItem)==SfxItemState::SET) {
      aResizeX*=static_cast<const SdrResizeXOneItem*>(pPoolItem)->GetValue();
  }
  if (rAttr.GetItemState(SDRATTR_RESIZEYONE,true,&pPoolItem)==SfxItemState::SET) {
      aResizeY*=static_cast<const SdrResizeYOneItem*>(pPoolItem)->GetValue();
  }
  if (aResizeX!=Fraction(1,1) || aResizeY!=Fraction(1,1)) {
      NbcResize(aRef1,aResizeX,aResizeY);
  }
2095}

2097void SdrObject::TakeNotPersistAttr(SfxItemSet& rAttr) const
2098{
  const tools::Rectangle& rSnap=GetSnapRect();
  const tools::Rectangle& rLogic=GetLogicRect();
  rAttr.Put(SdrYesNoItem(SDRATTR_OBJMOVEPROTECT, IsMoveProtect()));
  rAttr.Put(SdrYesNoItem(SDRATTR_OBJSIZEPROTECT, IsResizeProtect()));
  rAttr.Put(SdrObjPrintableItem(IsPrintable()));
  rAttr.Put(SdrObjVisibleItem(IsVisible()));
  rAttr.Put(SdrAngleItem(SDRATTR_ROTATEANGLE, GetRotateAngle()));
  rAttr.Put(SdrShearAngleItem(GetShearAngle()));
  rAttr.Put(SdrOneSizeWidthItem(rSnap.GetWidth()-1));
  rAttr.Put(SdrOneSizeHeightItem(rSnap.GetHeight()-1));
  rAttr.Put(SdrOnePositionXItem(rSnap.Left()));
  rAttr.Put(SdrOnePositionYItem(rSnap.Top()));
  if (rLogic.GetWidth()!=rSnap.GetWidth()) {
      rAttr.Put(SdrLogicSizeWidthItem(rLogic.GetWidth()-1));
  }
  if (rLogic.GetHeight()!=rSnap.GetHeight()) {
      rAttr.Put(SdrLogicSizeHeightItem(rLogic.GetHeight()-1));
  }
  OUString aName(GetName());

  if (!aName.isEmpty())
  {
      rAttr.Put(SfxStringItem(SDRATTR_OBJECTNAME, aName));
  }

  rAttr.Put(SdrLayerIdItem(GetLayer()));
  const SdrLayerAdmin& rLayAd(nullptr != getSdrPageFromSdrObject()
      ? getSdrPageFromSdrObject()->GetLayerAdmin()
      : getSdrModelFromSdrObject().GetLayerAdmin());
  const SdrLayer* pLayer = rLayAd.GetLayerPerID(GetLayer());
  if(nullptr != pLayer)
  {
      rAttr.Put(SdrLayerNameItem(pLayer->GetName()));
  }
  Point aRef1(rSnap.Center());
  Point aRef2(aRef1); aRef2.AdjustY( 1 );
  rAttr.Put(SdrTransformRef1XItem(aRef1.X()));
  rAttr.Put(SdrTransformRef1YItem(aRef1.Y()));
  rAttr.Put(SdrTransformRef2XItem(aRef2.X()));
  rAttr.Put(SdrTransformRef2YItem(aRef2.Y()));
2139}

2141SfxStyleSheet* SdrObject::GetStyleSheet() const
2142{
  return GetProperties().GetStyleSheet();
2144}

2146void SdrObject::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr)
2147{
  tools::Rectangle aBoundRect0;

  if(pUserCall)
      aBoundRect0 = GetLastBoundRect();

  NbcSetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
  SetChanged();
  BroadcastObjectChange();
  SendUserCall(SdrUserCallType::ChangeAttr, aBoundRect0);
2157}

2159void SdrObject::NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr)
2160{
  GetProperties().SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
2162}

2164// Broadcasting while setting attributes is managed by the AttrObj.


2167SdrGluePoint SdrObject::GetVertexGluePoint(sal_uInt16 nPosNum) const
2168{
  // #i41936# Use SnapRect for default GluePoints
  const tools::Rectangle aR(GetSnapRect());
  Point aPt;

  switch(nPosNum)
  {
      case 0 : aPt = aR.TopCenter();    break;
      case 1 : aPt = aR.RightCenter();  break;
      case 2 : aPt = aR.BottomCenter(); break;
      case 3 : aPt = aR.LeftCenter();   break;
  }

  aPt -= aR.Center();
  SdrGluePoint aGP(aPt);
  aGP.SetPercent(false);

  return aGP;
2186}

2188SdrGluePoint SdrObject::GetCornerGluePoint(sal_uInt16 nPosNum) const
2189{
  tools::Rectangle aR(GetCurrentBoundRect());
  Point aPt;
  switch (nPosNum) {
      case 0 : aPt=aR.TopLeft();     break;
      case 1 : aPt=aR.TopRight();    break;
      case 2 : aPt=aR.BottomRight(); break;
      case 3 : aPt=aR.BottomLeft();  break;
  }
  aPt-=GetSnapRect().Center();
  SdrGluePoint aGP(aPt);
  aGP.SetPercent(false);
  return aGP;
2202}

2204const SdrGluePointList* SdrObject::GetGluePointList() const
2205{
  if (pPlusData!=nullptr) return pPlusData->pGluePoints.get();
  return nullptr;
2208}


2211SdrGluePointList* SdrObject::ForceGluePointList()
2212{
  ImpForcePlusData();
  if (pPlusData->pGluePoints==nullptr) {
      pPlusData->pGluePoints.reset(new SdrGluePointList);
  }
  return pPlusData->pGluePoints.get();
2218}

2220void SdrObject::SetGlueReallyAbsolute(bool bOn)
2221{
  // First a const call to see whether there are any glue points.
  // Force const call!
  if (GetGluePointList()!=nullptr) {
      SdrGluePointList* pGPL=ForceGluePointList();
      pGPL->SetReallyAbsolute(bOn,*this);
  }
2228}

2230void SdrObject::NbcRotateGluePoints(const Point& rRef, long nAngle, double sn, double cs)
2231{
  // First a const call to see whether there are any glue points.
  // Force const call!
  if (GetGluePointList()!=nullptr) {
      SdrGluePointList* pGPL=ForceGluePointList();
      pGPL->Rotate(rRef,nAngle,sn,cs,this);
  }
2238}

2240void SdrObject::NbcMirrorGluePoints(const Point& rRef1, const Point& rRef2)
2241{
  // First a const call to see whether there are any glue points.
  // Force const call!
  if (GetGluePointList()!=nullptr) {
      SdrGluePointList* pGPL=ForceGluePointList();
      pGPL->Mirror(rRef1,rRef2,this);
  }
2248}

2250void SdrObject::NbcShearGluePoints(const Point& rRef, double tn, bool bVShear)
2251{
  // First a const call to see whether there are any glue points.
  // Force const call!
  if (GetGluePointList()!=nullptr) {
      SdrGluePointList* pGPL=ForceGluePointList();
      pGPL->Shear(rRef,tn,bVShear,this);
  }
2258}

2260void SdrObject::ConnectToNode(bool /*bTail1*/, SdrObject* /*pObj*/)
2261{
2262}

2264void SdrObject::DisconnectFromNode(bool /*bTail1*/)
2265{
2266}

2268SdrObject* SdrObject::GetConnectedNode(bool /*bTail1*/) const
2269{
  return nullptr;
2271}


2274static void extractLineContourFromPrimitive2DSequence(
  const drawinglayer::primitive2d::Primitive2DContainer& rxSequence,
  basegfx::B2DPolygonVector& rExtractedHairlines,
  basegfx::B2DPolyPolygonVector& rExtractedLineFills)
2278{
  rExtractedHairlines.clear();
  rExtractedLineFills.clear();

  if(rxSequence.empty())
      return;

  // use neutral ViewInformation
  const drawinglayer::geometry::ViewInformation2D aViewInformation2D;

  // create extractor, process and get result
  drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
  aExtractor.process(rxSequence);

  // copy line results
  rExtractedHairlines = aExtractor.getExtractedHairlines();

  // copy fill rsults
  rExtractedLineFills = aExtractor.getExtractedLineFills();
2297}


2300SdrObject* SdrObject::ImpConvertToContourObj(bool bForceLineDash)
2301{
  SdrObject* pRetval(nullptr);

  if(LineGeometryUsageIsNecessary())
  {
      basegfx::B2DPolyPolygon aMergedLineFillPolyPolygon;
      basegfx::B2DPolyPolygon aMergedHairlinePolyPolygon;
      const drawinglayer::primitive2d::Primitive2DContainer & xSequence(GetViewContact().getViewIndependentPrimitive2DContainer());

      if(!xSequence.empty())
      {
          basegfx::B2DPolygonVector aExtractedHairlines;
          basegfx::B2DPolyPolygonVector aExtractedLineFills;

          extractLineContourFromPrimitive2DSequence(xSequence, aExtractedHairlines, aExtractedLineFills);

          // for SdrObject creation, just copy all to a single Hairline-PolyPolygon
          for(const basegfx::B2DPolygon & rExtractedHairline : aExtractedHairlines)
          {
              aMergedHairlinePolyPolygon.append(rExtractedHairline);
          }

          // check for fill rsults
          if (!aExtractedLineFills.empty() && !utl::ConfigManager::IsFuzzing())
          {
              // merge to a single tools::PolyPolygon (OR)
              aMergedLineFillPolyPolygon = basegfx::utils::mergeToSinglePolyPolygon(aExtractedLineFills);
          }
      }

      if(aMergedLineFillPolyPolygon.count() || (bForceLineDash && aMergedHairlinePolyPolygon.count()))
      {
          SfxItemSet aSet(GetMergedItemSet());
          drawing::FillStyle eOldFillStyle = aSet.Get(XATTR_FILLSTYLE).GetValue();
          SdrPathObj* aLinePolygonPart = nullptr;
          SdrPathObj* aLineHairlinePart = nullptr;
          bool bBuildGroup(false);

          if(aMergedLineFillPolyPolygon.count())
          {
              // create SdrObject for filled line geometry
              aLinePolygonPart = new SdrPathObj(
                  getSdrModelFromSdrObject(),
                  OBJ_PATHFILL,
                  aMergedLineFillPolyPolygon);

              // correct item properties
              aSet.Put(XLineWidthItem(0));
              aSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
              Color aColorLine = aSet.Get(XATTR_LINECOLOR).GetColorValue();
              sal_uInt16 nTransLine = aSet.Get(XATTR_LINETRANSPARENCE).GetValue();
              aSet.Put(XFillColorItem(OUString(), aColorLine));
              aSet.Put(XFillStyleItem(drawing::FillStyle_SOLID));
              aSet.Put(XFillTransparenceItem(nTransLine));

              aLinePolygonPart->SetMergedItemSet(aSet);
          }

          if(aMergedHairlinePolyPolygon.count())
          {
              // create SdrObject for hairline geometry
              // OBJ_PATHLINE is necessary here, not OBJ_PATHFILL. This is intended
              // to get a non-filled object. If the poly is closed, the PathObj takes care for
              // the correct closed state.
              aLineHairlinePart = new SdrPathObj(
                  getSdrModelFromSdrObject(),
                  OBJ_PATHLINE,
                  aMergedHairlinePolyPolygon);

              aSet.Put(XLineWidthItem(0));
              aSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
              aSet.Put(XLineStyleItem(drawing::LineStyle_SOLID));

              // it is also necessary to switch off line start and ends here
              aSet.Put(XLineStartWidthItem(0));
              aSet.Put(XLineEndWidthItem(0));

              aLineHairlinePart->SetMergedItemSet(aSet);

              if(aLinePolygonPart)
              {
                  bBuildGroup = true;
              }
          }

          // check if original geometry should be added (e.g. filled and closed)
          bool bAddOriginalGeometry(false);
          SdrPathObj* pPath = dynamic_cast<SdrPathObj*>(this);

          if(pPath && pPath->IsClosed())
          {
              if(eOldFillStyle != drawing::FillStyle_NONE)
              {
                  bAddOriginalGeometry = true;
              }
          }

          // do we need a group?
          if(bBuildGroup || bAddOriginalGeometry)
          {
              SdrObject* pGroup = new SdrObjGroup(getSdrModelFromSdrObject());

              if(bAddOriginalGeometry)
              {
                  // Add a clone of the original geometry.
                  aSet.ClearItem();
                  aSet.Put(GetMergedItemSet());
                  aSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
                  aSet.Put(XLineWidthItem(0));

                  SdrObject* pClone(CloneSdrObject(getSdrModelFromSdrObject()));
                  pClone->SetMergedItemSet(aSet);

                  pGroup->GetSubList()->NbcInsertObject(pClone);
              }

              if(aLinePolygonPart)
              {
                  pGroup->GetSubList()->NbcInsertObject(aLinePolygonPart);
              }

              if(aLineHairlinePart)
              {
                  pGroup->GetSubList()->NbcInsertObject(aLineHairlinePart);
              }

              pRetval = pGroup;
          }
          else
          {
              if(aLinePolygonPart)
              {
                  pRetval = aLinePolygonPart;
              }
              else if(aLineHairlinePart)
              {
                  pRetval = aLineHairlinePart;
              }
          }
      }
  }

  if(nullptr == pRetval)
  {
      // due to current method usage, create and return a clone when nothing has changed
      SdrObject* pClone(CloneSdrObject(getSdrModelFromSdrObject()));
      pRetval = pClone;
  }

  return pRetval;
2451}


2454void SdrObject::SetMarkProtect(bool bProt)
2455{
  bMarkProt = bProt;
2457}


2460void SdrObject::SetEmptyPresObj(bool bEpt)
2461{
  bEmptyPresObj = bEpt;
2463}


2466void SdrObject::SetNotVisibleAsMaster(bool bFlg)
2467{
  bNotVisibleAsMaster=bFlg;
2469}


2472// convert this path object to contour object, even when it is a group
2473SdrObject* SdrObject::ConvertToContourObj(SdrObject* pRet, bool bForceLineDash) const
2474{
  if(dynamic_cast<const SdrObjGroup*>( pRet) !=  nullptr)
4
←
Taking true branch→
10
←
Assuming pointer value is null→
11
←
Taking false branch→
  {
      SdrObjList* pObjList2 = pRet->GetSubList();
      SdrObject* pGroup = new SdrObjGroup(getSdrModelFromSdrObject());

      for(size_t a=0; a<pObjList2->GetObjCount(); ++a)
5
←
Assuming the condition is true→
6
←
Loop condition is true.  Entering loop body→
      {
          SdrObject* pIterObj = pObjList2->GetObj(a);
7
←
'pIterObj' initialized here→
          pGroup->GetSubList()->NbcInsertObject(ConvertToContourObj(pIterObj, bForceLineDash));
8
←
Passing value via 1st parameter 'pRet'→
9
←
Calling 'SdrObject::ConvertToContourObj'→
      }

      pRet = pGroup;
  }
  else
  {
      if (SdrPathObj *pPathObj11.1
'pPathObj' is null
 = dynamic_cast<SdrPathObj*>(pRet))
12
←
Taking false branch→
      {
          // bezier geometry got created, even for straight edges since the given
          // object is a result of DoConvertToPolyObj. For conversion to contour
          // this is not really needed and can be reduced again AFAP
          pPathObj->SetPathPoly(basegfx::utils::simplifyCurveSegments(pPathObj->GetPathPoly()));
      }

      pRet = pRet->ImpConvertToContourObj(bForceLineDash);
13
←
Called C++ object pointer is null
  }

  // #i73441# preserve LayerID
  if(pRet && pRet->GetLayer() != GetLayer())
  {
      pRet->SetLayer(GetLayer());
  }

  return pRet;
2508}


2511SdrObjectUniquePtr SdrObject::ConvertToPolyObj(bool bBezier, bool bLineToArea) const
2512{
  SdrObjectUniquePtr pRet = DoConvertToPolyObj(bBezier, true);

  if(pRet && bLineToArea)
1
Assuming 'bLineToArea' is true→
2
←
Taking true branch→
  {
      SdrObject* pNewRet = ConvertToContourObj(pRet.get());
3
←
Calling 'SdrObject::ConvertToContourObj'→
      pRet.reset(pNewRet);
  }

  // #i73441# preserve LayerID
  if(pRet && pRet->GetLayer() != GetLayer())
  {
      pRet->SetLayer(GetLayer());
  }

  return pRet;
2528}


2531SdrObjectUniquePtr SdrObject::DoConvertToPolyObj(bool /*bBezier*/, bool /*bAddText*/) const
2532{
  return nullptr;
2534}


2537void SdrObject::InsertedStateChange()
2538{
  const bool bIsInserted(nullptr != getParentSdrObjListFromSdrObject());
  const tools::Rectangle aBoundRect0(GetLastBoundRect());

  if(bIsInserted)
  {
      SendUserCall(SdrUserCallType::Inserted, aBoundRect0);
  }
  else
  {
      SendUserCall(SdrUserCallType::Removed, aBoundRect0);
  }

  if(nullptr != pPlusData && nullptr != pPlusData->pBroadcast)
  {
      SdrHint aHint(bIsInserted ? SdrHintKind::ObjectInserted : SdrHintKind::ObjectRemoved, *this);
      pPlusData->pBroadcast->Broadcast(aHint);
  }
2556}

2558void SdrObject::SetMoveProtect(bool bProt)
2559{
  if(IsMoveProtect() != bProt)
  {
      // #i77187# secured and simplified
      bMovProt = bProt;
      SetChanged();
      BroadcastObjectChange();
  }
2567}

2569void SdrObject::SetResizeProtect(bool bProt)
2570{
  if(IsResizeProtect() != bProt)
  {
      // #i77187# secured and simplified
      bSizProt = bProt;
      SetChanged();
      BroadcastObjectChange();
  }
2578}

2580void SdrObject::SetPrintable(bool bPrn)
2581{
  if( bPrn == bNoPrint )
  {
      bNoPrint=!bPrn;
      SetChanged();
      if (IsInserted())
      {
          SdrHint aHint(SdrHintKind::ObjectChange, *this);
          getSdrModelFromSdrObject().Broadcast(aHint);
      }
  }
2592}

2594void SdrObject::SetVisible(bool bVisible)
2595{
  if( bVisible != mbVisible )
  {
      mbVisible = bVisible;
      SetChanged();
      if (IsInserted())
      {
          SdrHint aHint(SdrHintKind::ObjectChange, *this);
          getSdrModelFromSdrObject().Broadcast(aHint);
      }
  }
2606}


2609sal_uInt16 SdrObject::GetUserDataCount() const
2610{
  if (pPlusData==nullptr || pPlusData->pUserDataList==nullptr) return 0;
  return pPlusData->pUserDataList->GetUserDataCount();
2613}

2615SdrObjUserData* SdrObject::GetUserData(sal_uInt16 nNum) const
2616{
  if (pPlusData==nullptr || pPlusData->pUserDataList==nullptr) return nullptr;
  return &pPlusData->pUserDataList->GetUserData(nNum);
2619}

2621void SdrObject::AppendUserData(std::unique_ptr<SdrObjUserData> pData)
2622{
  if (!pData)
  {
      OSL_FAIL("SdrObject::AppendUserData(): pData is NULL pointer.")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2625" ": "), "%s", "SdrObject::AppendUserData(): pData is NULL pointer."
); } } while (false);
      return;
  }

  ImpForcePlusData();
  if (!pPlusData->pUserDataList)
      pPlusData->pUserDataList.reset( new SdrObjUserDataList );

  pPlusData->pUserDataList->AppendUserData(std::move(pData));
2634}

2636void SdrObject::DeleteUserData(sal_uInt16 nNum)
2637{
  sal_uInt16 nCount=GetUserDataCount();
  if (nNum<nCount) {
      pPlusData->pUserDataList->DeleteUserData(nNum);
      if (nCount==1)  {
          pPlusData->pUserDataList.reset();
      }
  } else {
      OSL_FAIL("SdrObject::DeleteUserData(): Invalid Index.")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2645" ": "), "%s", "SdrObject::DeleteUserData(): Invalid Index."
); } } while (false);
  }
2647}

2649void SdrObject::SetUserCall(SdrObjUserCall* pUser)
2650{
  pUserCall = pUser;
2652}


2655void SdrObject::SendUserCall(SdrUserCallType eUserCall, const tools::Rectangle& rBoundRect) const
2656{
  SdrObject* pGroup(getParentSdrObjectFromSdrObject());

  if ( pUserCall )
  {
      pUserCall->Changed( *this, eUserCall, rBoundRect );
  }

  if(nullptr != pGroup && pGroup->GetUserCall())
  {
      // broadcast to group
      SdrUserCallType eChildUserType = SdrUserCallType::ChildChangeAttr;

      switch( eUserCall )
      {
          case SdrUserCallType::MoveOnly:
              eChildUserType = SdrUserCallType::ChildMoveOnly;
          break;

          case SdrUserCallType::Resize:
              eChildUserType = SdrUserCallType::ChildResize;
          break;

          case SdrUserCallType::ChangeAttr:
              eChildUserType = SdrUserCallType::ChildChangeAttr;
          break;

          case SdrUserCallType::Delete:
              eChildUserType = SdrUserCallType::ChildDelete;
          break;

          case SdrUserCallType::Inserted:
              eChildUserType = SdrUserCallType::ChildInserted;
          break;

          case SdrUserCallType::Removed:
              eChildUserType = SdrUserCallType::ChildRemoved;
          break;

          default: break;
      }

      pGroup->GetUserCall()->Changed( *this, eChildUserType, rBoundRect );
  }

  // notify our UNO shape listeners
  switch ( eUserCall )
  {
  case SdrUserCallType::Resize:
      notifyShapePropertyChange( svx::ShapeProperty::Size );
      [[fallthrough]]; // RESIZE might also imply a change of the position
  case SdrUserCallType::MoveOnly:
      notifyShapePropertyChange( svx::ShapeProperty::Position );
      break;
  default:
      // not interested in
      break;
  }
2714}

2716void SdrObject::impl_setUnoShape( const uno::Reference< uno::XInterface >& _rxUnoShape )
2717{
  const uno::Reference< uno::XInterface>& xOldUnoShape( maWeakUnoShape );
  // the UNO shape would be gutted by the following code; return early
  if ( _rxUnoShape == xOldUnoShape )
  {
      if ( !xOldUnoShape.is() )
      {
          // make sure there is no stale impl. pointer if the UNO
          // shape was destroyed meanwhile (remember we only hold weak
          // reference to it!)
          mpSvxShape = nullptr;
      }
      return;
  }

  bool bTransferOwnership( false );
  if ( xOldUnoShape.is() )
  {
      bTransferOwnership = mpSvxShape->HasSdrObjectOwnership();
      // Remove yourself from the current UNO shape. Its destructor
      // will reset our UNO shape otherwise.
      mpSvxShape->InvalidateSdrObject();
  }

  maWeakUnoShape = _rxUnoShape;
  mpSvxShape = comphelper::getUnoTunnelImplementation<SvxShape>( _rxUnoShape );

  // I think this may never happen... But I am not sure enough .-)
  if ( bTransferOwnership )
  {
      if (mpSvxShape)
          mpSvxShape->TakeSdrObjectOwnership();
      SAL_WARN( "svx.uno", "a UNO shape took over an SdrObject previously owned by another UNO shape!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx.uno")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.uno"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2749" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.uno"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2749" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.uno"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2749" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "a UNO shape took over an SdrObject previously owned by another UNO shape!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.uno"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2749" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
2751}

2753/** only for internal use! */
2754SvxShape* SdrObject::getSvxShape()
2755{
  DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false);
      // retrieving the impl pointer and subsequently using it is not thread-safe, of course, so it needs to be
      // guarded by the SolarMutex

  uno::Reference< uno::XInterface > xShape( maWeakUnoShape );
2761#if OSL_DEBUG_LEVEL1 > 0
  OSL_ENSURE( !( !xShape.is() && mpSvxShape ),do { if (true && (!(!( !xShape.is() && mpSvxShape
 )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2763" ": "), "%s", "SdrObject::getSvxShape: still having IMPL-Pointer to dead object!"
); } } while (false)
      "SdrObject::getSvxShape: still having IMPL-Pointer to dead object!" )do { if (true && (!(!( !xShape.is() && mpSvxShape
 )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2763" ": "), "%s", "SdrObject::getSvxShape: still having IMPL-Pointer to dead object!"
); } } while (false);
2764#endif
  //#113608#, make sure mpSvxShape is always synchronized with maWeakUnoShape
  if ( mpSvxShape && !xShape.is() )
      mpSvxShape = nullptr;

  return mpSvxShape;
2770}

2772css::uno::Reference< css::uno::XInterface > SdrObject::getUnoShape()
2773{
  // try weak reference first
  uno::Reference< uno::XInterface > xShape( getWeakUnoShape() );
  if( !xShape.is() )
  {
      OSL_ENSURE( mpSvxShape == nullptr, "SdrObject::getUnoShape: XShape already dead, but still an IMPL pointer!" )do { if (true && (!(mpSvxShape == nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2778" ": "), "%s", "SdrObject::getUnoShape: XShape already dead, but still an IMPL pointer!"
); } } while (false);

      // try to access SdrPage from this SdrObject. This will only exist if the SdrObject is
      // inserted in a SdrObjList (page/group/3dScene)
      SdrPage* pPageCandidate(getSdrPageFromSdrObject());

      // tdf#12152, tdf#120728
      //
      // With the paradigm change to only get a SdrPage for a SdrObject when the SdrObject
      // is *inserted*, the functionality for creating 1:1 associated UNO API implementation
      // SvxShapes was partially broken: The used ::CreateShape relies on the SvxPage being
      // derived and the CreateShape method overloaded, implementing additional SdrInventor
      // types as needed.
      //
      // The fallback to use SvxDrawPage::CreateShapeByTypeAndInventor is a trap: It's only
      // a static fallback that handles the SdrInventor types SdrInventor::E3d and
      // SdrInventor::Default. Due to that, e.g. the ReportDesigner broke in various conditions.
      //
      // That again has to do with the ReportDesigner being implemented using the UNO API
      // aspects of SdrObjects early during their construction, not just after these are
      // inserted to a SdrPage - but that is not illegal or wrong, the SdrObject exists already.
      //
      // As a current solution, use the (now always available) SdrModel and any of the
      // existing SdrPages. The only important thing is to get a SdrPage where ::CreateShape is
      // overloaded and implemented as needed.
      //
      // Note for the future:
      // In a more ideal world there would be only one factory method for creating SdrObjects (not
      // ::CreateShape and ::CreateShapeByTypeAndInventor). This also would not be placed at
      // SdrPage/SvxPage at all, but at the Model where it belongs - where else would you expect
      // objects for the current Model to be constructed? To have this at the Page only would make
      // sense if different shapes would need to be constructed for different Pages in the same Model
      // - this is never the case.
      // At that Model extended functionality for that factory (or overloads and implementations)
      // should be placed. But to be realistic, migrating the factories to Model now is too much
      // work - maybe over time when melting SdrObject/SvxObject one day...
      if(nullptr == pPageCandidate)
      {
          // If not inserted, alternatively access a SdrPage using the SdrModel. There is
          // no reason not to create and return a UNO API XShape when the SdrObject is not
          // inserted - it may be in construction. Main paradigm is that it exists.
          if(0 != getSdrModelFromSdrObject().GetPageCount())
          {
              // Take 1st SdrPage. That may be e.g. a special page (in SD), but the
              // to-be-used method ::CreateShape will be correctly overloaded in
              // all cases
              pPageCandidate = getSdrModelFromSdrObject().GetPage(0);
          }
      }

      if(nullptr != pPageCandidate)
      {
          uno::Reference< uno::XInterface > xPage(pPageCandidate->getUnoPage());
          if( xPage.is() )
          {
              SvxDrawPage* pDrawPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>(xPage);
              if( pDrawPage )
              {
                  // create one
                  xShape = pDrawPage->CreateShape( this );
                  impl_setUnoShape( xShape );
              }
          }
      }
      else
      {
          // Fallback to static base functionality. CAUTION: This will only support
          // the most basic stuff like SdrInventor::E3d and SdrInventor::Default. All
          // the other SdrInventor enum entries are from overloads and are *not accessible*
          // using this fallback (!) - what a bad trap
          mpSvxShape = SvxDrawPage::CreateShapeByTypeAndInventor( GetObjIdentifier(), GetObjInventor(), this );
          maWeakUnoShape = xShape = static_cast< ::cppu::OWeakObject* >( mpSvxShape );
      }
  }

  return xShape;
2854}

2856void SdrObject::setUnoShape(const uno::Reference<uno::XInterface >& _rxUnoShape)
2857{
  impl_setUnoShape( _rxUnoShape );
2859}

2861svx::PropertyChangeNotifier& SdrObject::getShapePropertyChangeNotifier()
2862{
  DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false);

  SvxShape* pSvxShape = getSvxShape();
  ENSURE_OR_THROW( pSvxShape, "no SvxShape, yet!" )if( !(pSvxShape) ){ do { if (true && (!(pSvxShape))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "2866" ": "), "%s", "no SvxShape, yet!"); } } while (false
); throw css::uno::RuntimeException( __func__ + OUStringLiteral
(u",\n" "no SvxShape, yet!"), css::uno::Reference< css::uno
::XInterface >() ); };
  return pSvxShape->getShapePropertyChangeNotifier();
2868}

2870void SdrObject::notifyShapePropertyChange( const svx::ShapeProperty _eProperty ) const
2871{
  DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false);

  SvxShape* pSvxShape = const_cast< SdrObject* >( this )->getSvxShape();
  if ( pSvxShape )
      return pSvxShape->getShapePropertyChangeNotifier().notifyPropertyChange( _eProperty );
2877}


2880// transformation interface for StarOfficeAPI. This implements support for
2881// homogeneous 3x3 matrices containing the transformation of the SdrObject. At the
2882// moment it contains a shearX, rotation and translation, but for setting all linear
2883// transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.


2886// gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
2887// with the base geometry and returns TRUE. Otherwise it returns FALSE.
2888bool SdrObject::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
2889{
  // any kind of SdrObject, just use SnapRect
  tools::Rectangle aRectangle(GetSnapRect());

  // convert to transformation values
  basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
  basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());

  // position maybe relative to anchorpos, convert
  if(getSdrModelFromSdrObject().IsWriter())
  {
      if(GetAnchorPos().X() || GetAnchorPos().Y())
      {
          aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
      }
  }

  // build matrix
  rMatrix = basegfx::utils::createScaleTranslateB2DHomMatrix(aScale, aTranslate);

  return false;
2910}

2912// sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix.
2913// If it's an SdrPathObj it will use the provided geometry information. The Polygon has
2914// to use (0,0) as upper left and will be scaled to the given size in the matrix.
2915void SdrObject::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
2916{
  // break up matrix
  basegfx::B2DTuple aScale;
  basegfx::B2DTuple aTranslate;
  double fRotate, fShearX;
  rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

  // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
  // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
  if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
  {
      aScale.setX(fabs(aScale.getX()));
      aScale.setY(fabs(aScale.getY()));
  }

  // if anchor is used, make position relative to it
  if(getSdrModelFromSdrObject().IsWriter())
  {
      if(GetAnchorPos().X() || GetAnchorPos().Y())
      {
          aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
      }
  }

  // build BaseRect
  Point aPoint(FRound(aTranslate.getX()), FRound(aTranslate.getY()));
  tools::Rectangle aBaseRect(aPoint, Size(FRound(aScale.getX()), FRound(aScale.getY())));

  // set BaseRect
  SetSnapRect(aBaseRect);
2946}

2948// Give info if object is in destruction
2949bool SdrObject::IsInDestruction() const
2950{
  return getSdrModelFromSdrObject().IsInDestruction();
2952}

2954// return if fill is != drawing::FillStyle_NONE
2955bool SdrObject::HasFillStyle() const
2956{
  return GetObjectItem(XATTR_FILLSTYLE).GetValue() != drawing::FillStyle_NONE;
2958}

2960bool SdrObject::HasLineStyle() const
2961{
  return GetObjectItem(XATTR_LINESTYLE).GetValue() != drawing::LineStyle_NONE;
2963}


2966// #i52224#
2967// on import of OLE object from MS documents the BLIP size might be retrieved,
2968// the following four methods are used to control it;
2969// usually this data makes no sense after the import is finished, since the object
2970// might be resized


2973void SdrObject::SetBLIPSizeRectangle( const tools::Rectangle& aRect )
2974{
  maBLIPSizeRectangle = aRect;
2976}

2978void SdrObject::SetContextWritingMode( const sal_Int16 /*_nContextWritingMode*/ )
2979{
  // this base class does not support different writing modes, so ignore the call
2981}

2983void SdrObject::SetDoNotInsertIntoPageAutomatically(const bool bSet)
2984{
  mbDoNotInsertIntoPageAutomatically = bSet;
2986}


2989// #i121917#
2990bool SdrObject::HasText() const
2991{
  return false;
2993}

2995bool SdrObject::IsTextBox() const
2996{
  return false;
2998}

3000void SdrObject::MakeNameUnique()
3001{
  std::unordered_set<OUString> aNameSet;
  MakeNameUnique(aNameSet);
3004}

3006void SdrObject::MakeNameUnique(std::unordered_set<OUString>& rNameSet)
3007{
  if (GetName().isEmpty())
      return;

  if (rNameSet.empty())
  {
      SdrPage* pPage;
      SdrObject* pObj;
      for (sal_uInt16 nPage(0); nPage < mrSdrModelFromSdrObject.GetPageCount(); ++nPage)
      {
          pPage = mrSdrModelFromSdrObject.GetPage(nPage);
          SdrObjListIter aIter(pPage, SdrIterMode::DeepWithGroups);
          while (aIter.IsMore())
          {
              pObj = aIter.Next();
              if (pObj != this)
                  rNameSet.insert(pObj->GetName());
          }
      }
  }

  OUString sName(GetName());
  OUString sRootName(GetName());
  sal_Int32 index = sName.lastIndexOf("_");
  if ( index > 0)
      sRootName = sRootName.copy(0, index);

  sal_uInt32 n = 0;
  while (rNameSet.find(sName) != rNameSet.end())
  {
      sName = sRootName + "_" + OUString::number(n++);
  }
  rNameSet.insert(sName);

  SetName(sName);
3042}

3044SdrObject* SdrObjFactory::CreateObjectFromFactory(SdrModel& rSdrModel, SdrInventor nInventor, sal_uInt16 nObjIdentifier)
3045{
  SdrObjCreatorParams aParams { nInventor, nObjIdentifier, rSdrModel };
  for (const auto & i : ImpGetUserMakeObjHdl()) {
      SdrObject* pObj = i.Call(aParams);
      if (pObj) {
          return pObj;
      }
  }
  return nullptr;
3054}

3056SdrObject* SdrObjFactory::MakeNewObject(
  SdrModel& rSdrModel,
  SdrInventor nInventor,
  sal_uInt16 nIdentifier,
  const tools::Rectangle* pSnapRect)
3061{
  SdrObject* pObj(nullptr);
  bool bSetSnapRect(nullptr != pSnapRect);

  if (nInventor == SdrInventor::Default)
  {
      switch (nIdentifier)
      {
          case OBJ_MEASURE:
          {
              if(nullptr != pSnapRect)
              {
                  pObj = new SdrMeasureObj(
                      rSdrModel,
                      pSnapRect->TopLeft(),
                      pSnapRect->BottomRight());
              }
              else
              {
                  pObj = new SdrMeasureObj(rSdrModel);
              }
          }
          break;
          case OBJ_LINE:
          {
              if(nullptr != pSnapRect)
              {
                  basegfx::B2DPolygon aPoly;

                  aPoly.append(
                      basegfx::B2DPoint(
                          pSnapRect->Left(),
                          pSnapRect->Top()));
                  aPoly.append(
                      basegfx::B2DPoint(
                          pSnapRect->Right(),
                          pSnapRect->Bottom()));
                  pObj = new SdrPathObj(
                      rSdrModel,
                      OBJ_LINE,
                      basegfx::B2DPolyPolygon(aPoly));
              }
              else
              {
                  pObj = new SdrPathObj(
                      rSdrModel,
                      OBJ_LINE);
              }
          }
          break;
          case OBJ_TEXT:
          case OBJ_TITLETEXT:
          case OBJ_OUTLINETEXT:
          {
              if(nullptr != pSnapRect)
              {
                  pObj = new SdrRectObj(
                      rSdrModel,
                      static_cast<SdrObjKind>(nIdentifier),
                      *pSnapRect);
                  bSetSnapRect = false;
              }
              else
              {
                  pObj = new SdrRectObj(
                      rSdrModel,
                      static_cast<SdrObjKind>(nIdentifier));
              }
          }
          break;
          case OBJ_CIRC:
          case OBJ_SECT:
          case OBJ_CARC:
          case OBJ_CCUT:
          {
              SdrCircKind eCircKind = ToSdrCircKind(static_cast<SdrObjKind>(nIdentifier));
              if(nullptr != pSnapRect)
              {
                  pObj = new SdrCircObj(rSdrModel, eCircKind, *pSnapRect);
                  bSetSnapRect = false;
              }
              else
              {
                  pObj = new SdrCircObj(rSdrModel, eCircKind);
              }
          }
          break;
          case sal_uInt16(OBJ_NONE       ): pObj=new SdrObject(rSdrModel);                   break;
          case sal_uInt16(OBJ_GRUP       ): pObj=new SdrObjGroup(rSdrModel);                 break;
          case sal_uInt16(OBJ_POLY       ): pObj=new SdrPathObj(rSdrModel, OBJ_POLY       ); break;
          case sal_uInt16(OBJ_PLIN       ): pObj=new SdrPathObj(rSdrModel, OBJ_PLIN       ); break;
          case sal_uInt16(OBJ_PATHLINE   ): pObj=new SdrPathObj(rSdrModel, OBJ_PATHLINE   ); break;
          case sal_uInt16(OBJ_PATHFILL   ): pObj=new SdrPathObj(rSdrModel, OBJ_PATHFILL   ); break;
          case sal_uInt16(OBJ_FREELINE   ): pObj=new SdrPathObj(rSdrModel, OBJ_FREELINE   ); break;
          case sal_uInt16(OBJ_FREEFILL   ): pObj=new SdrPathObj(rSdrModel, OBJ_FREEFILL   ); break;
          case sal_uInt16(OBJ_PATHPOLY   ): pObj=new SdrPathObj(rSdrModel, OBJ_POLY       ); break;
          case sal_uInt16(OBJ_PATHPLIN   ): pObj=new SdrPathObj(rSdrModel, OBJ_PLIN       ); break;
          case sal_uInt16(OBJ_EDGE       ): pObj=new SdrEdgeObj(rSdrModel);                  break;
          case sal_uInt16(OBJ_RECT       ): pObj=new SdrRectObj(rSdrModel);                  break;
          case sal_uInt16(OBJ_GRAF       ): pObj=new SdrGrafObj(rSdrModel);                  break;
          case sal_uInt16(OBJ_OLE2       ): pObj=new SdrOle2Obj(rSdrModel);                  break;
          case sal_uInt16(OBJ_FRAME      ): pObj=new SdrOle2Obj(rSdrModel, true);            break;
          case sal_uInt16(OBJ_CAPTION    ): pObj=new SdrCaptionObj(rSdrModel);               break;
          case sal_uInt16(OBJ_PAGE       ): pObj=new SdrPageObj(rSdrModel);                  break;
          case sal_uInt16(OBJ_UNO        ): pObj=new SdrUnoObj(rSdrModel, OUString());       break;
          case sal_uInt16(OBJ_CUSTOMSHAPE  ): pObj=new SdrObjCustomShape(rSdrModel);       break;
3167#if HAVE_FEATURE_AVMEDIA1
          case sal_uInt16(OBJ_MEDIA      ): pObj=new SdrMediaObj(rSdrModel);               break;
3169#endif
          case sal_uInt16(OBJ_TABLE      ): pObj=new sdr::table::SdrTableObj(rSdrModel);   break;
      }
  }

  if (!pObj)
  {
      pObj = CreateObjectFromFactory(rSdrModel, nInventor, nIdentifier);
  }

  if (!pObj)
  {
      // Well, if no one wants it...
      return nullptr;
  }

  if(bSetSnapRect && nullptr != pSnapRect)
  {
      pObj->SetSnapRect(*pSnapRect);
  }

  return pObj;
3191}

3193void SdrObjFactory::InsertMakeObjectHdl(Link<SdrObjCreatorParams, SdrObject*> const & rLink)
3194{
  std::vector<Link<SdrObjCreatorParams, SdrObject*>>& rLL=ImpGetUserMakeObjHdl();
  auto it = std::find(rLL.begin(), rLL.end(), rLink);
  if (it != rLL.end()) {
      OSL_FAIL("SdrObjFactory::InsertMakeObjectHdl(): Link already in place.")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdobj.cxx"
 ":" "3198" ": "), "%s", "SdrObjFactory::InsertMakeObjectHdl(): Link already in place."
); } } while (false);
  } else {
      rLL.push_back(rLink);
  }
3202}

3204void SdrObjFactory::RemoveMakeObjectHdl(Link<SdrObjCreatorParams, SdrObject*> const & rLink)
3205{
  std::vector<Link<SdrObjCreatorParams, SdrObject*>>& rLL=ImpGetUserMakeObjHdl();
  auto it = std::find(rLL.begin(), rLL.end(), rLink);
  if (it != rLL.end())
      rLL.erase(it);
3210}

3212namespace svx
3213{
  ISdrObjectFilter::~ISdrObjectFilter()
  {
  }
3217}

3219/* vim:set shiftwidth=4 softtabstop=4 expandtab: */