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 <svdglob.hxx>
  29 #include <svx/svdtrans.hxx>
  30 #include <basegfx/polygon/b2dpolygon.hxx>
  31 #include <basegfx/polygon/b2dpolygontools.hxx>
  32 #include <tools/helpers.hxx>
  33
  34 #include <svx/polypolygoneditor.hxx>
  35
  36 using namespace sdr;
  37
  38
  39 void SdrPolyEditView::ImpResetPolyPossibilityFlags()
  40 {
  41     eMarkedPointsSmooth=SdrPathSmoothKind::DontCare;
  42     eMarkedSegmentsKind=SdrPathSegmentKind::DontCare;
  43     bSetMarkedPointsSmoothPossible=false;
  44     bSetMarkedSegmentsKindPossible=false;
  45 }
  46
  47 SdrPolyEditView::SdrPolyEditView(SdrModel* pModel1, OutputDevice* pOut):
  48     SdrEditView(pModel1,pOut)
  49 {
  50     ImpResetPolyPossibilityFlags();
  51 }
  52
  53 SdrPolyEditView::~SdrPolyEditView()
  54 {
  55 }
  56
  57 void SdrPolyEditView::ImpCheckPolyPossibilities()
  58 {
  59     ImpResetPolyPossibilityFlags();
  60     const size_t nMarkCount(GetMarkedObjectCount());
  61
  62     if(nMarkCount && !ImpIsFrameHandles())
  63     {
  64         bool b1stSmooth(true);
  65         bool b1stSegm(true);
  66         bool bCurve(false);
  67         bool bSmoothFuz(false);
  68         bool bSegmFuz(false);
  69         basegfx::B2VectorContinuity eSmooth = basegfx::B2VectorContinuity::NONE;
  70
  71         for(size_t nMarkNum = 0; nMarkNum < nMarkCount; ++nMarkNum)
  72         {
  73             SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
  74             CheckPolyPossibilitiesHelper( pM, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth );
  75         }
  76     }
  77 }
  78
  79 void SdrPolyEditView::CheckPolyPossibilitiesHelper( SdrMark* pM, bool& b1stSmooth, bool& b1stSegm, bool& bCurve, bool& bSmoothFuz, bool& bSegmFuz, basegfx::B2VectorContinuity& eSmooth )
  80 {
  81     SdrObject* pObj = pM->GetMarkedSdrObj();
  82     SdrPathObj* pPath = dynamic_cast<SdrPathObj*>( pObj );
  83
  84     if (!pPath)
  85         return;
  86
  87     SdrUShortCont& rPts = pM->GetMarkedPoints();
  88     if (rPts.empty())
  89         return;
  90
  91     const bool bClosed(pPath->IsClosed());
  92     bSetMarkedPointsSmoothPossible = true;
  93
  94     if (bClosed)
  95     {
  96         bSetMarkedSegmentsKindPossible = true;
  97     }
  98
  99     for (SdrUShortCont::const_iterator it = rPts.begin(); it != rPts.end(); ++it)
 100     {
 101         sal_uInt32 nNum(*it);
 102         sal_uInt32 nPolyNum, nPntNum;
 103
 104         if(PolyPolygonEditor::GetRelativePolyPoint(pPath->GetPathPoly(), nNum, nPolyNum, nPntNum))
 105         {
 106             const basegfx::B2DPolygon aLocalPolygon(pPath->GetPathPoly().getB2DPolygon(nPolyNum));
 107             bool bCanSegment(bClosed || nPntNum < aLocalPolygon.count() - 1);
 108
 109             if(!bSetMarkedSegmentsKindPossible && bCanSegment)
 110             {
 111                 bSetMarkedSegmentsKindPossible = true;
 112             }
 113
 114             if(!bSmoothFuz)
 115             {
 116                 if (b1stSmooth)
 117                 {
 118                     b1stSmooth = false;
 119                     eSmooth = basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum);
 120                 }
 121                 else
 122                 {
 123                     bSmoothFuz = (eSmooth != basegfx::utils::getContinuityInPoint(aLocalPolygon, nPntNum));
 124                 }
 125             }
 126
 127             if(!bSegmFuz)
 128             {
 129                 if(bCanSegment)
 130                 {
 131                     bool bCrv(aLocalPolygon.isNextControlPointUsed(nPntNum));
 132
 133                     if(b1stSegm)
 134                     {
 135                         b1stSegm = false;
 136                         bCurve = bCrv;
 137                     }
 138                     else
 139                     {
 140                         bSegmFuz = (bCrv != bCurve);
 141                     }
 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     {
 194         SortMarkedObjects();
 195
 196         const bool bUndo = IsUndoEnabled();
 197         if( bUndo )
 198             BegUndo(ImpGetResStr(STR_EditSetPointsSmooth), GetDescriptionOfMarkedPoints());
 199         const size_t nMarkCount(GetMarkedObjectCount());
 200
 201         for(size_t nMarkNum(nMarkCount); nMarkNum > 0;)
 202         {
 203             --nMarkNum;
 204             SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 205             SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 206             if (!pPath)
 207                 continue;
 208
 209             SdrUShortCont& rPts = pM->GetMarkedPoints();
 210             PolyPolygonEditor aEditor(pPath->GetPathPoly());
 211             if (aEditor.SetPointsSmooth(eFlags, rPts))
 212             {
 213                 if( bUndo )
 214                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
 215                 pPath->SetPathPoly(aEditor.GetPolyPolygon());
 216             }
 217         }
 218
 219         if( bUndo )
 220             EndUndo();
 221     }
 222 }
 223
 224 void SdrPolyEditView::SetMarkedSegmentsKind(SdrPathSegmentKind eKind)
 225 {
 226     if(HasMarkedPoints())
 227     {
 228         SortMarkedObjects();
 229
 230         const bool bUndo = IsUndoEnabled();
 231         if( bUndo )
 232             BegUndo(ImpGetResStr(STR_EditSetSegmentsKind), GetDescriptionOfMarkedPoints());
 233         const size_t nMarkCount(GetMarkedObjectCount());
 234
 235         for(size_t nMarkNum=nMarkCount; nMarkNum > 0;)
 236         {
 237             --nMarkNum;
 238             SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 239             SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 240             if (!pPath)
 241                 continue;
 242             SdrUShortCont& rPts = pM->GetMarkedPoints();
 243             PolyPolygonEditor aEditor( pPath->GetPathPoly());
 244             if (aEditor.SetSegmentsKind(eKind, rPts))
 245             {
 246                 if( bUndo )
 247                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
 248                 pPath->SetPathPoly(aEditor.GetPolyPolygon());
 249             }
 250         }
 251
 252         if( bUndo )
 253             EndUndo();
 254     }
 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     {
 290         BrkAction();
 291         SortMarkedObjects();
 292         const size_t nMarkCount=GetMarkedObjectCount();
 293
 294         const bool bUndo = IsUndoEnabled();
 295         if( bUndo )
 296         {
 297             // Description
 298             BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Delete);
 299         }
 300
 301         for (size_t nMarkNum=nMarkCount; nMarkNum>0;)
 302         {
 303             --nMarkNum;
 304             SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
 305             SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() );
 306             if (!pPath)
 307                 continue;
 308
 309             SdrUShortCont& rPts = pM->GetMarkedPoints();
 310             PolyPolygonEditor aEditor( pPath->GetPathPoly());
 311             if (aEditor.DeletePoints(rPts))
 312             {
 313                 if( aEditor.GetPolyPolygon().count() )
 314                 {
 315                     if( bUndo )
 316                         AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath ));
 317                     pPath->SetPathPoly( aEditor.GetPolyPolygon() );
 318                 }
 319                 else
 320                 {
 321                     if( bUndo )
 322                         AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pPath ) );
 323                     pM->GetPageView()->GetObjList()->RemoveObject(pPath->GetOrdNum());
 324                     if( !bUndo )
 325                     {
 326                         SdrObject* pObj = pPath;
 327                         SdrObject::Free(pObj);
 328                     }
 329                 }
 330             }
 331         }
 332
 333         if( bUndo )
 334             EndUndo();
 335         UnmarkAllPoints();
 336         MarkListHasChanged();
 337     }
 338 }
 339
 340 void SdrPolyEditView::RipUpAtMarkedPoints()
 341 {
 342     if(HasMarkedPoints())
 343     {
 344         SortMarkedObjects();
 345         const size_t nMarkCount(GetMarkedObjectCount());
 346
 347         const bool bUndo = IsUndoEnabled();
 348         if( bUndo )
 349             BegUndo(ImpGetResStr(STR_EditRipUp), GetDescriptionOfMarkedPoints());
 350
 351         for(size_t nMarkNum = nMarkCount; nMarkNum > 0;)
 352         {
 353             --nMarkNum;
 354             SdrMark* pM = GetSdrMarkByIndex(nMarkNum);
 355             SdrPathObj* pObj = dynamic_cast<SdrPathObj*>( pM->GetMarkedSdrObj() );
 356             if (!pObj)
 357                 continue;
 358
 359             SdrUShortCont& rPts = pM->GetMarkedPoints();
 360
 361             if( bUndo )
 362                 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 363             bool bKorregFlag(false);
 364             sal_uInt32 nMax(pObj->GetHdlCount());
 365
 366             for(SdrUShortCont::const_reverse_iterator it = rPts.rbegin(); it != rPts.rend(); ++it)
 367             {
 368                 sal_uInt32 nNewPt0Idx(0);
 369                 SdrObject* pNewObj = pObj->RipPoint(*it, nNewPt0Idx);
 370
 371                 if(pNewObj)
 372                 {
 373                     pM->GetPageView()->GetObjList()->InsertObject(pNewObj, pObj->GetOrdNum() + 1);
 374                     if( bUndo )
 375                         AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pNewObj));
 376                     MarkObj(pNewObj, pM->GetPageView(), false, true);
 377                 }
 378
 379                 if(nNewPt0Idx)
 380                 {
 381                     // correction necessary?
 382                     DBG_ASSERT(!bKorregFlag,"Multiple index corrections at SdrPolyEditView::RipUp().");
 383                     if(!bKorregFlag)
 384                     {
 385                         bKorregFlag = true;
 386
 387                         SdrUShortCont aReplaceSet;
 388                         for(SdrUShortCont::const_iterator it2 = rPts.begin(); it2 != rPts.end(); ++it2)
 389                         {
 390                             sal_uInt32 nPntNum(*it2);
 391                             nPntNum += nNewPt0Idx;
 392
 393                             if(nPntNum >= nMax)
 394                             {
 395                                 nPntNum -= nMax;
 396                             }
 397
 398                             aReplaceSet.insert( (sal_uInt16)nPntNum );
 399                         }
 400                         rPts.swap(aReplaceSet);
 401
 402                         it = rPts.rbegin();
 403                     }
 404                 }
 405             }
 406         }
 407
 408         UnmarkAllPoints();
 409         if( bUndo )
 410             EndUndo();
 411         MarkListHasChanged();
 412     }
 413 }
 414
 415 bool SdrPolyEditView::IsRipUpAtMarkedPointsPossible() const
 416 {
 417     bool bRetval(false);
 418     const size_t nMarkCount(GetMarkedObjectCount());
 419
 420     for(size_t a = 0; a < nMarkCount; ++a)
 421     {
 422         const SdrMark* pMark = GetSdrMarkByIndex(a);
 423         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 424
 425         if (!pMarkedPathObject)
 426             continue;
 427
 428         const SdrUShortCont& rSelectedPoints = pMark->GetMarkedPoints();
 429         if (rSelectedPoints.empty())
 430             continue;
 431
 432         const basegfx::B2DPolyPolygon& rPathPolyPolygon = pMarkedPathObject->GetPathPoly();
 433
 434         if(1 == rPathPolyPolygon.count())
 435         {
 436             // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions
 437             // are different and methods need to be changed thoroughly with interaction rework
 438             const tools::Polygon aPathPolygon(rPathPolyPolygon.getB2DPolygon(0));
 439             const sal_uInt16 nPointCount(aPathPolygon.GetSize());
 440
 441             if(nPointCount >= 3)
 442             {
 443                 bRetval = pMarkedPathObject->IsClosedObj(); // #i76617#
 444
 445                 for(SdrUShortCont::const_iterator it = rSelectedPoints.begin();
 446                     !bRetval && it != rSelectedPoints.end(); ++it)
 447                 {
 448                     const sal_uInt16 nMarkedPointNum(*it);
 449
 450                     bRetval = (nMarkedPointNum > 0 && nMarkedPointNum < nPointCount - 1);
 451                 }
 452             }
 453         }
 454     }
 455
 456     return bRetval;
 457 }
 458
 459 bool SdrPolyEditView::IsOpenCloseMarkedObjectsPossible() const
 460 {
 461     bool bRetval(false);
 462     const size_t nMarkCount(GetMarkedObjectCount());
 463
 464     for(size_t a = 0; a < nMarkCount; ++a)
 465     {
 466         const SdrMark* pMark = GetSdrMarkByIndex(a);
 467         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 468
 469         if(pMarkedPathObject)
 470         {
 471             // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions
 472             // are different and methods need to be changed thoroughly with interaction rework
 473             const tools::PolyPolygon aPathPolyPolygon(pMarkedPathObject->GetPathPoly());
 474             const sal_uInt16 nPolygonCount(aPathPolyPolygon.Count());
 475
 476             for(sal_uInt16 b(0); !bRetval && b < nPolygonCount; b++)
 477             {
 478                 const tools::Polygon& rPathPolygon = aPathPolyPolygon[b];
 479                 const sal_uInt16 nPointCount(rPathPolygon.GetSize());
 480
 481                 bRetval = (nPointCount >= 3);
 482             }
 483         }
 484     }
 485
 486     return bRetval;
 487 }
 488
 489 SdrObjClosedKind SdrPolyEditView::GetMarkedObjectsClosedState() const
 490 {
 491     bool bOpen(false);
 492     bool bClosed(false);
 493     const size_t nMarkCount(GetMarkedObjectCount());
 494
 495     for(size_t a = 0; !(bOpen && bClosed) && a < nMarkCount; ++a)
 496     {
 497         const SdrMark* pMark = GetSdrMarkByIndex(a);
 498         const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj());
 499
 500         if(pMarkedPathObject)
 501         {
 502             if(pMarkedPathObject->IsClosedObj())
 503             {
 504                 bClosed = true;
 505             }
 506             else
 507             {
 508                 bOpen = true;
 509             }
 510         }
 511     }
 512
 513     if(bOpen && bClosed)
 514     {
 515         return SdrObjClosedKind::DontCare;
 516     }
 517     else if(bOpen)
 518     {
 519         return SdrObjClosedKind::Open;
 520     }
 521     else
 522     {
 523         return SdrObjClosedKind::Closed;
 524     }
 525 }
 526
 527 void SdrPolyEditView::ImpTransformMarkedPoints(PPolyTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4)
 528 {
 529     const bool bUndo = IsUndoEnabled();
 530
 531     const size_t nMarkCount=GetMarkedObjectCount();
 532     for (size_t nm=0; nm<nMarkCount; ++nm)
 533     {
 534         SdrMark* pM=GetSdrMarkByIndex(nm);
 535         SdrObject* pObj=pM->GetMarkedSdrObj();
 536         SdrPathObj* pPath=dynamic_cast<SdrPathObj*>( pObj );
 537         if (!pPath)
 538             continue;
 539
 540         const SdrUShortCont& rPts = pM->GetMarkedPoints();
 541         if (rPts.empty())
 542             continue;
 543
 544         if( bUndo )
 545             AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 546
 547         basegfx::B2DPolyPolygon aXPP(pPath->GetPathPoly());
 548
 549         for (SdrUShortCont::const_iterator it = rPts.begin(); it != rPts.end(); ++it)
 550         {
 551             sal_uInt32 nPt = *it;
 552             sal_uInt32 nPolyNum, nPointNum;
 553
 554             if(PolyPolygonEditor::GetRelativePolyPoint(aXPP, nPt, nPolyNum, nPointNum))
 555             {
 556                 //#i83671# used nLocalPointNum (which was the polygon point count)
 557                 // instead of the point index (nPointNum). This of course leaded
 558                 // to a wrong point access to the B2DPolygon.
 559                 basegfx::B2DPolygon aNewXP(aXPP.getB2DPolygon(nPolyNum));
 560                 Point aPos, aC1, aC2;
 561                 bool bC1(false);
 562                 bool bC2(false);
 563
 564                 const basegfx::B2DPoint aB2DPos(aNewXP.getB2DPoint(nPointNum));
 565                 aPos = Point(FRound(aB2DPos.getX()), FRound(aB2DPos.getY()));
 566
 567                 if(aNewXP.isPrevControlPointUsed(nPointNum))
 568                 {
 569                     const basegfx::B2DPoint aB2DC1(aNewXP.getPrevControlPoint(nPointNum));
 570                     aC1 = Point(FRound(aB2DC1.getX()), FRound(aB2DC1.getY()));
 571                     bC1 = true;
 572                 }
 573
 574                 if(aNewXP.isNextControlPointUsed(nPointNum))
 575                 {
 576                     const basegfx::B2DPoint aB2DC2(aNewXP.getNextControlPoint(nPointNum));
 577                     aC2 = Point(FRound(aB2DC2.getX()), FRound(aB2DC2.getY()));
 578                     bC2 = true;
 579                 }
 580
 581                 (*pTrFunc)(aPos,&aC1,&aC2,p1,p2,p3,p4);
 582                 aNewXP.setB2DPoint(nPointNum, basegfx::B2DPoint(aPos.X(), aPos.Y()));
 583
 584                 if (bC1)
 585                 {
 586                     aNewXP.setPrevControlPoint(nPointNum, basegfx::B2DPoint(aC1.X(), aC1.Y()));
 587                 }
 588
 589                 if (bC2)
 590                 {
 591                     aNewXP.setNextControlPoint(nPointNum, basegfx::B2DPoint(aC2.X(), aC2.Y()));
 592                 }
 593
 594                 aXPP.setB2DPolygon(nPolyNum, aNewXP);
 595             }
 596         }
 597
 598         pPath->SetPathPoly(aXPP);
 599     }
 600 }
 601
 602
 603 static void ImpMove(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/)
 604 {
 605     MovePoint(rPt,*static_cast<const Size*>(p1));
 606     if (pC1!=nullptr) MovePoint(*pC1,*static_cast<const Size*>(p1));
 607     if (pC2!=nullptr) MovePoint(*pC2,*static_cast<const Size*>(p1));
 608 }
 609
 610 void SdrPolyEditView::MoveMarkedPoints(const Size& rSiz)
 611 {
 612     ForceUndirtyMrkPnt();
 613     OUString aStr(ImpGetResStr(STR_EditMove));
 614     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Move);
 615     ImpTransformMarkedPoints(ImpMove,&rSiz);
 616     EndUndo();
 617     AdjustMarkHdl();
 618 }
 619
 620 static void ImpResize(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* p2, const void* p3, const void* /*p4*/)
 621 {
 622     ResizePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 623     if (pC1!=nullptr) ResizePoint(*pC1,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 624     if (pC2!=nullptr) ResizePoint(*pC2,*static_cast<const Point*>(p1),*static_cast<const Fraction*>(p2),*static_cast<const Fraction*>(p3));
 625 }
 626
 627 void SdrPolyEditView::ResizeMarkedPoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 628 {
 629     ForceUndirtyMrkPnt();
 630     OUString aStr(ImpGetResStr(STR_EditResize));
 631     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Resize);
 632     ImpTransformMarkedPoints(ImpResize,&rRef,&xFact,&yFact);
 633     EndUndo();
 634     AdjustMarkHdl();
 635 }
 636
 637 static void ImpRotate(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* p3, const void* p4)
 638 {
 639     RotatePoint(rPt,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 640     if (pC1!=nullptr) RotatePoint(*pC1,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 641     if (pC2!=nullptr) RotatePoint(*pC2,*static_cast<const Point*>(p1),*static_cast<const double*>(p3),*static_cast<const double*>(p4));
 642 }
 643
 644 void SdrPolyEditView::RotateMarkedPoints(const Point& rRef, long nAngle)
 645 {
 646     ForceUndirtyMrkPnt();
 647     OUString aStr(ImpGetResStr(STR_EditResize));
 648     BegUndo(aStr,GetDescriptionOfMarkedPoints(),SdrRepeatFunc::Rotate);
 649     double nSin=sin(nAngle*nPi180);
 650     double nCos=cos(nAngle*nPi180);
 651     ImpTransformMarkedPoints(ImpRotate,&rRef,&nAngle,&nSin,&nCos);
 652     EndUndo();
 653     AdjustMarkHdl();
 654 }
 655
 656 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */