svx/source/svdraw/svdpoev.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <svx/svdpoev.hxx>
  22 #include <math.h>
  23 #include <svx/svdpagv.hxx>
  24 #include <svx/svdpage.hxx>
  25 #include <svx/svdopath.hxx>
  26 #include <svx/svdundo.hxx>
  27 #include <svx/strings.hrc>
  28 #include <svx/dialmgr.hxx>
  29 #include <svx/svdtrans.hxx>
  30 #include <basegfx/polygon/b2dpolygon.hxx>
  31 #include <basegfx/polygon/b2dpolygontools.hxx>
  32 #include <tools/debug.hxx>
  33 #include <tools/helpers.hxx>
  34
  35 #include <svx/polypolygoneditor.hxx>
  36
  37 using namespace sdr;
  38
  39
  40 void SdrPolyEditView::ImpResetPolyPossibilityFlags()
  41 {
  42     eMarkedPointsSmooth=SdrPathSmoothKind::DontCare;
  43     eMarkedSegmentsKind=SdrPathSegmentKind::DontCare;
  44     bSetMarkedPointsSmoothPossible=false;
  45     bSetMarkedSegmentsKindPossible=false;
  46 }
  47
  48 SdrPolyEditView::SdrPolyEditView(
  49     SdrModel& rSdrModel,
  50     OutputDevice* pOut)
  51 :   SdrEditView(rSdrModel, pOut)
  52 {
  53     ImpResetPolyPossibilityFlags();
  54 }
  55
  56 SdrPolyEditView::~SdrPolyEditView()
  57 {
  58 }
  59
  60 void SdrPolyEditView::ImpCheckPolyPossibilities()
  61 {
  62     ImpResetPolyPossibilityFlags();
  63     const size_t nMarkCount(GetMarkedObjectCount());
  64
  65     if(!nMarkCount || ImpIsFrameHandles())
  66         return;
  67
  68     bool b1stSmooth(true);
  69     bool b1stSegm(true);
  70     bool bCurve(false);
  71     bool bSmoothFuz(false);
  72     bool bSegmFuz(false);
  73     basegfx::B2VectorContinuity eSmooth = basegfx::B2VectorContinuity::NONE;
  74
  75     for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum)
  76     {
  77         SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
  78         CheckPolyPossibilitiesHelper( pM, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth );
  79     }
  80 }
  81
  82 void SdrPolyEditView::CheckPolyPossibilitiesHelper( SdrMark* pM, bool& b1stSmooth, bool& b1stSegm, bool& bCurve, bool& bSmoothFuz, bool& bSegmFuz, basegfx::B2VectorContinuity& eSmooth )
  83 {
  84     SdrObject* pObj = pM->GetMarkedSdrObj();
  85     SdrPathObj* pPath = dynamic_cast<SdrPathObj*>( pObj );
  86
  87     if (!pPath)
  88         return;
  89
  90     SdrUShortCont& rPts = pM->GetMarkedPoints();
  91     if (rPts.empty())
  92         return;
  93
  94     const bool bClosed(pPath->IsClosed());
  95     bSetMarkedPointsSmoothPossible = true;
  96
  97     if (bClosed)
  98     {
  99         bSetMarkedSegmentsKindPossible = true;
 100     }
 101
 102     for (const auto& rPt : rPts)
 103     {
 104         sal_uInt32 nNum(rPt);
 105         sal_uInt32 nPolyNum, nPntNum;
 106
 107         if(PolyPolygonEditor::GetRelativePolyPoint(pPath->GetPathPoly(), nNum, nPolyNum, nPntNum))
 108         {
 109             const basegfx::B2DPolygon aLocalPolygon(pPath->GetPathPoly().getB2DPolygon(nPolyNum));
 110             bool bCanSegment(bClosed || nPntNum < aLocalPolygon.count() - 1);
 111
 112             if(!bSetMarkedSegmentsKindPossible && bCanSegment)
 113             {
 114                 bSetMarkedSegmentsKindPossible = true;
 115             }
 116
 117             if(!bSmoothFuz)
 118             {
 119                 if (b1stSmooth)
 120                 {
 121                     b1stSmooth = false;
 122                     eSmooth = basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum);
 123                 }
 124                 else
 125                 {
 126                     bSmoothFuz = (eSmooth != basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum));
 127                 }
 128             }
 129
 130             if(!bSegmFuz && bCanSegment)
 131             {
 132                 bool bCrv(aLocalPolygon.isNextControlPointUsed(nPntNum));
 133
 134                 if(b1stSegm)
 135                 {
 136                     b1stSegm = false;
 137                     bCurve = bCrv;
 138                 }
 139                 else
 140                 {
 141                     bSegmFuz = (bCrv != bCurve);
 142                 }
 143             }
 144         }
 145     }
 146
 147     if(!b1stSmooth && !bSmoothFuz)
 148     {
 149         if(basegfx::B2VectorContinuity::NONE == eSmooth)
 150         {
 151             eMarkedPointsSmooth = SdrPathSmoothKind::Angular;
 152         }
 153
 154         if(basegfx::B2VectorContinuity::C1 == eSmooth)
 155         {
 156             eMarkedPointsSmooth = SdrPathSmoothKind::Asymmetric;
 157         }
 158
 159         if(basegfx::B2VectorContinuity::C2 == eSmooth)
 160         {
 161             eMarkedPointsSmooth = SdrPathSmoothKind::Symmetric;
 162         }
 163     }
 164
 165     if(!b1stSegm && !bSegmFuz)
 166     {
 167         eMarkedSegmentsKind = bCurve ? SdrPathSegmentKind::Curve : SdrPathSegmentKind::Line;
 168     }
 169 }
 170
 171 void SdrPolyEditView::SetMarkedPointsSmooth(SdrPathSmoothKind eKind)
 172 {
 173     basegfx::B2VectorContinuity eFlags;
 174
 175     if(SdrPathSmoothKind::Angular == eKind)
 176     {
 177         eFlags = basegfx::B2VectorContinuity::NONE;
 178     }
 179     else if(SdrPathSmoothKind::Asymmetric == eKind)
 180     {
 181         eFlags = basegfx::B2VectorContinuity::C1;
 182     }
 183     else if(SdrPathSmoothKind::Symmetric == eKind)
 184     {
 185         eFlags = basegfx::B2VectorContinuity::C2;
 186     }
 187     else
 188     {
 189         return;
 190     }
 191
 192     if(!HasMarkedPoints())
 193         return;
 194
 195     SortMarkedObjects();
 196
 197     const bool bUndo = IsUndoEnabled();
 198     if( bUndo )
 199         BegUndo(SvxResId(STR_EditSetPointsSmooth), GetDescriptionOfMarkedPoints());
 200     const size_t nMarkCount(GetMarkedObjectCount());
 201
 202     for(size_t nMarkNum(nMarkCount); nMarkNum > 0;)
 203     {
 204         --nMarkNum;
 205         SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 206         SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 207         if (!pPath)
 208             continue;
 209
 210         SdrUShortCont& rPts = pM->GetMarkedPoints();
 211         PolyPolygonEditor aEditor(pPath->GetPathPoly());
 212         if (aEditor.SetPointsSmooth(eFlags, rPts))
 213         {
 214             if( bUndo )
 215                 AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
 216             pPath->SetPathPoly(aEditor.GetPolyPolygon());
 217         }
 218     }
 219
 220     if( bUndo )
 221         EndUndo();
 222 }
 223
 224 void SdrPolyEditView::SetMarkedSegmentsKind(SdrPathSegmentKind eKind)
 225 {
 226     if(!HasMarkedPoints())
 227         return;
 228
 229     SortMarkedObjects();
 230
 231     const bool bUndo = IsUndoEnabled();
 232     if( bUndo )
 233         BegUndo(SvxResId(STR_EditSetSegmentsKind), GetDescriptionOfMarkedPoints());
 234     const size_t nMarkCount(GetMarkedObjectCount());
 235
 236     for(size_t nMarkNum=nMarkCount; nMarkNum > 0;)
 237     {
 238         --nMarkNum;
 239         SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 240         SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 241         if (!pPath)
 242             continue;
 243         SdrUShortCont& rPts = pM->GetMarkedPoints();
 244         PolyPolygonEditor aEditor( pPath->GetPathPoly());
 245         if (aEditor.SetSegmentsKind(eKind, rPts))
 246         {
 247             if( bUndo )
 248                 AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
 249             pPath->SetPathPoly(aEditor.GetPolyPolygon());
 250         }
 251     }
 252
 253     if( bUndo )
 254         EndUndo();
 255 }
 256
 257 bool SdrPolyEditView::IsSetMarkedPointsSmoothPossible() const
 258 {
 259     ForcePossibilities();
 260     return bSetMarkedPointsSmoothPossible;
 261 }
 262
 263 SdrPathSmoothKind SdrPolyEditView::GetMarkedPointsSmooth() const
 264 {
 265     ForcePossibilities();
 266     return eMarkedPointsSmooth;
 267 }
 268
 269 bool SdrPolyEditView::IsSetMarkedSegmentsKindPossible() const
 270 {
 271     ForcePossibilities();
 272     return bSetMarkedSegmentsKindPossible;
 273 }
 274
 275 SdrPathSegmentKind SdrPolyEditView::GetMarkedSegmentsKind() const
 276 {
 277     ForcePossibilities();
 278     return eMarkedSegmentsKind;
 279 }
 280
 281 bool SdrPolyEditView::IsDeleteMarkedPointsPossible() const
 282 {
 283     return HasMarkedPoints();
 284 }
 285
 286 void SdrPolyEditView::DeleteMarkedPoints()
 287 {
 288     if (!HasMarkedPoints())
 289         return;
 290
 291     BrkAction();
 292     SortMarkedObjects();
 293     const size_t nMarkCount=GetMarkedObjectCount();
 294
 295     const bool bUndo = IsUndoEnabled();
 296     if( bUndo )
 297     {
 298         // Description
 299         BegUndo(SvxResId(STR_EditDelete),GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Delete);
 300     }
 301
 302     for (size_t nMarkNum=nMarkCount; nMarkNum>0;)
 303     {
 304         --nMarkNum;
 305         SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 306         SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 307         if (!pPath)
 308             continue;
 309
 310         SdrUShortCont& rPts = pM->GetMarkedPoints();
 311         PolyPolygonEditor aEditor( pPath->GetPathPoly());
 312         if (aEditor.DeletePoints(rPts))
 313         {
 314             if( aEditor.GetPolyPolygon().count() )
 315             {
 316                 if (bUndo)
 317                     AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
 318                 pPath->SetPathPoly( aEditor.GetPolyPolygon() );
 319             }
 320             else
 321             {
 322                 if (bUndo)
 323                     AddUndo(GetModel().GetSdrUndoFactory().CreateUndoDeleteObject(*pPath));
 324                 pM->GetPageView()->GetObjList()->RemoveObject(pPath->GetOrdNum());
 325             }
 326         }
 327     }
 328
 329     if( bUndo )
 330         EndUndo();
 331     UnmarkAllPoints();
 332     MarkListHasChanged();
 333 }
 334
 335 void SdrPolyEditView::RipUpAtMarkedPoints()
 336 {
 337     if(!HasMarkedPoints())
 338         return;
 339
 340     SortMarkedObjects();
 341     const size_t nMarkCount(GetMarkedObjectCount());
 342
 343     const bool bUndo = IsUndoEnabled();
 344     if( bUndo )
 345         BegUndo(SvxResId(STR_EditRipUp), GetDescriptionOfMarkedPoints());
 346
 347     for(size_t nMarkNum = nMarkCount; nMarkNum > 0;)
 348     {
 349         --nMarkNum;
 350         SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 351         SdrPathObj* pObj = dynamic_cast<SdrPathObj*>( pM->GetMarkedSdrObj() );
 352         if (!pObj)
 353             continue;
 354
 355         SdrUShortCont& rPts = pM->GetMarkedPoints();
 356
 357         if (bUndo)
 358             AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 359         bool bCorrectionFlag(false);
 360         sal_uInt32 nMax(pObj->GetHdlCount());
 361
 362         for(SdrUShortCont::const_reverse_iterator it = rPts.rbegin(); it != rPts.rend(); ++it)
 363         {
 364             sal_uInt32 nNewPt0Idx(0);
 365             rtl::Reference<SdrPathObj> pNewObj = pObj->RipPoint(*it, nNewPt0Idx);
 366
 367             if(pNewObj)
 368             {
 369                 pM->GetPageView()->GetObjList()->InsertObject(pNewObj.get(), pObj->GetOrdNum() + 1);
 370                 if (bUndo)
 371                     AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pNewObj));
 372                 MarkObj(pNewObj.get(), pM->GetPageView(), false, true);
 373             }
 374
 375             if(nNewPt0Idx)
 376             {
 377                 // correction necessary?
 378                 DBG_ASSERT(!bCorrectionFlag,"Multiple index corrections at SdrPolyEditView::RipUp().");
 379                 if(!bCorrectionFlag)
 380                 {
 381                     bCorrectionFlag = true;
 382
 383                     SdrUShortCont aReplaceSet;
 384                     for(const auto& rPt : rPts)
 385                     {
 386                         sal_uInt32 nPntNum(rPt);
 387                         nPntNum += nNewPt0Idx;
 388
 389                         if(nPntNum >= nMax)
 390                         {
 391                             nPntNum -= nMax;
 392                         }
 393
 394                         aReplaceSet.insert( static_cast<sal_uInt16>(nPntNum) );
 395                     }
 396                     rPts.swap(aReplaceSet);
 397
 398                     it = rPts.rbegin();
 399                 }
 400             }
 401         }
 402     }
 403
 404     UnmarkAllPoints();
 405     if( bUndo )
 406         EndUndo();
 407     MarkListHasChanged();
 408 }
 409
 410 bool SdrPolyEditView::IsRipUpAtMarkedPointsPossible() const
 411 {
 412     bool bRetval(false);
 413     const size_t nMarkCount(GetMarkedObjectCount());
 414
 415     for(size_t a = 0; a < nMarkCount; ++a)
 416     {
 417         const SdrMark* pMark = GetSdrMarkByIndex(a);
 418         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 419
 420         if (!pMarkedPathObject)
 421             continue;
 422
 423         const SdrUShortCont& rSelectedPoints = pMark->GetMarkedPoints();
 424         if (rSelectedPoints.empty())
 425             continue;
 426
 427         const basegfx::B2DPolyPolygon& rPathPolyPolygon = pMarkedPathObject->GetPathPoly();
 428
 429         if(1 == rPathPolyPolygon.count())
 430         {
 431             // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions
 432             // are different and methods need to be changed thoroughly with interaction rework
 433             const tools::Polygon aPathPolygon(rPathPolyPolygon.getB2DPolygon(0));
 434             const sal_uInt16 nPointCount(aPathPolygon.GetSize());
 435
 436             if(nPointCount >= 3)
 437             {
 438                 bRetval = pMarkedPathObject->IsClosedObj() // #i76617#
 439                     || std::any_of(rSelectedPoints.begin(), rSelectedPoints.end(),
 440                         [nPointCount](const sal_uInt16 nMarkedPointNum) {
 441                             return nMarkedPointNum > 0 && nMarkedPointNum < nPointCount - 1;
 442                         });
 443             }
 444         }
 445     }
 446
 447     return bRetval;
 448 }
 449
 450 bool SdrPolyEditView::IsOpenCloseMarkedObjectsPossible() const
 451 {
 452     bool bRetval(false);
 453     const size_t nMarkCount(GetMarkedObjectCount());
 454
 455     for(size_t a = 0; a < nMarkCount; ++a)
 456     {
 457         const SdrMark* pMark = GetSdrMarkByIndex(a);
 458         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 459
 460         if(pMarkedPathObject)
 461         {
 462             // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions
 463             // are different and methods need to be changed thoroughly with interaction rework
 464             const tools::PolyPolygon aPathPolyPolygon(pMarkedPathObject->GetPathPoly());
 465             const sal_uInt16 nPolygonCount(aPathPolyPolygon.Count());
 466
 467             for(sal_uInt16 b(0); !bRetval && b < nPolygonCount; b++)
 468             {
 469                 const tools::Polygon& rPathPolygon = aPathPolyPolygon[b];
 470                 const sal_uInt16 nPointCount(rPathPolygon.GetSize());
 471
 472                 bRetval = (nPointCount >= 3);
 473             }
 474         }
 475     }
 476
 477     return bRetval;
 478 }
 479
 480 SdrObjClosedKind SdrPolyEditView::GetMarkedObjectsClosedState() const
 481 {
 482     bool bOpen(false);
 483     bool bClosed(false);
 484     const size_t nMarkCount(GetMarkedObjectCount());
 485
 486     for(size_t a = 0; !(bOpen && bClosed) && a < nMarkCount; ++a)
 487     {
 488         const SdrMark* pMark = GetSdrMarkByIndex(a);
 489         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 490
 491         if(pMarkedPathObject)
 492         {
 493             if(pMarkedPathObject->IsClosedObj())
 494             {
 495                 bClosed = true;
 496             }
 497             else
 498             {
 499                 bOpen = true;
 500             }
 501         }
 502     }
 503
 504     if(bOpen && bClosed)
 505     {
 506         return SdrObjClosedKind::DontCare;
 507     }
 508     else if(bOpen)
 509     {
 510         return SdrObjClosedKind::Open;
 511     }
 512     else
 513     {
 514         return SdrObjClosedKind::Closed;
 515     }
 516 }
 517
 518 void SdrPolyEditView::ImpTransformMarkedPoints(PPolyTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4)
 519 {
 520     const bool bUndo = IsUndoEnabled();
 521
 522     const size_t nMarkCount=GetMarkedObjectCount();
 523     for (size_t nm=0; nm<nMarkCount; ++nm)
 524     {
 525         SdrMark* pM=GetSdrMarkByIndex(nm);
 526         SdrObject* pObj=pM->GetMarkedSdrObj();
 527         SdrPathObj* pPath=dynamic_cast<SdrPathObj*>( pObj );
 528         if (!pPath)
 529             continue;
 530
 531         const SdrUShortCont& rPts = pM->GetMarkedPoints();
 532         if (rPts.empty())
 533             continue;
 534
 535         if( bUndo )
 536             AddUndo(GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 537
 538         basegfx::B2DPolyPolygon aXPP(pPath->GetPathPoly());
 539
 540         for (const auto& rPt : rPts)
 541         {
 542             sal_uInt32 nPt = rPt;
 543             sal_uInt32 nPolyNum, nPointNum;
 544
 545             if(PolyPolygonEditor::GetRelativePolyPoint(aXPP, nPt, nPolyNum, nPointNum))
 546             {
 547                 //#i83671# used nLocalPointNum (which was the polygon point count)
 548                 // instead of the point index (nPointNum). This of course led
 549                 // to a wrong point access to the B2DPolygon.
 550                 basegfx::B2DPolygon aNewXP(aXPP.getB2DPolygon(nPolyNum));
 551                 Point aPos, aC1, aC2;
 552                 bool bC1(false);
 553                 bool bC2(false);
 554
 555                 const basegfx::B2DPoint aB2DPos(aNewXP.getB2DPoint(nPointNum));
 556                 aPos = Point(FRound(aB2DPos.getX()), FRound(aB2DPos.getY()));
 557
 558                 if(aNewXP.isPrevControlPointUsed(nPointNum))
 559                 {
 560                     const basegfx::B2DPoint aB2DC1(aNewXP.getPrevControlPoint(nPointNum));
 561                     aC1 = Point(FRound(aB2DC1.getX()), FRound(aB2DC1.getY()));
 562                     bC1 = true;
 563                 }
 564
 565                 if(aNewXP.isNextControlPointUsed(nPointNum))
 566                 {
 567                     const basegfx::B2DPoint aB2DC2(aNewXP.getNextControlPoint(nPointNum));
 568                     aC2 = Point(FRound(aB2DC2.getX()), FRound(aB2DC2.getY()));
 569                     bC2 = true;
 570                 }
 571
 572                 (*pTrFunc)(aPos,&aC1,&aC2,p1,p2,p3,p4);
 573                 aNewXP.setB2DPoint(nPointNum, basegfx::B2DPoint(aPos.X(), aPos.Y()));
 574
 575                 if (bC1)
 576                 {
 577                     aNewXP.setPrevControlPoint(nPointNum, basegfx::B2DPoint(aC1.X(), aC1.Y()));
 578                 }
 579
 580                 if (bC2)
 581                 {
 582                     aNewXP.setNextControlPoint(nPointNum, basegfx::B2DPoint(aC2.X(), aC2.Y()));
 583                 }
 584
 585                 aXPP.setB2DPolygon(nPolyNum, aNewXP);
 586             }
 587         }
 588
 589         pPath->SetPathPoly(aXPP);
 590     }
 591 }
 592
 593
 594 static void ImpMove(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/)
 595 {
 596     rPt.Move(*static_cast<const Size*>(p1));
 597     if (pC1!=nullptr) pC1->Move(*static_cast<const Size*>(p1));
 598     if (pC2!=nullptr) pC2->Move(*static_cast<const Size*>(p1));
 599 }
 600
 601 void SdrPolyEditView::MoveMarkedPoints(const Size& rSiz)
 602 {
 603     ForceUndirtyMrkPnt();
 604     OUString aStr(SvxResId(STR_EditMove));
 605     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Move);
 606     ImpTransformMarkedPoints(ImpMove,&rSiz);
 607     EndUndo();
 608     AdjustMarkHdl();
 609 }
 610
 611 static void ImpResize(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* p2, const void* p3, const void* /*p4*/)
 612 {
 613     ResizePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 614     if (pC1!=nullptr) ResizePoint(*pC1,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 615     if (pC2!=nullptr) ResizePoint(*pC2,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 616 }
 617
 618 void SdrPolyEditView::ResizeMarkedPoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 619 {
 620     ForceUndirtyMrkPnt();
 621     OUString aStr(SvxResId(STR_EditResize));
 622     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Resize);
 623     ImpTransformMarkedPoints(ImpResize,&rRef,&xFact,&yFact);
 624     EndUndo();
 625     AdjustMarkHdl();
 626 }
 627
 628 static void ImpRotate(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* p3, const void* p4)
 629 {
 630     RotatePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 631     if (pC1!=nullptr) RotatePoint(*pC1,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 632     if (pC2!=nullptr) RotatePoint(*pC2,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 633 }
 634
 635 void SdrPolyEditView::RotateMarkedPoints(const Point& rRef, Degree100 nAngle)
 636 {
 637     ForceUndirtyMrkPnt();
 638     OUString aStr(SvxResId(STR_EditResize));
 639     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Rotate);
 640     double nSin = sin(toRadians(nAngle));
 641     double nCos = cos(toRadians(nAngle));
 642     ImpTransformMarkedPoints(ImpRotate,&rRef,&nAngle,&nSin,&nCos);
 643     EndUndo();
 644     AdjustMarkHdl();
 645 }
 646
 647 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */