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

Bug Summary

File:	home/maarten/src/libreoffice/core/svx/source/svdraw/svdedtv1.cxx
Warning:	line 339, column 13 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 svdedtv1.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/svdedtv1.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 <basegfx/matrix/b2dhommatrix.hxx>
21#include <basegfx/matrix/b2dhommatrixtools.hxx>
22#include <editeng/eeitem.hxx>
23#include <math.h>
24#include <svl/itemiter.hxx>
25#include <svl/whiter.hxx>
26#include <tools/bigint.hxx>
27#include <vcl/svapp.hxx>
28#include <vcl/weld.hxx>

30#include <getallcharpropids.hxx>
31#include <svx/dialmgr.hxx>
32#include <svx/svditer.hxx>
33#include <svx/strings.hrc>

35#include <AffineMatrixItem.hxx>
36#include <svx/e3dsceneupdater.hxx>
37#include <svx/obj3d.hxx>
38#include <svx/rectenum.hxx>
39#include <svx/sdr/contact/viewcontact.hxx>
40#include <svx/sdooitm.hxx>
41#include <svx/sderitm.hxx>
42#include <svx/sdtagitm.hxx>
43#include <svx/svdedtv.hxx>
44#include <svx/svdetc.hxx>
45#include <svx/svdopath.hxx>
46#include <svx/svdpage.hxx>
47#include <svx/svdpagv.hxx>
48#include <svx/svdtrans.hxx>
49#include <svx/svdundo.hxx>
50#include <svx/svxids.hrc>
51#include <sxallitm.hxx>
52#include <sxmovitm.hxx>
53#include <sxreaitm.hxx>
54#include <sxreoitm.hxx>
55#include <sxroaitm.hxx>
56#include <sxrooitm.hxx>
57#include <sxsalitm.hxx>
58#include <sxsoitm.hxx>
59#include <sxtraitm.hxx>
60#include <svx/xlnedwit.hxx>
61#include <svx/xlnstwit.hxx>
62#include <svx/xlnwtit.hxx>
63#include <svx/xlnclit.hxx>
64#include <svx/xflclit.hxx>
65#include <svx/xlntrit.hxx>
66#include <svx/xfltrit.hxx>
67#include <svx/sdprcitm.hxx>
68#include <LibreOfficeKit/LibreOfficeKitEnums.h>
69#include <rtl/ustring.hxx>
70#include <sfx2/viewsh.hxx>
71#include <comphelper/lok.hxx>

73// EditView


76void SdrEditView::SetMarkedObjRect(const tools::Rectangle& rRect)
77{
  DBG_ASSERT(!rRect.IsEmpty(),"SetMarkedObjRect() with an empty Rect does not make sense.")do { if (true && (!(!rRect.IsEmpty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdedtv1.cxx"
 ":" "78" ": "), "%s", "SetMarkedObjRect() with an empty Rect does not make sense."
); } } while (false);
  if (rRect.IsEmpty()) return;
  const size_t nCount=GetMarkedObjectCount();
  if (nCount==0) return;
  tools::Rectangle aR0(GetMarkedObjRect());
  DBG_ASSERT(!aR0.IsEmpty(),"SetMarkedObjRect(): GetMarkedObjRect() is empty.")do { if (true && (!(!aR0.IsEmpty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdedtv1.cxx"
 ":" "83" ": "), "%s", "SetMarkedObjRect(): GetMarkedObjRect() is empty."
); } } while (false);
  if (aR0.IsEmpty()) return;
  long x0=aR0.Left();
  long y0=aR0.Top();
  long w0=aR0.Right()-x0;
  long h0=aR0.Bottom()-y0;
  long x1=rRect.Left();
  long y1=rRect.Top();
  long w1=rRect.Right()-x1;
  long h1=rRect.Bottom()-y1;

  const bool bUndo = IsUndoEnabled();
  if( bUndo )
  {
      EndTextEditAllViews();
      BegUndo(ImpGetDescriptionString(STR_EditPosSizereinterpret_cast<char const *>("STR_EditPosSize" "\004"
 u8"Set position and size for %1")));
  }

  for (size_t nm=0; nm<nCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));

      tools::Rectangle aR1(pO->GetSnapRect());
      if (!aR1.IsEmpty())
      {
          if (aR1==aR0)
          {
              aR1=rRect;
          }
          else
          { // transform aR1 to aR0 after rRect
              aR1.Move(-x0,-y0);
              BigInt l(aR1.Left());
              BigInt r(aR1.Right());
              BigInt t(aR1.Top());
              BigInt b(aR1.Bottom());
              if (w0!=0) {
                  l*=w1; l/=w0;
                  r*=w1; r/=w0;
              } else {
                  l=0; r=w1;
              }
              if (h0!=0) {
                  t*=h1; t/=h0;
                  b*=h1; b/=h0;
              } else {
                  t=0; b=h1;
              }
              aR1.SetLeft(long(l) );
              aR1.SetRight(long(r) );
              aR1.SetTop(long(t) );
              aR1.SetBottom(long(b) );
              aR1.Move(x1,y1);
          }
          pO->SetSnapRect(aR1);
      } else {
          OSL_FAIL("SetMarkedObjRect(): pObj->GetSnapRect() returns empty Rect")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/svdraw/svdedtv1.cxx"
 ":" "142" ": "), "%s", "SetMarkedObjRect(): pObj->GetSnapRect() returns empty Rect"
); } } while (false);
      }
  }
  if( bUndo )
      EndUndo();
147}

149std::vector< std::unique_ptr<SdrUndoAction> > SdrEditView::CreateConnectorUndo( SdrObject& rO )
150{
  std::vector< std::unique_ptr<SdrUndoAction> > vUndoActions;

  if ( rO.GetBroadcaster() )
  {
      const SdrPage* pPage = rO.getSdrPageFromSdrObject();
      if ( pPage )
      {
          SdrObjListIter aIter(pPage, SdrIterMode::DeepWithGroups);
          while( aIter.IsMore() )
          {
              SdrObject* pPartObj = aIter.Next();
              if ( dynamic_cast<const SdrEdgeObj*>( pPartObj) !=  nullptr )
              {
                  if ( ( pPartObj->GetConnectedNode( false ) == &rO ) ||
                       ( pPartObj->GetConnectedNode( true  ) == &rO ) )
                  {
                      vUndoActions.push_back( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject( *pPartObj ) );
                  }
              }
          }
      }
  }
  return vUndoActions;
174}

176void SdrEditView::AddUndoActions( std::vector< std::unique_ptr<SdrUndoAction> > aUndoActions )
177{
  for (auto & rAction : aUndoActions)
      AddUndo( std::move(rAction) );
180}

182void SdrEditView::MoveMarkedObj(const Size& rSiz, bool bCopy)
183{
  const bool bUndo = IsUndoEnabled();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr(SvxResId(STR_EditMovereinterpret_cast<char const *>("STR_EditMove" "\004" u8"Move %1"
)));
      if (bCopy)
          aStr += SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      // needs its own UndoGroup because of its parameters
      BegUndo(aStr,GetDescriptionOfMarkedObjects(),SdrRepeatFunc::Move);
  }

  if (bCopy)
      CopyMarkedObj();

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
      {
          AddUndoActions( CreateConnectorUndo( *pO ) );
          AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pO,rSiz));
      }
      pO->Move(rSiz);
  }

  if( bUndo )
      EndUndo();
214}

216void SdrEditView::ResizeMarkedObj(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy)
217{
  const bool bUndo = IsUndoEnabled();
  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr {ImpGetDescriptionString(STR_EditResizereinterpret_cast<char const *>("STR_EditResize" "\004" u8"Resize %1"
))};
      if (bCopy)
          aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy)
      CopyMarkedObj();

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
      {
          AddUndoActions( CreateConnectorUndo( *pO ) );
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
      }
      pO->Resize(rRef,xFact,yFact);
  }

  if( bUndo )
      EndUndo();
246}
247void SdrEditView::ResizeMultMarkedObj(const Point& rRef,
  const Fraction& xFact,
  const Fraction& yFact,
  const bool bWdh,
  const bool bHgt)
252{
  const bool bUndo = IsUndoEnabled();
  if( bUndo )
  {
      EndTextEditAllViews();
      BegUndo(ImpGetDescriptionString(STR_EditResizereinterpret_cast<char const *>("STR_EditResize" "\004" u8"Resize %1"
)));
  }

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
      {
          AddUndoActions( CreateConnectorUndo( *pO ) );
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
      }

      Fraction aFrac(1,1);
      if (bWdh && bHgt)
          pO->Resize(rRef, xFact, yFact);
      else if (bWdh)
          pO->Resize(rRef, xFact, aFrac);
      else if (bHgt)
          pO->Resize(rRef, aFrac, yFact);
  }
  if( bUndo )
      EndUndo();
281}

283long SdrEditView::GetMarkedObjRotate() const
284{
  long nRetval(0);

  if(GetMarkedObjectCount())
  {
      SdrMark* pM = GetSdrMarkByIndex(0);
      SdrObject* pO = pM->GetMarkedSdrObj();

      nRetval = pO->GetRotateAngle();
  }

  return nRetval;
296}

298void SdrEditView::RotateMarkedObj(const Point& rRef, long nAngle, bool bCopy)
299{
  const bool bUndo = IsUndoEnabled();
  if( bUndo )
70
←
Assuming 'bUndo' is false→
71
←
Taking false branch→
  {
      EndTextEditAllViews();
      OUString aStr {ImpGetDescriptionString(STR_EditRotatereinterpret_cast<char const *>("STR_EditRotate" "\004" u8"Rotate %1"
))};
      if (bCopy) aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy71.1
'bCopy' is false
)
72
←
Taking false branch→
      CopyMarkedObj();

  double nSin = sin(nAngle * F_PI18000(3.14159265358979323846/18000.0));
  double nCos = cos(nAngle * F_PI18000(3.14159265358979323846/18000.0));
  const size_t nMarkCount(GetMarkedObjectCount());

  if(nMarkCount)
73
←
Assuming 'nMarkCount' is not equal to 0→
74
←
Taking true branch→
  {
      std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;

      for(size_t nm = 0; nm74.1
'nm' is < 'nMarkCount'
 < nMarkCount; ++nm)
75
←
Loop condition is true.  Entering loop body→
      {
          SdrMark* pM = GetSdrMarkByIndex(nm);
          SdrObject* pO = pM->GetMarkedSdrObj();
76
←
'pO' initialized here→

          if( bUndo76.1
'bUndo' is false
 )
77
←
Taking false branch→
          {
              // extra undo actions for changed connector which now may hold its laid out path (SJ)
              AddUndoActions( CreateConnectorUndo( *pO ) );

              AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
          }

          // set up a scene updater if object is a 3d object
          if(dynamic_cast< E3dObject* >(pO))
78
←
Assuming 'pO' is null→
79
←
Taking false branch→
          {
              aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
          }

          pO->Rotate(rRef,nAngle,nSin,nCos);
80
←
Called C++ object pointer is null
      }

      // fire scene updaters
      while(!aUpdaters.empty())
      {
          delete aUpdaters.back();
          aUpdaters.pop_back();
      }
  }

  if( bUndo )
      EndUndo();
352}

354void SdrEditView::MirrorMarkedObj(const Point& rRef1, const Point& rRef2, bool bCopy)
355{
  const bool bUndo = IsUndoEnabled();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr;
      Point aDif(rRef2-rRef1);
      if (aDif.X()==0)
          aStr = ImpGetDescriptionString(STR_EditMirrorHorireinterpret_cast<char const *>("STR_EditMirrorHori" "\004"
 u8"Flip %1 horizontal"));
      else if (aDif.Y()==0)
          aStr = ImpGetDescriptionString(STR_EditMirrorVertreinterpret_cast<char const *>("STR_EditMirrorVert" "\004"
 u8"Flip %1 vertical"));
      else if (std::abs(aDif.X()) == std::abs(aDif.Y()))
          aStr = ImpGetDescriptionString(STR_EditMirrorDiagreinterpret_cast<char const *>("STR_EditMirrorDiag" "\004"
 u8"Flip %1 diagonal"));
      else
          aStr = ImpGetDescriptionString(STR_EditMirrorFreereinterpret_cast<char const *>("STR_EditMirrorFree" "\004"
 u8"Flip %1 freehand"));
      if (bCopy) aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy)
      CopyMarkedObj();

  const size_t nMarkCount(GetMarkedObjectCount());

  if(nMarkCount)
  {
      std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;

      for(size_t nm = 0; nm < nMarkCount; ++nm)
      {
          SdrMark* pM = GetSdrMarkByIndex(nm);
          SdrObject* pO = pM->GetMarkedSdrObj();

          if( bUndo )
          {
              // extra undo actions for changed connector which now may hold its laid out path (SJ)
              AddUndoActions( CreateConnectorUndo( *pO ) );

              AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
          }

          // set up a scene updater if object is a 3d object
          if(dynamic_cast< E3dObject* >(pO))
          {
              aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pO));
          }

          pO->Mirror(rRef1,rRef2);
      }

      // fire scene updaters
      while(!aUpdaters.empty())
      {
          delete aUpdaters.back();
          aUpdaters.pop_back();
      }
  }

  if( bUndo )
      EndUndo();
416}

418void SdrEditView::MirrorMarkedObjHorizontal()
419{
  Point aCenter(GetMarkedObjRect().Center());
  Point aPt2(aCenter);
  aPt2.AdjustY( 1 );
  MirrorMarkedObj(aCenter,aPt2);
424}

426void SdrEditView::MirrorMarkedObjVertical()
427{
  Point aCenter(GetMarkedObjRect().Center());
  Point aPt2(aCenter);
  aPt2.AdjustX( 1 );
  MirrorMarkedObj(aCenter,aPt2);
432}

434long SdrEditView::GetMarkedObjShear() const
435{
  bool b1st=true;
  bool bOk=true;
  long nAngle=0;
  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount && bOk; ++nm) {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      long nAngle2=pO->GetShearAngle();
      if (b1st) nAngle=nAngle2;
      else if (nAngle2!=nAngle) bOk=false;
      b1st=false;
  }
  if (nAngle>SDRMAXSHEAR8900) nAngle=SDRMAXSHEAR8900;
  if (nAngle<-SDRMAXSHEAR8900) nAngle=-SDRMAXSHEAR8900;
  if (!bOk) nAngle=0;
  return nAngle;
452}

454void SdrEditView::ShearMarkedObj(const Point& rRef, long nAngle, bool bVShear, bool bCopy)
455{
  const bool bUndo = IsUndoEnabled();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr {ImpGetDescriptionString(STR_EditShearreinterpret_cast<char const *>("STR_EditShear" "\004" u8"Distort %1 (slant)"
))};
      if (bCopy)
          aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy)
      CopyMarkedObj();

  double nTan = tan(nAngle * F_PI18000(3.14159265358979323846/18000.0));
  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
      {
          AddUndoActions( CreateConnectorUndo( *pO ) );
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));
      }
      pO->Shear(rRef,nAngle,nTan,bVShear);
  }

  if( bUndo )
      EndUndo();
486}

488void SdrEditView::ImpCrookObj(SdrObject* pO, const Point& rRef, const Point& rRad,
  SdrCrookMode eMode, bool bVertical, bool bNoContortion, bool bRotate, const tools::Rectangle& rMarkRect)
490{
  SdrPathObj* pPath=dynamic_cast<SdrPathObj*>( pO );
  bool bDone = false;

  if(pPath!=nullptr && !bNoContortion)
  {
      XPolyPolygon aXPP(pPath->GetPathPoly());
      switch (eMode) {
          case SdrCrookMode::Rotate : CrookRotatePoly (aXPP,rRef,rRad,bVertical);           break;
          case SdrCrookMode::Slant  : CrookSlantPoly  (aXPP,rRef,rRad,bVertical);           break;
          case SdrCrookMode::Stretch: CrookStretchPoly(aXPP,rRef,rRad,bVertical,rMarkRect); break;
      } // switch
      pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
      bDone = true;
  }

  if(!bDone && !pPath && pO->IsPolyObj() && 0 != pO->GetPointCount())
  {
      // for PolyObj's, but NOT for SdrPathObj's, e.g. the measurement object
      sal_uInt32 nPointCount(pO->GetPointCount());
      XPolygon aXP(static_cast<sal_uInt16>(nPointCount));
      sal_uInt32 nPtNum;

      for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
      {
          Point aPt(pO->GetPoint(nPtNum));
          aXP[static_cast<sal_uInt16>(nPtNum)]=aPt;
      }

      switch (eMode)
      {
          case SdrCrookMode::Rotate : CrookRotatePoly (aXP,rRef,rRad,bVertical);           break;
          case SdrCrookMode::Slant  : CrookSlantPoly  (aXP,rRef,rRad,bVertical);           break;
          case SdrCrookMode::Stretch: CrookStretchPoly(aXP,rRef,rRad,bVertical,rMarkRect); break;
      }

      for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
      {
          // broadcasting could be optimized here, but for the
          // current two points of the measurement object, it's fine
          pO->SetPoint(aXP[static_cast<sal_uInt16>(nPtNum)],nPtNum);
      }

      bDone = true;
  }

  if(bDone)
      return;

  // for all others or if bNoContortion
  Point aCtr0(pO->GetSnapRect().Center());
  Point aCtr1(aCtr0);
  bool bRotOk(false);
  double nSin(0.0), nCos(1.0);
  double nAngle(0.0);

  if(0 != rRad.X() && 0 != rRad.Y())
  {
      bRotOk = bRotate;

      switch (eMode)
      {
          case SdrCrookMode::Rotate : nAngle=CrookRotateXPoint (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical); bRotOk=bRotate; break;
          case SdrCrookMode::Slant  : nAngle=CrookSlantXPoint  (aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical);           break;
          case SdrCrookMode::Stretch: nAngle=CrookStretchXPoint(aCtr1,nullptr,nullptr,rRef,rRad,nSin,nCos,bVertical,rMarkRect); break;
      }
  }

  aCtr1 -= aCtr0;

  if(bRotOk)
      pO->Rotate(aCtr0, FRound(nAngle / F_PI18000(3.14159265358979323846/18000.0)), nSin, nCos);

  pO->Move(Size(aCtr1.X(),aCtr1.Y()));
564}

566void SdrEditView::CrookMarkedObj(const Point& rRef, const Point& rRad, SdrCrookMode eMode,
  bool bVertical, bool bNoContortion, bool bCopy)
568{
  tools::Rectangle aMarkRect(GetMarkedObjRect());
  const bool bUndo = IsUndoEnabled();

  bool bRotate=bNoContortion && eMode==SdrCrookMode::Rotate && IsRotateAllowed();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr {ImpGetDescriptionString(bNoContortion ? STR_EditCrookreinterpret_cast<char const *>("STR_EditCrook" "\004" u8"Arrange %1 in circle"
) : STR_EditCrookContortionreinterpret_cast<char const *>("STR_EditCrookContortion"
 "\004" u8"Curve %1 in circle"))};
      if (bCopy)
          aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy)
      CopyMarkedObj();

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));

      const SdrObjList* pOL=pO->GetSubList();
      if (bNoContortion || pOL==nullptr) {
          ImpCrookObj(pO,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
      } else {
          SdrObjListIter aIter(pOL,SdrIterMode::DeepNoGroups);
          while (aIter.IsMore()) {
              SdrObject* pO1=aIter.Next();
              ImpCrookObj(pO1,rRef,rRad,eMode,bVertical,bNoContortion,bRotate,aMarkRect);
          }
      }
  }

  if( bUndo )
      EndUndo();
608}

610void SdrEditView::ImpDistortObj(SdrObject* pO, const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion)
611{
  SdrPathObj* pPath = dynamic_cast<SdrPathObj*>( pO );

  if(!bNoContortion && pPath)
  {
      XPolyPolygon aXPP(pPath->GetPathPoly());
      aXPP.Distort(rRef, rDistortedRect);
      pPath->SetPathPoly(aXPP.getB2DPolyPolygon());
  }
  else if(pO->IsPolyObj())
  {
      // e. g. for the measurement object
      sal_uInt32 nPointCount(pO->GetPointCount());
      XPolygon aXP(static_cast<sal_uInt16>(nPointCount));
      sal_uInt32 nPtNum;

      for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
      {
          Point aPt(pO->GetPoint(nPtNum));
          aXP[static_cast<sal_uInt16>(nPtNum)]=aPt;
      }

      aXP.Distort(rRef, rDistortedRect);

      for(nPtNum = 0; nPtNum < nPointCount; nPtNum++)
      {
          // broadcasting could be optimized here, but for the
          // current two points of the measurement object it's fine
          pO->SetPoint(aXP[static_cast<sal_uInt16>(nPtNum)],nPtNum);
      }
  }
642}

644void SdrEditView::DistortMarkedObj(const tools::Rectangle& rRef, const XPolygon& rDistortedRect, bool bNoContortion, bool bCopy)
645{
  const bool bUndo = IsUndoEnabled();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr {ImpGetDescriptionString(STR_EditDistortreinterpret_cast<char const *>("STR_EditDistort" "\004"
 u8"Distort %1"))};
      if (bCopy)
          aStr+=SvxResId(STR_EditWithCopyreinterpret_cast<char const *>("STR_EditWithCopy" "\004"
 u8"with copy"));
      BegUndo(aStr);
  }

  if (bCopy)
      CopyMarkedObj();

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pO=pM->GetMarkedSdrObj();
      if( bUndo )
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO));

      tools::Rectangle aRefRect(rRef);
      const SdrObjList* pOL=pO->GetSubList();
      if (bNoContortion || pOL==nullptr) {
          ImpDistortObj(pO,aRefRect,rDistortedRect,bNoContortion);
      } else {
          SdrObjListIter aIter(pOL,SdrIterMode::DeepNoGroups);
          while (aIter.IsMore()) {
              SdrObject* pO1=aIter.Next();
              ImpDistortObj(pO1,aRefRect,rDistortedRect,bNoContortion);
          }
      }
  }
  if( bUndo )
      EndUndo();
682}


685void SdrEditView::SetNotPersistAttrToMarked(const SfxItemSet& rAttr)
686{
  // bReplaceAll has no effect here
  tools::Rectangle aAllSnapRect(GetMarkedObjRect());
  const SfxPoolItem *pPoolItem=nullptr;
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1X,true,&pPoolItem)==SfxItemState::SET) {
46
←
Assuming the condition is false→
47
←
Taking false branch→
      long n=static_cast<const SdrTransformRef1XItem*>(pPoolItem)->GetValue();
      SetRef1(Point(n,GetRef1().Y()));
  }
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1Y,true,&pPoolItem)==SfxItemState::SET) {
48
←
Assuming the condition is false→
49
←
Taking false branch→
      long n=static_cast<const SdrTransformRef1YItem*>(pPoolItem)->GetValue();
      SetRef1(Point(GetRef1().X(),n));
  }
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2X,true,&pPoolItem)==SfxItemState::SET) {
50
←
Assuming the condition is false→
51
←
Taking false branch→
      long n=static_cast<const SdrTransformRef2XItem*>(pPoolItem)->GetValue();
      SetRef2(Point(n,GetRef2().Y()));
  }
  if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2Y,true,&pPoolItem)==SfxItemState::SET) {
52
←
Assuming the condition is false→
53
←
Taking false branch→
      long n=static_cast<const SdrTransformRef2YItem*>(pPoolItem)->GetValue();
      SetRef2(Point(GetRef2().X(),n));
  }
  long nAllPosX=0; bool bAllPosX=false;
  long nAllPosY=0; bool bAllPosY=false;
  long nAllWdt=0;  bool bAllWdt=false;
  long nAllHgt=0;  bool bAllHgt=false;
  bool bDoIt=false;
  if (rAttr.GetItemState(SDRATTR_ALLPOSITIONX,true,&pPoolItem)==SfxItemState::SET) {
54
←
Assuming the condition is false→
55
←
Taking false branch→
      nAllPosX=static_cast<const SdrAllPositionXItem*>(pPoolItem)->GetValue();
      bAllPosX=true; bDoIt=true;
  }
  if (rAttr.GetItemState(SDRATTR_ALLPOSITIONY,true,&pPoolItem)==SfxItemState::SET) {
56
←
Assuming the condition is false→
57
←
Taking false branch→
      nAllPosY=static_cast<const SdrAllPositionYItem*>(pPoolItem)->GetValue();
      bAllPosY=true; bDoIt=true;
  }
  if (rAttr.GetItemState(SDRATTR_ALLSIZEWIDTH,true,&pPoolItem)==SfxItemState::SET) {
58
←
Assuming the condition is false→
59
←
Taking false branch→
      nAllWdt=static_cast<const SdrAllSizeWidthItem*>(pPoolItem)->GetValue();
      bAllWdt=true; bDoIt=true;
  }
  if (rAttr.GetItemState(SDRATTR_ALLSIZEHEIGHT,true,&pPoolItem)==SfxItemState::SET) {
60
←
Assuming the condition is false→
61
←
Taking false branch→
      nAllHgt=static_cast<const SdrAllSizeHeightItem*>(pPoolItem)->GetValue();
      bAllHgt=true; bDoIt=true;
  }
  if (bDoIt61.1
'bDoIt' is false
) {
62
←
Taking false branch→
      tools::Rectangle aRect(aAllSnapRect); // TODO: change this for PolyPt's and GluePt's!!!
      if (bAllPosX) aRect.Move(nAllPosX-aRect.Left(),0);
      if (bAllPosY) aRect.Move(0,nAllPosY-aRect.Top());
      if (bAllWdt)  aRect.SetRight(aAllSnapRect.Left()+nAllWdt );
      if (bAllHgt)  aRect.SetBottom(aAllSnapRect.Top()+nAllHgt );
      SetMarkedObjRect(aRect);
  }
  if (rAttr.GetItemState(SDRATTR_RESIZEXALL,true,&pPoolItem)==SfxItemState::SET) {
63
←
Assuming the condition is false→
64
←
Taking false branch→
      Fraction aXFact=static_cast<const SdrResizeXAllItem*>(pPoolItem)->GetValue();
      ResizeMarkedObj(aAllSnapRect.TopLeft(),aXFact,Fraction(1,1));
  }
  if (rAttr.GetItemState(SDRATTR_RESIZEYALL,true,&pPoolItem)==SfxItemState::SET) {
65
←
Assuming the condition is false→
66
←
Taking false branch→
      Fraction aYFact=static_cast<const SdrResizeYAllItem*>(pPoolItem)->GetValue();
      ResizeMarkedObj(aAllSnapRect.TopLeft(),Fraction(1,1),aYFact);
  }
  if (rAttr.GetItemState(SDRATTR_ROTATEALL,true,&pPoolItem)==SfxItemState::SET) {
67
←
Assuming the condition is true→
68
←
Taking true branch→
      long nAngle=static_cast<const SdrRotateAllItem*>(pPoolItem)->GetValue();
      RotateMarkedObj(aAllSnapRect.Center(),nAngle);
69
←
Calling 'SdrEditView::RotateMarkedObj'→
  }
  if (rAttr.GetItemState(SDRATTR_HORZSHEARALL,true,&pPoolItem)==SfxItemState::SET) {
      long nAngle=static_cast<const SdrHorzShearAllItem*>(pPoolItem)->GetValue();
      ShearMarkedObj(aAllSnapRect.Center(),nAngle);
  }
  if (rAttr.GetItemState(SDRATTR_VERTSHEARALL,true,&pPoolItem)==SfxItemState::SET) {
      long nAngle=static_cast<const SdrVertShearAllItem*>(pPoolItem)->GetValue();
      ShearMarkedObj(aAllSnapRect.Center(),nAngle,true);
  }

  const bool bUndo = IsUndoEnabled();

  // TODO: check if WhichRange is necessary.
  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      const SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pObj=pM->GetMarkedSdrObj();
      if( bUndo )
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));

      pObj->ApplyNotPersistAttr(rAttr);
  }
769}

771void SdrEditView::MergeNotPersistAttrFromMarked(SfxItemSet& rAttr) const
772{
  // TODO: Take into account the origin and PvPos.
  tools::Rectangle aAllSnapRect(GetMarkedObjRect()); // TODO: change this for PolyPt's and GluePt's!!!
  long nAllSnapPosX=aAllSnapRect.Left();
  long nAllSnapPosY=aAllSnapRect.Top();
  long nAllSnapWdt=aAllSnapRect.GetWidth()-1;
  long nAllSnapHgt=aAllSnapRect.GetHeight()-1;
  // TODO: could go into CheckPossibilities
  bool bMovProtect = false, bMovProtectDC = false;
  bool bSizProtect = false, bSizProtectDC = false;
  bool bPrintable = true, bPrintableDC = false;
  bool bVisible = true, bVisibleDC = false;
  SdrLayerID nLayerId(0);
  bool bLayerDC=false;
  long nSnapPosX=0;      bool bSnapPosXDC=false;
  long nSnapPosY=0;      bool bSnapPosYDC=false;
  long nSnapWdt=0;       bool bSnapWdtDC=false;
  long nSnapHgt=0;       bool bSnapHgtDC=false;
  long nLogicWdt=0;      bool bLogicWdtDC=false,bLogicWdtDiff=false;
  long nLogicHgt=0;      bool bLogicHgtDC=false,bLogicHgtDiff=false;
  long nRotAngle=0;      bool bRotAngleDC=false;
  long nShrAngle=0;      bool bShrAngleDC=false;
  tools::Rectangle aSnapRect;
  tools::Rectangle aLogicRect;
  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm) {
      const SdrMark* pM=GetSdrMarkByIndex(nm);
      const SdrObject* pObj=pM->GetMarkedSdrObj();
      if (nm==0) {
          nLayerId=pObj->GetLayer();
          bMovProtect=pObj->IsMoveProtect();
          bSizProtect=pObj->IsResizeProtect();
          bPrintable =pObj->IsPrintable();
          bVisible = pObj->IsVisible();
          tools::Rectangle aSnapRect2(pObj->GetSnapRect());
          tools::Rectangle aLogicRect2(pObj->GetLogicRect());
          nSnapPosX=aSnapRect2.Left();
          nSnapPosY=aSnapRect2.Top();
          nSnapWdt=aSnapRect2.GetWidth()-1;
          nSnapHgt=aSnapRect2.GetHeight()-1;
          nLogicWdt=aLogicRect2.GetWidth()-1;
          nLogicHgt=aLogicRect2.GetHeight()-1;
          bLogicWdtDiff=nLogicWdt!=nSnapWdt;
          bLogicHgtDiff=nLogicHgt!=nSnapHgt;
          nRotAngle=pObj->GetRotateAngle();
          nShrAngle=pObj->GetShearAngle();
      } else {
          if (!bLayerDC      && nLayerId   !=pObj->GetLayer())        bLayerDC = true;
          if (!bMovProtectDC && bMovProtect!=pObj->IsMoveProtect())   bMovProtectDC = true;
          if (!bSizProtectDC && bSizProtect!=pObj->IsResizeProtect()) bSizProtectDC = true;
          if (!bPrintableDC  && bPrintable !=pObj->IsPrintable())     bPrintableDC = true;
          if (!bVisibleDC    && bVisible !=pObj->IsVisible())         bVisibleDC=true;
          if (!bRotAngleDC   && nRotAngle  !=pObj->GetRotateAngle())  bRotAngleDC=true;
          if (!bShrAngleDC   && nShrAngle  !=pObj->GetShearAngle())   bShrAngleDC=true;
          if (!bSnapWdtDC || !bSnapHgtDC || !bSnapPosXDC || !bSnapPosYDC || !bLogicWdtDiff || !bLogicHgtDiff) {
              aSnapRect=pObj->GetSnapRect();
              if (nSnapPosX!=aSnapRect.Left()) bSnapPosXDC=true;
              if (nSnapPosY!=aSnapRect.Top()) bSnapPosYDC=true;
              if (nSnapWdt!=aSnapRect.GetWidth()-1) bSnapWdtDC=true;
              if (nSnapHgt!=aSnapRect.GetHeight()-1) bSnapHgtDC=true;
          }
          if (!bLogicWdtDC || !bLogicHgtDC || !bLogicWdtDiff || !bLogicHgtDiff) {
              aLogicRect=pObj->GetLogicRect();
              if (nLogicWdt!=aLogicRect.GetWidth()-1) bLogicWdtDC=true;
              if (nLogicHgt!=aLogicRect.GetHeight()-1) bLogicHgtDC=true;
              if (!bLogicWdtDiff && aSnapRect.GetWidth()!=aLogicRect.GetWidth()) bLogicWdtDiff=true;
              if (!bLogicHgtDiff && aSnapRect.GetHeight()!=aLogicRect.GetHeight()) bLogicHgtDiff=true;
          }
      }
  }

  if (bSnapPosXDC || nAllSnapPosX!=nSnapPosX) rAttr.Put(SdrAllPositionXItem(nAllSnapPosX));
  if (bSnapPosYDC || nAllSnapPosY!=nSnapPosY) rAttr.Put(SdrAllPositionYItem(nAllSnapPosY));
  if (bSnapWdtDC  || nAllSnapWdt !=nSnapWdt ) rAttr.Put(SdrAllSizeWidthItem(nAllSnapWdt));
  if (bSnapHgtDC  || nAllSnapHgt !=nSnapHgt ) rAttr.Put(SdrAllSizeHeightItem(nAllSnapHgt));

  // items for pure transformations
  rAttr.Put(SdrMoveXItem());
  rAttr.Put(SdrMoveYItem());
  rAttr.Put(SdrResizeXOneItem());
  rAttr.Put(SdrResizeYOneItem());
  rAttr.Put(SdrRotateOneItem());
  rAttr.Put(SdrHorzShearOneItem());
  rAttr.Put(SdrVertShearOneItem());

  if (nMarkCount>1) {
      rAttr.Put(SdrResizeXAllItem());
      rAttr.Put(SdrResizeYAllItem());
      rAttr.Put(SdrRotateAllItem());
      rAttr.Put(SdrHorzShearAllItem());
      rAttr.Put(SdrVertShearAllItem());
  }

  if(meDragMode == SdrDragMode::Rotate || meDragMode == SdrDragMode::Mirror)
  {
      rAttr.Put(SdrTransformRef1XItem(GetRef1().X()));
      rAttr.Put(SdrTransformRef1YItem(GetRef1().Y()));
  }

  if(meDragMode == SdrDragMode::Mirror)
  {
      rAttr.Put(SdrTransformRef2XItem(GetRef2().X()));
      rAttr.Put(SdrTransformRef2YItem(GetRef2().Y()));
  }
876}

878SfxItemSet SdrEditView::GetAttrFromMarked(bool bOnlyHardAttr) const
879{
  SfxItemSet aSet(mpModel->GetItemPool());
  MergeAttrFromMarked(aSet,bOnlyHardAttr);
  //the EE_FEATURE items should not be set with SetAttrToMarked (see error message there)
  //so we do not set them here
  // #i32448#
  // Do not disable, but clear the items.
  aSet.ClearItem(EE_FEATURE_TAB);
  aSet.ClearItem(EE_FEATURE_LINEBR);
  aSet.ClearItem(EE_FEATURE_NOTCONV);
  aSet.ClearItem(EE_FEATURE_FIELD);

  return aSet;
892}

894void SdrEditView::MergeAttrFromMarked(SfxItemSet& rAttr, bool bOnlyHardAttr) const
895{
  const size_t nMarkCount(GetMarkedObjectCount());

  for(size_t a = 0; a < nMarkCount; ++a)
  {
      // #80277# merging was done wrong in the prev version
      const SfxItemSet& rSet = GetMarkedObjectByIndex(a)->GetMergedItemSet();
      SfxWhichIter aIter(rSet);
      sal_uInt16 nWhich(aIter.FirstWhich());

      while(nWhich)
      {
          if(!bOnlyHardAttr)
          {
              if(SfxItemState::DONTCARE == rSet.GetItemState(nWhich, false))
                  rAttr.InvalidateItem(nWhich);
              else
                  rAttr.MergeValue(rSet.Get(nWhich), true);
          }
          else if(SfxItemState::SET == rSet.GetItemState(nWhich, false))
          {
              const SfxPoolItem& rItem = rSet.Get(nWhich);
              rAttr.MergeValue(rItem, true);
          }

          if (comphelper::LibreOfficeKit::isActive())
          {
              OUString sPayload;
              switch(nWhich)
              {
                  case XATTR_LINECOLOR:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINECOLOR);
                      if (pItem)
                      {
                          Color aColor = static_cast<const XLineColorItem*>(pItem)->GetColorValue();
                          sPayload = OUString::number(static_cast<sal_uInt32>(aColor));

                          sPayload = ".uno:XLineColor=" + sPayload;
                      }
                      break;
                  }

                  case XATTR_FILLCOLOR:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLCOLOR);
                      if (pItem)
                      {
                          Color aColor = static_cast<const XFillColorItem*>(pItem)->GetColorValue();
                          sPayload = OUString::number(static_cast<sal_uInt32>(aColor));

                          sPayload = ".uno:FillColor=" + sPayload;
                      }
                      break;
                  }

                  case XATTR_FILLTRANSPARENCE:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(XATTR_FILLTRANSPARENCE);
                      if (pItem)
                      {
                          sal_uInt16 nTransparency = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
                          sPayload = OUString::number(nTransparency);

                          sPayload = ".uno:FillTransparence=" + sPayload;
                      }
                      break;
                  }

                  case XATTR_LINETRANSPARENCE:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINETRANSPARENCE);
                      if (pItem)
                      {
                          sal_uInt16 nTransparency = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
                          sPayload = OUString::number(nTransparency);

                          sPayload = ".uno:LineTransparence=" + sPayload;
                      }
                      break;
                  }

                  case XATTR_LINEWIDTH:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(XATTR_LINEWIDTH);
                      if (pItem)
                      {
                          sal_uInt32 nWidth = static_cast<const XLineWidthItem*>(pItem)->GetValue();
                          sPayload = OUString::number(nWidth);

                          sPayload = ".uno:LineWidth=" + sPayload;
                      }
                      break;
                  }

                  case SDRATTR_SHADOWTRANSPARENCE:
                  {
                      const SfxPoolItem* pItem = rSet.GetItem(SDRATTR_SHADOWTRANSPARENCE);
                      if (pItem)
                      {
                          sal_uInt16 nWidth = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
                          sPayload = OUString::number(nWidth);

                          sPayload = ".uno:FillShadowTransparency=" + sPayload;
                      }
                      break;
                  }
              }

              if (!sPayload.isEmpty())
                  GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                      OUStringToOString(sPayload, RTL_TEXTENCODING_ASCII_US(((rtl_TextEncoding) 11))).getStr());
          }

          nWhich = aIter.NextWhich();
      }
  }
1012}

1014std::vector<sal_uInt16> GetAllCharPropIds(const SfxItemSet& rSet)
1015{
  std::vector<sal_uInt16> aCharWhichIds;
  {
      SfxItemIter aIter(rSet);
      for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
      {
          if (!IsInvalidItem(pItem))
          {
              sal_uInt16 nWhich = pItem->Which();
              if (nWhich>=EE_CHAR_START && nWhich<=EE_CHAR_END)
                  aCharWhichIds.push_back( nWhich );
          }
      }
  }
  return aCharWhichIds;
1030}

1032void SdrEditView::SetAttrToMarked(const SfxItemSet& rAttr, bool bReplaceAll)
1033{
  if (!AreObjectsMarked())
33
←
Taking false branch→
      return;

1037#ifdef DBG_UTIL
  {
      bool bHasEEFeatureItems=false;
      SfxItemIter aIter(rAttr);
      for (const SfxPoolItem* pItem = aIter.GetCurItem(); !bHasEEFeatureItems && pItem;
           pItem = aIter.NextItem())
      {
          if (!IsInvalidItem(pItem)) {
              sal_uInt16 nW=pItem->Which();
              if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true;
          }
      }
      if(bHasEEFeatureItems)
      {
          std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
                                                        VclMessageType::Info, VclButtonsType::Ok,
                                                        "SdrEditView::SetAttrToMarked(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents."));
          xInfoBox->run();
      }
  }
1057#endif

  // #103836# if the user sets character attributes to the complete shape,
  //          we want to remove all hard set character attributes with same
  //          which ids from the text. We do that later but here we remember
  //          all character attribute which id's that are set.
  std::vector<sal_uInt16> aCharWhichIds(GetAllCharPropIds(rAttr));

  // To make Undo reconstruct text attributes correctly after Format.Standard
  bool bHasEEItems=SearchOutlinerItems(rAttr,bReplaceAll);

  // save additional geometry information when paragraph or character attributes
  // are changed and the geometrical shape of the text object might be changed
  bool bPossibleGeomChange(false);
  SfxWhichIter aIter(rAttr);
  sal_uInt16 nWhich = aIter.FirstWhich();
  while(!bPossibleGeomChange33.1
'bPossibleGeomChange' is false
 && nWhich)
34
←
Loop condition is false. Execution continues on line 1091→
  {
      SfxItemState eState = rAttr.GetItemState(nWhich);
      if(eState == SfxItemState::SET)
      {
          if((nWhich >= SDRATTR_TEXT_MINFRAMEHEIGHT && nWhich <= SDRATTR_TEXT_CONTOURFRAME)
              || nWhich == SDRATTR_3DOBJ_PERCENT_DIAGONAL
              || nWhich == SDRATTR_3DOBJ_BACKSCALE
              || nWhich == SDRATTR_3DOBJ_DEPTH
              || nWhich == SDRATTR_3DOBJ_END_ANGLE
              || nWhich == SDRATTR_3DSCENE_DISTANCE)
          {
              bPossibleGeomChange = true;
          }
      }
      nWhich = aIter.NextWhich();
  }

  const bool bUndo = IsUndoEnabled();
  if( bUndo )
35
←
Assuming 'bUndo' is false→
36
←
Taking false branch→
  {
      EndTextEditAllViews();
      BegUndo(ImpGetDescriptionString(STR_EditSetAttributesreinterpret_cast<char const *>("STR_EditSetAttributes" "\004"
 u8"Apply attributes to %1")));
  }

  const size_t nMarkCount(GetMarkedObjectCount());
  std::vector< E3DModifySceneSnapRectUpdater* > aUpdaters;

  // create ItemSet without SfxItemState::DONTCARE. Put()
  // uses its second parameter (bInvalidAsDefault) to
  // remove all such items to set them to default.
  SfxItemSet aAttr(*rAttr.GetPool(), rAttr.GetRanges());
  aAttr.Put(rAttr);

  // #i38135#
  bool bResetAnimationTimer(false);

  const bool bLineStartWidthExplicitChange(SfxItemState::SET
37
←
Assuming the condition is true→
                                           == aAttr.GetItemState(XATTR_LINESTARTWIDTH));
  const bool bLineEndWidthExplicitChange(SfxItemState::SET
38
←
Assuming the condition is true→
                                         == aAttr.GetItemState(XATTR_LINEENDWIDTH));
  // check if LineWidth is part of the change
  const bool bAdaptStartEndWidths(!(bLineStartWidthExplicitChange38.1
'bLineStartWidthExplicitChange' is true
 && bLineEndWidthExplicitChange)
                                   && SfxItemState::SET == aAttr.GetItemState(XATTR_LINEWIDTH));
  sal_Int32 nNewLineWidth(0);

  if(bAdaptStartEndWidths38.2
'bAdaptStartEndWidths' is false
)
39
←
Taking false branch→
  {
      nNewLineWidth = aAttr.Get(XATTR_LINEWIDTH).GetValue();
  }

  for (size_t nm=0; nm<nMarkCount; ++nm)
40
←
Assuming 'nm' is >= 'nMarkCount'→
41
←
Loop condition is false. Execution continues on line 1230→
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pObj = pM->GetMarkedSdrObj();

      if( bUndo )
      {
          SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >( pObj );
          if ( pEdgeObj )
              bPossibleGeomChange = true;
          else
              AddUndoActions( CreateConnectorUndo( *pObj ) );
      }

      // new geometry undo
      if(bPossibleGeomChange && bUndo)
      {
          // save position and size of object, too
          AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
      }

      if( bUndo )
      {
          // #i8508#
          // If this is a text object also rescue the OutlinerParaObject since
          // applying attributes to the object may change text layout when
          // multiple portions exist with multiple formats. If an OutlinerParaObject
          // really exists and needs to be rescued is evaluated in the undo
          // implementation itself.
          const bool bRescueText = dynamic_cast< SdrTextObj* >(pObj) != nullptr;

          // add attribute undo
          AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj,false,bHasEEItems || bPossibleGeomChange || bRescueText));
      }

      // set up a scene updater if object is a 3d object
      if(dynamic_cast< E3dObject* >(pObj))
      {
          aUpdaters.push_back(new E3DModifySceneSnapRectUpdater(pObj));
      }

      sal_Int32 nOldLineWidth(0);
      if (bAdaptStartEndWidths)
      {
          nOldLineWidth = pObj->GetMergedItem(XATTR_LINEWIDTH).GetValue();
      }

      // set attributes at object
      pObj->SetMergedItemSetAndBroadcast(aAttr, bReplaceAll);

      if(bAdaptStartEndWidths)
      {
          const SfxItemSet& rSet = pObj->GetMergedItemSet();

          if(nOldLineWidth != nNewLineWidth)
          {
              if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINESTARTWIDTH))
              {
                  const sal_Int32 nValAct(rSet.Get(XATTR_LINESTARTWIDTH).GetValue());
                  const sal_Int32 nValNewStart(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10)));

                  pObj->SetMergedItem(XLineStartWidthItem(nValNewStart));
              }

              if(SfxItemState::DONTCARE != rSet.GetItemState(XATTR_LINEENDWIDTH))
              {
                  const sal_Int32 nValAct(rSet.Get(XATTR_LINEENDWIDTH).GetValue());
                  const sal_Int32 nValNewEnd(std::max(sal_Int32(0), nValAct + (((nNewLineWidth - nOldLineWidth) * 15) / 10)));

                  pObj->SetMergedItem(XLineEndWidthItem(nValNewEnd));
              }
          }
      }

      if(dynamic_cast<const SdrTextObj*>( pObj) !=  nullptr)
      {
          SdrTextObj* pTextObj = static_cast<SdrTextObj*>(pObj);

          if(!aCharWhichIds.empty())
          {
              tools::Rectangle aOldBoundRect = pTextObj->GetLastBoundRect();

              // #110094#-14 pTextObj->SendRepaintBroadcast(pTextObj->GetBoundRect());
              pTextObj->RemoveOutlinerCharacterAttribs( aCharWhichIds );

              // object has changed, should be called from
              // RemoveOutlinerCharacterAttribs. This will change when the text
              // object implementation changes.
              pTextObj->SetChanged();

              pTextObj->BroadcastObjectChange();
              pTextObj->SendUserCall(SdrUserCallType::ChangeAttr, aOldBoundRect);
          }
      }

      // #i38495#
      if(!bResetAnimationTimer)
      {
          if(pObj->GetViewContact().isAnimatedInAnyViewObjectContact())
          {
              bResetAnimationTimer = true;
          }
      }
  }

  // fire scene updaters
  while(!aUpdaters.empty())
42
←
Assuming the condition is false→
43
←
Loop condition is false. Execution continues on line 1237→
  {
      delete aUpdaters.back();
      aUpdaters.pop_back();
  }

  // #i38135#
  if(bResetAnimationTimer43.1
'bResetAnimationTimer' is false
)
44
←
Taking false branch→
  {
      SetAnimationTimer(0);
  }

  // better check before what to do:
  // pObj->SetAttr() or SetNotPersistAttr()
  // TODO: missing implementation!
  SetNotPersistAttrToMarked(rAttr);
45
←
Calling 'SdrEditView::SetNotPersistAttrToMarked'→

  if( bUndo )
      EndUndo();
1249}

1251SfxStyleSheet* SdrEditView::GetStyleSheetFromMarked() const
1252{
  SfxStyleSheet* pRet=nullptr;
  bool b1st=true;
  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm) {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SfxStyleSheet* pSS=pM->GetMarkedSdrObj()->GetStyleSheet();
      if (b1st) pRet=pSS;
      else if (pRet!=pSS) return nullptr; // different stylesheets
      b1st=false;
  }
  return pRet;
1264}

1266void SdrEditView::SetStyleSheetToMarked(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
1267{
  if (!AreObjectsMarked())
      return;

  const bool bUndo = IsUndoEnabled();

  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr;
      if (pStyleSheet!=nullptr)
          aStr = ImpGetDescriptionString(STR_EditSetStylesheetreinterpret_cast<char const *>("STR_EditSetStylesheet" "\004"
 u8"Apply Styles to %1"));
      else
          aStr = ImpGetDescriptionString(STR_EditDelStylesheetreinterpret_cast<char const *>("STR_EditDelStylesheet" "\004"
 u8"Remove Style from %1"));
      BegUndo(aStr);
  }

  const size_t nMarkCount=GetMarkedObjectCount();
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      if( bUndo )
      {
          AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pM->GetMarkedSdrObj()));
          AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pM->GetMarkedSdrObj(),true,true));
      }
      pM->GetMarkedSdrObj()->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
  }

  if( bUndo )
      EndUndo();
1298}


1301void SdrEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
1302{
  if(GetMarkedObjectCount())
  {
      rTargetSet.Put(GetAttrFromMarked(bOnlyHardAttr), false);
  }
  else
  {
      SdrMarkView::GetAttributes(rTargetSet, bOnlyHardAttr);
  }
1311}

1313void SdrEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
1314{
  if (GetMarkedObjectCount()!=0) {
      SetAttrToMarked(rSet,bReplaceAll);
  } else {
      SdrMarkView::SetAttributes(rSet,bReplaceAll);
  }
1320}

1322SfxStyleSheet* SdrEditView::GetStyleSheet() const
1323{
  if (GetMarkedObjectCount()!=0) {
      return GetStyleSheetFromMarked();
  } else {
      return SdrMarkView::GetStyleSheet();
  }
1329}

1331void SdrEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
1332{
  if (GetMarkedObjectCount()!=0) {
      SetStyleSheetToMarked(pStyleSheet,bDontRemoveHardAttr);
  } else {
      SdrMarkView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
  }
1338}


1341SfxItemSet SdrEditView::GetGeoAttrFromMarked() const
1342{
  SfxItemSet aRetSet(
      mpModel->GetItemPool(),
      svl::Items< // SID_ATTR_TRANSFORM_... from s:svxids.hrc
          SDRATTR_ECKENRADIUS, SDRATTR_ECKENRADIUS,
          SID_ATTR_TRANSFORM_POS_XTypedWhichId<SfxInt32Item>( 10000 + 88 ), SID_ATTR_TRANSFORM_ANGLETypedWhichId<SfxInt32Item>( 10000 + 95 ),
          SID_ATTR_TRANSFORM_PROTECT_POSTypedWhichId<SfxBoolItem>( 10000 + 236 ), SID_ATTR_TRANSFORM_AUTOHEIGHT( 10000 + 311 )>{});

  if (AreObjectsMarked())
  {
      SfxItemSet aMarkAttr(GetAttrFromMarked(false)); // because of AutoGrowHeight and corner radius
      tools::Rectangle aRect(GetMarkedObjRect());

      if(GetSdrPageView())
      {
          GetSdrPageView()->LogicToPagePos(aRect);
      }

      // position
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_XTypedWhichId<SfxInt32Item>( 10000 + 88 ),aRect.Left()));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_YTypedWhichId<SfxInt32Item>( 10000 + 89 ),aRect.Top()));

      // size
      long nResizeRefX=aRect.Left();
      long nResizeRefY=aRect.Top();
      if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for resizing, too
          nResizeRefX=maRef1.X();
          nResizeRefY=maRef1.Y();
      }
      aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_WIDTHTypedWhichId<SfxUInt32Item>( 10000 + 90 ),aRect.Right()-aRect.Left()));
      aRetSet.Put(SfxUInt32Item(SID_ATTR_TRANSFORM_HEIGHTTypedWhichId<SfxUInt32Item>( 10000 + 91 ),aRect.Bottom()-aRect.Top()));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_X( 10000 + 308 ),nResizeRefX));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_RESIZE_REF_Y( 10000 + 309 ),nResizeRefY));

      Point aRotateAxe(maRef1);

      if(GetSdrPageView())
      {
          GetSdrPageView()->LogicToPagePos(aRotateAxe);
      }

      // rotation
      long nRotateRefX=aRect.Center().X();
      long nRotateRefY=aRect.Center().Y();
      if (meDragMode==SdrDragMode::Rotate) {
          nRotateRefX=aRotateAxe.X();
          nRotateRefY=aRotateAxe.Y();
      }
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ANGLETypedWhichId<SfxInt32Item>( 10000 + 95 ),GetMarkedObjRotate()));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_XTypedWhichId<SfxInt32Item>( 10000 + 93 ),nRotateRefX));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_YTypedWhichId<SfxInt32Item>( 10000 + 94 ),nRotateRefY));

      // shearing
      long nShearRefX=aRect.Left();
      long nShearRefY=aRect.Bottom();
      if (meDragMode==SdrDragMode::Rotate) { // use rotation axis as a reference for shearing, too
          nShearRefX=aRotateAxe.X();
          nShearRefY=aRotateAxe.Y();
      }
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR( 10000 + 304 ),GetMarkedObjShear()));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X( 10000 + 305 ),nShearRefX));
      aRetSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y( 10000 + 306 ),nShearRefY));

      // check every object whether it is protected
      const SdrMarkList& rMarkList=GetMarkedObjectList();
      const size_t nMarkCount=rMarkList.GetMarkCount();
      SdrObject* pObj=rMarkList.GetMark(0)->GetMarkedSdrObj();
      bool bPosProt=pObj->IsMoveProtect();
      bool bSizProt=pObj->IsResizeProtect();
      bool bPosProtDontCare=false;
      bool bSizProtDontCare=false;
      for (size_t i=1; i<nMarkCount && (!bPosProtDontCare || !bSizProtDontCare); ++i)
      {
          pObj=rMarkList.GetMark(i)->GetMarkedSdrObj();
          if (bPosProt!=pObj->IsMoveProtect()) bPosProtDontCare=true;
          if (bSizProt!=pObj->IsResizeProtect()) bSizProtDontCare=true;
      }

      // InvalidateItem sets item to DONT_CARE
      if (bPosProtDontCare) {
          aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_POSTypedWhichId<SfxBoolItem>( 10000 + 236 ));
      } else {
          aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_POSTypedWhichId<SfxBoolItem>( 10000 + 236 ),bPosProt));
      }
      if (bSizProtDontCare) {
          aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_PROTECT_SIZETypedWhichId<SfxBoolItem>( 10000 + 237 ));
      } else {
          aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_PROTECT_SIZETypedWhichId<SfxBoolItem>( 10000 + 237 ),bSizProt));
      }

      SfxItemState eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWWIDTH);
      bool bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWWIDTH).GetValue();
      if (eState==SfxItemState::DONTCARE) {
          aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOWIDTH( 10000 + 310 ));
      } else if (eState==SfxItemState::SET) {
          aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOWIDTH( 10000 + 310 ),bAutoGrow));
      }

      eState=aMarkAttr.GetItemState(SDRATTR_TEXT_AUTOGROWHEIGHT);
      bAutoGrow=aMarkAttr.Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue();
      if (eState==SfxItemState::DONTCARE) {
          aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_AUTOHEIGHT( 10000 + 311 ));
      } else if (eState==SfxItemState::SET) {
          aRetSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_AUTOHEIGHT( 10000 + 311 ),bAutoGrow));
      }

      eState=aMarkAttr.GetItemState(SDRATTR_ECKENRADIUS);
      long nRadius=aMarkAttr.Get(SDRATTR_ECKENRADIUS).GetValue();
      if (eState==SfxItemState::DONTCARE) {
          aRetSet.InvalidateItem(SDRATTR_ECKENRADIUS);
      } else if (eState==SfxItemState::SET) {
          aRetSet.Put(makeSdrEckenradiusItem(nRadius));
      }

      basegfx::B2DHomMatrix aTransformation;

      if(nMarkCount > 1)
      {
          // multiple objects, range is collected in aRect
          aTransformation = basegfx::utils::createScaleTranslateB2DHomMatrix(
              aRect.Left(), aRect.Top(),
              aRect.getWidth(), aRect.getHeight());
      }
      else
      {
          // single object, get homogen transformation
          basegfx::B2DPolyPolygon aPolyPolygon;

          pObj->TRGetBaseGeometry(aTransformation, aPolyPolygon);
      }

      if(aTransformation.isIdentity())
      {
          aRetSet.InvalidateItem(SID_ATTR_TRANSFORM_MATRIX( 10000 + 1131 ));
      }
      else
      {
          css::geometry::AffineMatrix2D aAffineMatrix2D;
          Point aPageOffset(0, 0);

          if(GetSdrPageView())
          {
              aPageOffset = GetSdrPageView()->GetPageOrigin();
          }

          aAffineMatrix2D.m00 = aTransformation.get(0, 0);
          aAffineMatrix2D.m01 = aTransformation.get(0, 1);
          aAffineMatrix2D.m02 = aTransformation.get(0, 2) - aPageOffset.X();
          aAffineMatrix2D.m10 = aTransformation.get(1, 0);
          aAffineMatrix2D.m11 = aTransformation.get(1, 1);
          aAffineMatrix2D.m12 = aTransformation.get(1, 2) - aPageOffset.Y();

          aRetSet.Put(AffineMatrixItem(&aAffineMatrix2D));
      }
  }

  return aRetSet;
1499}

1501static Point ImpGetPoint(const tools::Rectangle& rRect, RectPoint eRP)
1502{
  switch(eRP) {
      case RectPoint::LT: return rRect.TopLeft();
      case RectPoint::MT: return rRect.TopCenter();
      case RectPoint::RT: return rRect.TopRight();
      case RectPoint::LM: return rRect.LeftCenter();
      case RectPoint::MM: return rRect.Center();
      case RectPoint::RM: return rRect.RightCenter();
      case RectPoint::LB: return rRect.BottomLeft();
      case RectPoint::MB: return rRect.BottomCenter();
      case RectPoint::RB: return rRect.BottomRight();
  }
  return Point(); // Should not happen!
1515}

1517void SdrEditView::SetGeoAttrToMarked(const SfxItemSet& rAttr)
1518{
  const bool bTiledRendering = comphelper::LibreOfficeKit::isActive();

  tools::Rectangle aRect(GetMarkedObjRect());

  if(GetSdrPageView())
1
Assuming the condition is false→
2
←
Taking false branch→
  {
      GetSdrPageView()->LogicToPagePos(aRect);
  }

  long nOldRotateAngle=GetMarkedObjRotate();
  long nOldShearAngle=GetMarkedObjShear();
  const SdrMarkList& rMarkList=GetMarkedObjectList();
  const size_t nMarkCount=rMarkList.GetMarkCount();
  SdrObject* pObj=nullptr;

  RectPoint eSizePoint=RectPoint::MM;
  long nPosDX=0;
  long nPosDY=0;
  long nSizX=0;
  long nSizY=0;
  long nRotateAngle=0;

  bool bModeIsRotate(meDragMode == SdrDragMode::Rotate);
3
←
Assuming field 'meDragMode' is not equal to Rotate→
  long nRotateX(0);
  long nRotateY(0);
  long nOldRotateX(0);
  long nOldRotateY(0);
  if(bModeIsRotate3.1
'bModeIsRotate' is false
)
4
←
Taking false branch→
  {
      Point aRotateAxe(maRef1);

      if(GetSdrPageView())
      {
          GetSdrPageView()->LogicToPagePos(aRotateAxe);
      }

      nRotateX = nOldRotateX = aRotateAxe.X();
      nRotateY = nOldRotateY = aRotateAxe.Y();
  }

  long nShearAngle=0;
  long nShearX=0;
  long nShearY=0;
  bool bShearVert=false;

  bool bChgPos=false;
  bool bChgSiz=false;
  bool bChgWdh=false;
  bool bChgHgt=false;
  bool bRotate=false;
  bool bShear =false;

  bool bSetAttr=false;
  SfxItemSet aSetAttr(mpModel->GetItemPool());

  const SfxPoolItem* pPoolItem=nullptr;

  // position
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_XTypedWhichId<SfxInt32Item>( 10000 + 88 ),true,&pPoolItem)) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
      nPosDX=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - aRect.Left();
      bChgPos=true;
  }
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_POS_YTypedWhichId<SfxInt32Item>( 10000 + 89 ),true,&pPoolItem)){
7
←
Assuming the condition is false→
8
←
Taking false branch→
      nPosDY=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - aRect.Top();
      bChgPos=true;
  }
  // size
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_WIDTHTypedWhichId<SfxUInt32Item>( 10000 + 90 ),true,&pPoolItem)) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
      nSizX=static_cast<const SfxUInt32Item*>(pPoolItem)->GetValue();
      bChgSiz=true;
      bChgWdh=true;
  }
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_HEIGHTTypedWhichId<SfxUInt32Item>( 10000 + 91 ),true,&pPoolItem)) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
      nSizY=static_cast<const SfxUInt32Item*>(pPoolItem)->GetValue();
      bChgSiz=true;
      bChgHgt=true;
  }
  if (bChgSiz12.1
'bChgSiz' is false
) {
13
←
Taking false branch→
      if (bTiledRendering && SfxItemState::SET != rAttr.GetItemState(SID_ATTR_TRANSFORM_SIZE_POINTTypedWhichId<SfxUInt16Item>( 10000 + 92 ), true, &pPoolItem))
          eSizePoint = RectPoint::LT;
      else
          eSizePoint = static_cast<RectPoint>(rAttr.Get(SID_ATTR_TRANSFORM_SIZE_POINTTypedWhichId<SfxUInt16Item>( 10000 + 92 )).GetValue());
  }

  // rotation
  if (SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_DELTA_ANGLETypedWhichId<SfxInt32Item>( 10000 + 96 ), true, &pPoolItem)) {
14
←
Assuming the condition is false→
15
←
Taking false branch→
      nRotateAngle = static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
      bRotate = (nRotateAngle != 0);
  }

  // rotation
  if (SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_ANGLETypedWhichId<SfxInt32Item>( 10000 + 95 ), true, &pPoolItem)) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
      nRotateAngle = static_cast<const SfxInt32Item*>(pPoolItem)->GetValue() - nOldRotateAngle;
      bRotate = (nRotateAngle != 0);
  }

  // position rotation point x
  if(bRotate17.1
'bRotate' is false
 || SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_XTypedWhichId<SfxInt32Item>( 10000 + 93 ), true ,&pPoolItem))
18
←
Assuming the condition is false→
19
←
Taking false branch→
      nRotateX = rAttr.Get(SID_ATTR_TRANSFORM_ROT_XTypedWhichId<SfxInt32Item>( 10000 + 93 )).GetValue();

  // position rotation point y
  if(bRotate19.1
'bRotate' is false
 || SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_ROT_YTypedWhichId<SfxInt32Item>( 10000 + 94 ), true ,&pPoolItem))
20
←
Assuming the condition is false→
21
←
Taking false branch→
      nRotateY = rAttr.Get(SID_ATTR_TRANSFORM_ROT_YTypedWhichId<SfxInt32Item>( 10000 + 94 )).GetValue();

  // shearing
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_SHEAR( 10000 + 304 ),true,&pPoolItem)) {
22
←
Assuming the condition is false→
23
←
Taking false branch→
      long nNewShearAngle=static_cast<const SfxInt32Item*>(pPoolItem)->GetValue();
      if (nNewShearAngle>SDRMAXSHEAR8900) nNewShearAngle=SDRMAXSHEAR8900;
      if (nNewShearAngle<-SDRMAXSHEAR8900) nNewShearAngle=-SDRMAXSHEAR8900;
      if (nNewShearAngle!=nOldShearAngle) {
          bShearVert=static_cast<const SfxBoolItem&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_VERTICAL( 10000 + 307 ))).GetValue();
          if (bShearVert) {
              nShearAngle=nNewShearAngle;
          } else {
              if (nNewShearAngle!=0 && nOldShearAngle!=0) {
                  // bug fix
                  double nOld = tan(static_cast<double>(nOldShearAngle) * F_PI18000(3.14159265358979323846/18000.0));
                  double nNew = tan(static_cast<double>(nNewShearAngle) * F_PI18000(3.14159265358979323846/18000.0));
                  nNew-=nOld;
                  nNew = atan(nNew) / F_PI18000(3.14159265358979323846/18000.0);
                  nShearAngle=FRound(nNew);
              } else {
                  nShearAngle=nNewShearAngle-nOldShearAngle;
              }
          }
          bShear=nShearAngle!=0;
          if (bShear) {
              nShearX=static_cast<const SfxInt32Item&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_X( 10000 + 305 ))).GetValue();
              nShearY=static_cast<const SfxInt32Item&>(rAttr.Get(SID_ATTR_TRANSFORM_SHEAR_Y( 10000 + 306 ))).GetValue();
          }
      }
  }

  // AutoGrow
  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOWIDTH( 10000 + 310 ),true,&pPoolItem)) {
24
←
Assuming the condition is false→
25
←
Taking false branch→
      bool bAutoGrow=static_cast<const SfxBoolItem*>(pPoolItem)->GetValue();
      aSetAttr.Put(makeSdrTextAutoGrowWidthItem(bAutoGrow));
      bSetAttr=true;
  }

  if (SfxItemState::SET==rAttr.GetItemState(SID_ATTR_TRANSFORM_AUTOHEIGHT( 10000 + 311 ),true,&pPoolItem)) {
26
←
Assuming the condition is false→
27
←
Taking false branch→
      bool bAutoGrow=static_cast<const SfxBoolItem*>(pPoolItem)->GetValue();
      aSetAttr.Put(makeSdrTextAutoGrowHeightItem(bAutoGrow));
      bSetAttr=true;
  }

  // corner radius
  if (m_bEdgeRadiusAllowed && SfxItemState::SET==rAttr.GetItemState(SDRATTR_ECKENRADIUS,true,&pPoolItem)) {
28
←
Assuming field 'm_bEdgeRadiusAllowed' is true→
29
←
Assuming the condition is true→
30
←
Taking true branch→
      long nRadius=static_cast<const SdrMetricItem*>(pPoolItem)->GetValue();
      aSetAttr.Put(makeSdrEckenradiusItem(nRadius));
      bSetAttr=true;
  }

  ForcePossibilities();

  BegUndo(SvxResId(STR_EditTransformreinterpret_cast<char const *>("STR_EditTransform" "\004"
 u8"Transform %1")),GetDescriptionOfMarkedObjects());

  if (bSetAttr30.1
'bSetAttr' is true
) {
31
←
Taking true branch→
      SetAttrToMarked(aSetAttr,false);
32
←
Calling 'SdrEditView::SetAttrToMarked'→
  }

  // change size and height
  if (bChgSiz && (m_bResizeFreeAllowed || m_bResizePropAllowed)) {
      Fraction aWdt(nSizX,aRect.Right()-aRect.Left());
      Fraction aHgt(nSizY,aRect.Bottom()-aRect.Top());
      Point aRef(ImpGetPoint(aRect,eSizePoint));

      if(GetSdrPageView())
      {
          GetSdrPageView()->PagePosToLogic(aRef);
      }

      ResizeMultMarkedObj(aRef, aWdt, aHgt, bChgWdh, bChgHgt);
  }

  // rotate
  if (bRotate && (m_bRotateFreeAllowed || m_bRotate90Allowed)) {
      Point aRef(nRotateX,nRotateY);

      if(GetSdrPageView())
      {
          GetSdrPageView()->PagePosToLogic(aRef);
      }

      RotateMarkedObj(aRef,nRotateAngle);
  }

  // set rotation point position
  if(bModeIsRotate && (nRotateX != nOldRotateX || nRotateY != nOldRotateY))
  {
      Point aNewRef1(nRotateX, nRotateY);

      if(GetSdrPageView())
      {
          GetSdrPageView()->PagePosToLogic(aNewRef1);
      }

      SetRef1(aNewRef1);
  }

  // shear
  if (bShear && m_bShearAllowed) {
      Point aRef(nShearX,nShearY);

      if(GetSdrPageView())
      {
          GetSdrPageView()->PagePosToLogic(aRef);
      }

      ShearMarkedObj(aRef,nShearAngle,bShearVert);

      // #i74358#
      // ShearMarkedObj creates a linear combination of the existing transformation and
      // the new shear to apply. If the object is already transformed (e.g. rotated) the
      // linear combination will not decompose to the same start values again, but to a
      // new combination. Thus it makes no sense to check if the wanted shear is reached
      // or not. Taking out.
  }

  // change position
  if (bChgPos && m_bMoveAllowed) {
      MoveMarkedObj(Size(nPosDX,nPosDY));
  }

  // protect position
  if(SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_POSTypedWhichId<SfxBoolItem>( 10000 + 236 ), true, &pPoolItem))
  {
      const bool bProtPos(static_cast<const SfxBoolItem*>(pPoolItem)->GetValue());
      bool bChanged(false);

      for(size_t i = 0; i < nMarkCount; ++i)
      {
          pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

          if(pObj->IsMoveProtect() != bProtPos)
          {
              bChanged = true;
              pObj->SetMoveProtect(bProtPos);

              if(bProtPos)
              {
                  pObj->SetResizeProtect(true);
              }
          }
      }

      if(bChanged)
      {
          m_bMoveProtect = bProtPos;

          if(bProtPos)
          {
              m_bResizeProtect = true;
          }

          // #i77187# there is no simple method to get the toolbars updated
          // in the application. The App is listening to selection change and i
          // will use it here (even if not true). It's acceptable since changing
          // this model data is pretty rare and only possible using the F4 dialog
          MarkListHasChanged();
      }
  }

  if(!m_bMoveProtect)
  {
      // protect size
      if(SfxItemState::SET == rAttr.GetItemState(SID_ATTR_TRANSFORM_PROTECT_SIZETypedWhichId<SfxBoolItem>( 10000 + 237 ), true, &pPoolItem))
      {
          const bool bProtSize(static_cast<const SfxBoolItem*>(pPoolItem)->GetValue());
          bool bChanged(false);

          for(size_t i = 0; i < nMarkCount; ++i)
          {
              pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();

              if(pObj->IsResizeProtect() != bProtSize)
              {
                  bChanged = true;
                  pObj->SetResizeProtect(bProtSize);
              }
          }

          if(bChanged)
          {
              m_bResizeProtect = bProtSize;

              // #i77187# see above
              MarkListHasChanged();
          }
      }
  }

  EndUndo();
1812}


1815bool SdrEditView::IsAlignPossible() const
1816{  // at least two selected objects, at least one of them movable
  ForcePossibilities();
  const size_t nCount=GetMarkedObjectCount();
  if (nCount==0) return false;         // nothing selected!
  if (nCount==1) return m_bMoveAllowed;  // align single object to page
  return m_bOneOrMoreMovable;          // otherwise: MarkCount>=2
1822}

1824void SdrEditView::AlignMarkedObjects(SdrHorAlign eHor, SdrVertAlign eVert)
1825{
  if (eHor==SdrHorAlign::NONE && eVert==SdrVertAlign::NONE)
      return;

  SortMarkedObjects();
  if (!GetMarkedObjectCount())
      return;

  const bool bUndo = IsUndoEnabled();
  if( bUndo )
  {
      EndTextEditAllViews();
      OUString aStr(GetDescriptionOfMarkedObjects());
      if (eHor==SdrHorAlign::NONE)
      {
          switch (eVert)
          {
              case SdrVertAlign::Top:
                  aStr = ImpGetDescriptionString(STR_EditAlignVTopreinterpret_cast<char const *>("STR_EditAlignVTop" "\004"
 u8"Align %1 to top"));
                  break;
              case SdrVertAlign::Bottom:
                  aStr = ImpGetDescriptionString(STR_EditAlignVBottomreinterpret_cast<char const *>("STR_EditAlignVBottom" "\004"
 u8"Align %1 to bottom"));
                  break;
              case SdrVertAlign::Center:
                  aStr = ImpGetDescriptionString(STR_EditAlignVCenterreinterpret_cast<char const *>("STR_EditAlignVCenter" "\004"
 u8"Horizontally center %1"));
                  break;
              default: break;
          }
      }
      else if (eVert==SdrVertAlign::NONE)
      {
          switch (eHor)
          {
              case SdrHorAlign::Left:
                  aStr = ImpGetDescriptionString(STR_EditAlignHLeftreinterpret_cast<char const *>("STR_EditAlignHLeft" "\004"
 u8"Align %1 to left"));
                  break;
              case SdrHorAlign::Right:
                  aStr = ImpGetDescriptionString(STR_EditAlignHRightreinterpret_cast<char const *>("STR_EditAlignHRight" "\004"
 u8"Align %1 to right"));
                  break;
              case SdrHorAlign::Center:
                  aStr = ImpGetDescriptionString(STR_EditAlignHCenterreinterpret_cast<char const *>("STR_EditAlignHCenter" "\004"
 u8"Vertically center %1"));
                  break;
              default: break;
          }
      }
      else if (eHor==SdrHorAlign::Center && eVert==SdrVertAlign::Center)
      {
          aStr = ImpGetDescriptionString(STR_EditAlignCenterreinterpret_cast<char const *>("STR_EditAlignCenter" "\004"
 u8"Center %1"));
      }
      else
      {
          aStr = ImpGetDescriptionString(STR_EditAlignreinterpret_cast<char const *>("STR_EditAlign" "\004" u8"Align %1"
));
      }
      BegUndo(aStr);
  }

  tools::Rectangle aBound;
  const size_t nMarkCount=GetMarkedObjectCount();
  bool bHasFixed=false;
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pObj=pM->GetMarkedSdrObj();
      SdrObjTransformInfoRec aInfo;
      pObj->TakeObjInfo(aInfo);
      if (!aInfo.bMoveAllowed || pObj->IsMoveProtect())
      {
          tools::Rectangle aObjRect(pObj->GetSnapRect());
          aBound.Union(aObjRect);
          bHasFixed=true;
      }
  }
  if (!bHasFixed)
  {
      if (nMarkCount==1)
      {   // align single object to page
          const SdrObject* pObj=GetMarkedObjectByIndex(0);
          const SdrPage* pPage=pObj->getSdrPageFromSdrObject();
          const SdrPageGridFrameList* pGFL=pPage->GetGridFrameList(GetSdrPageViewOfMarkedByIndex(0),&(pObj->GetSnapRect()));
          const SdrPageGridFrame* pFrame=nullptr;
          if (pGFL!=nullptr && pGFL->GetCount()!=0)
          { // Writer
              pFrame=&((*pGFL)[0]);
          }

          if (pFrame!=nullptr)
          { // Writer
              aBound=pFrame->GetUserArea();
          }
          else
          {
              aBound=tools::Rectangle(pPage->GetLeftBorder(),pPage->GetUpperBorder(),
                               pPage->GetWidth()-pPage->GetRightBorder(),
                               pPage->GetHeight()-pPage->GetLowerBorder());
          }
      }
      else
      {
          aBound=GetMarkedObjRect();
      }
  }
  Point aCenter(aBound.Center());
  for (size_t nm=0; nm<nMarkCount; ++nm)
  {
      SdrMark* pM=GetSdrMarkByIndex(nm);
      SdrObject* pObj=pM->GetMarkedSdrObj();
      SdrObjTransformInfoRec aInfo;
      pObj->TakeObjInfo(aInfo);
      if (aInfo.bMoveAllowed && !pObj->IsMoveProtect())
      {
          long nXMov=0;
          long nYMov=0;
          tools::Rectangle aObjRect(pObj->GetSnapRect());
          switch (eVert)
          {
              case SdrVertAlign::Top   : nYMov=aBound.Top()   -aObjRect.Top()       ; break;
              case SdrVertAlign::Bottom: nYMov=aBound.Bottom()-aObjRect.Bottom()    ; break;
              case SdrVertAlign::Center: nYMov=aCenter.Y()    -aObjRect.Center().Y(); break;
              default: break;
          }
          switch (eHor)
          {
              case SdrHorAlign::Left  : nXMov=aBound.Left()  -aObjRect.Left()      ; break;
              case SdrHorAlign::Right : nXMov=aBound.Right() -aObjRect.Right()     ; break;
              case SdrHorAlign::Center: nXMov=aCenter.X()    -aObjRect.Center().X(); break;
              default: break;
          }
          if (nXMov!=0 || nYMov!=0)
          {
              // SdrEdgeObj needs an extra SdrUndoGeoObj since the
              // connections may need to be saved
              if( bUndo )
              {
                  if( dynamic_cast<SdrEdgeObj*>(pObj) )
                  {
                      AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
                  }

                  AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pObj,Size(nXMov,nYMov)));
              }

              pObj->Move(Size(nXMov,nYMov));
          }
      }
  }

  if( bUndo )
      EndUndo();
1973}

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