1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svx.hxx" 26 27 #include <svx/svdpoev.hxx> 28 #include <math.h> 29 #include <svx/svdpagv.hxx> 30 #include <svx/svdpage.hxx> 31 #include <svx/svdopath.hxx> 32 #include <svx/svdundo.hxx> 33 #include "svx/svdstr.hrc" // Namen aus der Resource 34 #include "svx/svdglob.hxx" // StringCache 35 #include <svx/svdtrans.hxx> 36 #include <basegfx/polygon/b2dpolygon.hxx> 37 #include <basegfx/polygon/b2dpolygontools.hxx> 38 #include <vcl/salbtype.hxx> // FRound 39 40 #include <svx/polypolygoneditor.hxx> 41 42 using namespace sdr; 43 44 //////////////////////////////////////////////////////////////////////////////////////////////////// 45 46 void SdrPolyEditView::ImpResetPolyPossibilityFlags() 47 { 48 eMarkedPointsSmooth=SDRPATHSMOOTH_DONTCARE; 49 eMarkedSegmentsKind=SDRPATHSEGMENT_DONTCARE; 50 bSetMarkedPointsSmoothPossible=sal_False; 51 bSetMarkedSegmentsKindPossible=sal_False; 52 } 53 54 void SdrPolyEditView::ImpClearVars() 55 { 56 ImpResetPolyPossibilityFlags(); 57 } 58 59 SdrPolyEditView::SdrPolyEditView(SdrModel* pModel1, OutputDevice* pOut): 60 SdrEditView(pModel1,pOut) 61 { 62 ImpClearVars(); 63 } 64 65 SdrPolyEditView::~SdrPolyEditView() 66 { 67 } 68 69 void SdrPolyEditView::ImpCheckPolyPossibilities() 70 { 71 ImpResetPolyPossibilityFlags(); 72 const sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); 73 74 if(nMarkAnz && !ImpIsFrameHandles()) 75 { 76 bool b1stSmooth(true); 77 bool b1stSegm(true); 78 bool bCurve(false); 79 bool bSmoothFuz(false); 80 bool bSegmFuz(false); 81 basegfx::B2VectorContinuity eSmooth = basegfx::CONTINUITY_NONE; 82 83 for(sal_uIntPtr nMarkNum(0L); nMarkNum < nMarkAnz; nMarkNum++) 84 { 85 SdrMark* pM = GetSdrMarkByIndex(nMarkNum); 86 CheckPolyPossibilitiesHelper( pM, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth ); 87 } 88 } 89 } 90 91 void SdrPolyEditView::CheckPolyPossibilitiesHelper( SdrMark* pM, bool& b1stSmooth, bool& b1stSegm, bool& bCurve, bool& bSmoothFuz, bool& bSegmFuz, basegfx::B2VectorContinuity& eSmooth ) 92 { 93 SdrObject* pObj = pM->GetMarkedSdrObj(); 94 SdrUShortCont* pPts = pM->GetMarkedPoints(); 95 SdrPathObj* pPath = PTR_CAST(SdrPathObj,pObj); 96 97 if(pPath && pPts) 98 { 99 const sal_uInt32 nMarkedPntAnz(pPts->GetCount()); 100 101 if(nMarkedPntAnz) 102 { 103 bool bClosed(pPath->IsClosed()); 104 bSetMarkedPointsSmoothPossible = true; 105 106 if(bClosed) 107 { 108 bSetMarkedSegmentsKindPossible = true; 109 } 110 111 for(sal_uInt32 nMarkedPntNum(0L); nMarkedPntNum < nMarkedPntAnz; nMarkedPntNum++) 112 { 113 sal_uInt32 nNum(pPts->GetObject(nMarkedPntNum)); 114 sal_uInt32 nPolyNum, nPntNum; 115 116 if(PolyPolygonEditor::GetRelativePolyPoint(pPath->GetPathPoly(), nNum, nPolyNum, nPntNum)) 117 { 118 const basegfx::B2DPolygon aLocalPolygon(pPath->GetPathPoly().getB2DPolygon(nPolyNum)); 119 bool bCanSegment(bClosed || nPntNum < aLocalPolygon.count() - 1L); 120 121 if(!bSetMarkedSegmentsKindPossible && bCanSegment) 122 { 123 bSetMarkedSegmentsKindPossible = true; 124 } 125 126 if(!bSmoothFuz) 127 { 128 if (b1stSmooth) 129 { 130 b1stSmooth = false; 131 eSmooth = basegfx::tools::getContinuityInPoint(aLocalPolygon, nPntNum); 132 } 133 else 134 { 135 bSmoothFuz = (eSmooth != basegfx::tools::getContinuityInPoint(aLocalPolygon, nPntNum)); 136 } 137 } 138 139 if(!bSegmFuz) 140 { 141 if(bCanSegment) 142 { 143 bool bCrv(aLocalPolygon.isNextControlPointUsed(nPntNum)); 144 145 if(b1stSegm) 146 { 147 b1stSegm = false; 148 bCurve = bCrv; 149 } 150 else 151 { 152 bSegmFuz = (bCrv != bCurve); 153 } 154 } 155 } 156 } 157 } 158 159 if(!b1stSmooth && !bSmoothFuz) 160 { 161 if(basegfx::CONTINUITY_NONE == eSmooth) 162 { 163 eMarkedPointsSmooth = SDRPATHSMOOTH_ANGULAR; 164 } 165 166 if(basegfx::CONTINUITY_C1 == eSmooth) 167 { 168 eMarkedPointsSmooth = SDRPATHSMOOTH_ASYMMETRIC; 169 } 170 171 if(basegfx::CONTINUITY_C2 == eSmooth) 172 { 173 eMarkedPointsSmooth = SDRPATHSMOOTH_SYMMETRIC; 174 } 175 } 176 177 if(!b1stSegm && !bSegmFuz) 178 { 179 eMarkedSegmentsKind = (bCurve) ? SDRPATHSEGMENT_CURVE : SDRPATHSEGMENT_LINE; 180 } 181 } 182 } 183 } 184 185 void SdrPolyEditView::SetMarkedPointsSmooth(SdrPathSmoothKind eKind) 186 { 187 basegfx::B2VectorContinuity eFlags; 188 189 if(SDRPATHSMOOTH_ANGULAR == eKind) 190 { 191 eFlags = basegfx::CONTINUITY_NONE; 192 } 193 else if(SDRPATHSMOOTH_ASYMMETRIC == eKind) 194 { 195 eFlags = basegfx::CONTINUITY_C1; 196 } 197 else if(SDRPATHSMOOTH_SYMMETRIC == eKind) 198 { 199 eFlags = basegfx::CONTINUITY_C2; 200 } 201 else 202 { 203 return; 204 } 205 206 if(HasMarkedPoints()) 207 { 208 SortMarkedObjects(); 209 210 const bool bUndo = IsUndoEnabled(); 211 if( bUndo ) 212 BegUndo(ImpGetResStr(STR_EditSetPointsSmooth), GetDescriptionOfMarkedPoints()); 213 sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); 214 215 for(sal_uIntPtr nMarkNum(nMarkAnz); nMarkNum > 0L;) 216 { 217 nMarkNum--; 218 SdrMark* pM = GetSdrMarkByIndex(nMarkNum); 219 SdrUShortCont* pPts = pM->GetMarkedPoints(); 220 SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); 221 222 if(pPts && pPath) 223 { 224 PolyPolygonEditor aEditor( pPath->GetPathPoly(), pPath->IsClosed() ); 225 if(aEditor.SetPointsSmooth( eFlags, pPts->getContainer() ) ) 226 { 227 if( bUndo ) 228 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); 229 pPath->SetPathPoly(aEditor.GetPolyPolygon()); 230 } 231 } 232 } 233 234 if( bUndo ) 235 EndUndo(); 236 } 237 } 238 239 void SdrPolyEditView::SetMarkedSegmentsKind(SdrPathSegmentKind eKind) 240 { 241 if(HasMarkedPoints()) 242 { 243 SortMarkedObjects(); 244 245 const bool bUndo = IsUndoEnabled(); 246 if( bUndo ) 247 BegUndo(ImpGetResStr(STR_EditSetSegmentsKind), GetDescriptionOfMarkedPoints()); 248 sal_uIntPtr nMarkAnz(GetMarkedObjectCount()); 249 250 for(sal_uIntPtr nMarkNum(nMarkAnz); nMarkNum > 0L;) 251 { 252 nMarkNum--; 253 SdrMark* pM = GetSdrMarkByIndex(nMarkNum); 254 SdrUShortCont* pPts = pM->GetMarkedPoints(); 255 SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); 256 257 if(pPts && pPath) 258 { 259 PolyPolygonEditor aEditor( pPath->GetPathPoly(), pPath->IsClosed() ); 260 if(aEditor.SetSegmentsKind( eKind, pPts->getContainer()) ) 261 { 262 if( bUndo ) 263 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath)); 264 pPath->SetPathPoly(aEditor.GetPolyPolygon()); 265 } 266 } 267 } 268 269 if( bUndo ) 270 EndUndo(); 271 } 272 } 273 274 sal_Bool SdrPolyEditView::IsSetMarkedPointsSmoothPossible() const 275 { 276 ForcePossibilities(); 277 return bSetMarkedPointsSmoothPossible; 278 } 279 280 SdrPathSmoothKind SdrPolyEditView::GetMarkedPointsSmooth() const 281 { 282 ForcePossibilities(); 283 return eMarkedPointsSmooth; 284 } 285 286 sal_Bool SdrPolyEditView::IsSetMarkedSegmentsKindPossible() const 287 { 288 ForcePossibilities(); 289 return bSetMarkedSegmentsKindPossible; 290 } 291 292 SdrPathSegmentKind SdrPolyEditView::GetMarkedSegmentsKind() const 293 { 294 ForcePossibilities(); 295 return eMarkedSegmentsKind; 296 } 297 298 sal_Bool SdrPolyEditView::IsDeleteMarkedPointsPossible() const 299 { 300 return HasMarkedPoints(); 301 } 302 303 void SdrPolyEditView::DeleteMarkedPoints() 304 { 305 if (HasMarkedPoints()) 306 { 307 BrkAction(); 308 SortMarkedObjects(); 309 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 310 311 const bool bUndo = IsUndoEnabled(); 312 if( bUndo ) 313 { 314 // Description 315 BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_DELETE); 316 } 317 318 for (sal_uIntPtr nMarkNum=nMarkAnz; nMarkNum>0;) 319 { 320 nMarkNum--; 321 SdrMark* pM=GetSdrMarkByIndex(nMarkNum); 322 SdrUShortCont* pPts=pM->GetMarkedPoints(); 323 SdrPathObj* pPath = dynamic_cast< SdrPathObj* >( pM->GetMarkedSdrObj() ); 324 325 if( pPath && pPts ) 326 { 327 PolyPolygonEditor aEditor( pPath ->GetPathPoly(), pPath->IsClosed() ); 328 if( aEditor.DeletePoints( pPts->getContainer() ) ) 329 { 330 if( aEditor.GetPolyPolygon().count() ) 331 { 332 if( bUndo ) 333 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath )); 334 pPath->SetPathPoly( aEditor.GetPolyPolygon() ); 335 } 336 else 337 { 338 if( bUndo ) 339 AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pPath ) ); 340 pM->GetPageView()->GetObjList()->RemoveObject(pPath->GetOrdNum()); 341 if( !bUndo ) 342 { 343 SdrObject* pObj = pPath; 344 SdrObject::Free(pObj); 345 } 346 } 347 } 348 } 349 } 350 351 if( bUndo ) 352 EndUndo(); 353 UnmarkAllPoints(); 354 MarkListHasChanged(); 355 } 356 } 357 358 void SdrPolyEditView::RipUpAtMarkedPoints() 359 { 360 if(HasMarkedPoints()) 361 { 362 SortMarkedObjects(); 363 sal_uInt32 nMarkAnz(GetMarkedObjectCount()); 364 365 const bool bUndo = IsUndoEnabled(); 366 if( bUndo ) 367 BegUndo(ImpGetResStr(STR_EditRipUp), GetDescriptionOfMarkedPoints()); 368 369 for(sal_uInt32 nMarkNum(nMarkAnz); nMarkNum > 0L;) 370 { 371 nMarkNum--; 372 SdrMark* pM = GetSdrMarkByIndex(nMarkNum); 373 SdrUShortCont* pPts = pM->GetMarkedPoints(); 374 SdrPathObj* pObj = PTR_CAST(SdrPathObj, pM->GetMarkedSdrObj()); 375 376 if(pPts && pObj) 377 { 378 pPts->ForceSort(); 379 if( bUndo ) 380 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); 381 sal_Bool bKorregFlag(sal_False); 382 sal_Bool bInsAny(sal_False); 383 sal_uInt32 nMarkPtsAnz(pPts->GetCount()); 384 sal_uInt32 nMax(pObj->GetHdlCount()); 385 386 for(sal_uInt32 i(nMarkPtsAnz); i > 0L;) 387 { 388 i--; 389 sal_uInt32 nNewPt0Idx(0L); 390 SdrObject* pNeuObj = pObj->RipPoint(pPts->GetObject(i), nNewPt0Idx); 391 392 if(pNeuObj) 393 { 394 bInsAny = sal_True; 395 SdrInsertReason aReason(SDRREASON_VIEWCALL, pObj); 396 pM->GetPageView()->GetObjList()->InsertObject(pNeuObj, pObj->GetOrdNum() + 1, &aReason); 397 if( bUndo ) 398 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pNeuObj)); 399 MarkObj(pNeuObj, pM->GetPageView(), sal_False, sal_True); 400 } 401 402 if(nNewPt0Idx) 403 { 404 // Korrektur notwendig? 405 DBG_ASSERT(bKorregFlag==sal_False,"Mehrfache Indexkorrektur bei SdrPolyEditView::RipUp()"); 406 if(!bKorregFlag) 407 { 408 bKorregFlag = sal_True; 409 410 for(sal_uInt32 nBla(0L); nBla < nMarkPtsAnz; nBla++) 411 { 412 sal_uInt32 nPntNum(pPts->GetObject(nBla)); 413 nPntNum += nNewPt0Idx; 414 415 if(nPntNum >= nMax) 416 { 417 nPntNum -= nMax; 418 } 419 420 pPts->Replace((sal_uInt16)nPntNum, nBla); 421 } 422 423 i = nMarkPtsAnz; // ... und nochmal von vorn 424 } 425 } 426 } 427 } 428 } 429 430 UnmarkAllPoints(); 431 if( bUndo ) 432 EndUndo(); 433 MarkListHasChanged(); 434 } 435 } 436 437 bool SdrPolyEditView::IsRipUpAtMarkedPointsPossible() const 438 { 439 bool bRetval(false); 440 const sal_uInt32 nMarkCount(GetMarkedObjectCount()); 441 442 for(sal_uInt32 a(0); a < nMarkCount; a++) 443 { 444 const SdrMark* pMark = GetSdrMarkByIndex(a); 445 const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); 446 447 if(pMarkedPathObject) 448 { 449 const SdrUShortCont* pSelectedPoints = pMark->GetMarkedPoints(); 450 451 if(pSelectedPoints && pSelectedPoints->GetCount()) 452 { 453 const basegfx::B2DPolyPolygon& rPathPolyPolygon = pMarkedPathObject->GetPathPoly(); 454 455 if(1 == rPathPolyPolygon.count()) 456 { 457 // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions 458 // are different and methods need to be changed thoroughly with interaction rework 459 const Polygon aPathPolygon(rPathPolyPolygon.getB2DPolygon(0)); 460 const sal_uInt16 nPointCount(aPathPolygon.GetSize()); 461 462 if(nPointCount >= 3) 463 { 464 bRetval = pMarkedPathObject->IsClosedObj(); // #i76617# aPathPolygon.isClosed(); 465 466 for(sal_uInt32 b(0); !bRetval && b < pSelectedPoints->GetCount(); b++) 467 { 468 const sal_uInt16 nMarkedPointNum(pSelectedPoints->GetObject(b)); 469 470 bRetval = (nMarkedPointNum > 0 && nMarkedPointNum < nPointCount - 1); 471 } 472 } 473 } 474 } 475 } 476 } 477 478 return bRetval; 479 } 480 481 bool SdrPolyEditView::IsOpenCloseMarkedObjectsPossible() const 482 { 483 bool bRetval(false); 484 const sal_uInt32 nMarkCount(GetMarkedObjectCount()); 485 486 for(sal_uInt32 a(0); 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 // #i76617# Do not yet use basegfx::B2DPolygon since curve definitions 494 // are different and methods need to be changed thoroughly with interaction rework 495 const PolyPolygon aPathPolyPolygon(pMarkedPathObject->GetPathPoly()); 496 const sal_uInt16 nPolygonCount(aPathPolyPolygon.Count()); 497 498 for(sal_uInt16 b(0); !bRetval && b < nPolygonCount; b++) 499 { 500 const Polygon& rPathPolygon = aPathPolyPolygon[b]; 501 const sal_uInt16 nPointCount(rPathPolygon.GetSize()); 502 503 bRetval = (nPointCount >= 3); 504 } 505 } 506 } 507 508 return bRetval; 509 } 510 511 SdrObjClosedKind SdrPolyEditView::GetMarkedObjectsClosedState() const 512 { 513 bool bOpen(false); 514 bool bClosed(false); 515 const sal_uInt32 nMarkCount(GetMarkedObjectCount()); 516 517 for(sal_uInt32 a(0); !(bOpen && bClosed) && a < nMarkCount; a++) 518 { 519 const SdrMark* pMark = GetSdrMarkByIndex(a); 520 const SdrPathObj* pMarkedPathObject = dynamic_cast< const SdrPathObj* >(pMark->GetMarkedSdrObj()); 521 522 if(pMarkedPathObject) 523 { 524 if(pMarkedPathObject->IsClosedObj()) 525 { 526 bClosed = true; 527 } 528 else 529 { 530 bOpen = true; 531 } 532 } 533 } 534 535 if(bOpen && bClosed) 536 { 537 return SDROBJCLOSED_DONTCARE; 538 } 539 else if(bOpen) 540 { 541 return SDROBJCLOSED_OPEN; 542 } 543 else 544 { 545 return SDROBJCLOSED_CLOSED; 546 } 547 } 548 549 void SdrPolyEditView::ShutMarkedObjects() 550 { 551 CloseMarkedObjects(); 552 } 553 554 void SdrPolyEditView::CloseMarkedObjects(sal_Bool bToggle, sal_Bool bOpen) // , long nOpenDistance) 555 { 556 if (AreObjectsMarked()) 557 { 558 const bool bUndo = IsUndoEnabled(); 559 if( bUndo ) 560 BegUndo(ImpGetResStr(STR_EditShut),GetDescriptionOfMarkedPoints()); 561 562 bool bChg=false; 563 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 564 for (sal_uIntPtr nm=0; nm<nMarkAnz; nm++) 565 { 566 SdrMark* pM=GetSdrMarkByIndex(nm); 567 SdrObject* pO=pM->GetMarkedSdrObj(); 568 sal_Bool bClosed=pO->IsClosedObj(); 569 if (pO->IsPolyObj() && (bClosed==bOpen) || bToggle) 570 { 571 if( bUndo ) 572 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pO)); 573 574 SdrPathObj* pPathObj = dynamic_cast< SdrPathObj* >( pO ); 575 if(pPathObj) 576 pPathObj->ToggleClosed(); 577 bChg=true; 578 } 579 } 580 581 if( bUndo ) 582 EndUndo(); 583 584 if (bChg) 585 { 586 UnmarkAllPoints(); 587 MarkListHasChanged(); 588 } 589 } 590 } 591 592 //////////////////////////////////////////////////////////////////////////////////////////////////// 593 594 void SdrPolyEditView::ImpCopyMarkedPoints() 595 { 596 } 597 598 //////////////////////////////////////////////////////////////////////////////////////////////////// 599 600 void SdrPolyEditView::ImpTransformMarkedPoints(PPolyTrFunc pTrFunc, const void* p1, const void* p2, const void* p3, const void* p4, const void* p5) 601 { 602 const bool bUndo = IsUndoEnabled(); 603 604 sal_uIntPtr nMarkAnz=GetMarkedObjectCount(); 605 for (sal_uIntPtr nm=0; nm<nMarkAnz; nm++) 606 { 607 SdrMark* pM=GetSdrMarkByIndex(nm); 608 SdrObject* pObj=pM->GetMarkedSdrObj(); 609 const SdrUShortCont* pPts=pM->GetMarkedPoints(); 610 sal_uIntPtr nPtAnz=pPts==NULL ? 0 : pPts->GetCount(); 611 SdrPathObj* pPath=PTR_CAST(SdrPathObj,pObj); 612 if (nPtAnz!=0 && pPath!=NULL) 613 { 614 if( bUndo ) 615 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj)); 616 617 basegfx::B2DPolyPolygon aXPP(pPath->GetPathPoly()); 618 619 for(sal_uInt32 nPtNum(0L); nPtNum < nPtAnz; nPtNum++) 620 { 621 sal_uInt32 nPt(pPts->GetObject(nPtNum)); 622 sal_uInt32 nPolyNum, nPointNum; 623 624 if(PolyPolygonEditor::GetRelativePolyPoint(aXPP, nPt, nPolyNum, nPointNum)) 625 { 626 //#i83671# used nLocalPointNum (which was the polygon point count) 627 // instead of the point index (nPointNum). This of course leaded 628 // to a wrong point access to the B2DPolygon. 629 basegfx::B2DPolygon aNewXP(aXPP.getB2DPolygon(nPolyNum)); 630 Point aPos, aC1, aC2; 631 bool bC1(false); 632 bool bC2(false); 633 634 const basegfx::B2DPoint aB2DPos(aNewXP.getB2DPoint(nPointNum)); 635 aPos = Point(FRound(aB2DPos.getX()), FRound(aB2DPos.getY())); 636 637 if(aNewXP.isPrevControlPointUsed(nPointNum)) 638 { 639 const basegfx::B2DPoint aB2DC1(aNewXP.getPrevControlPoint(nPointNum)); 640 aC1 = Point(FRound(aB2DC1.getX()), FRound(aB2DC1.getY())); 641 bC1 = true; 642 } 643 644 if(aNewXP.isNextControlPointUsed(nPointNum)) 645 { 646 const basegfx::B2DPoint aB2DC2(aNewXP.getNextControlPoint(nPointNum)); 647 aC2 = Point(FRound(aB2DC2.getX()), FRound(aB2DC2.getY())); 648 bC2 = true; 649 } 650 651 (*pTrFunc)(aPos,&aC1,&aC2,p1,p2,p3,p4,p5); 652 aNewXP.setB2DPoint(nPointNum, basegfx::B2DPoint(aPos.X(), aPos.Y())); 653 654 if (bC1) 655 { 656 aNewXP.setPrevControlPoint(nPointNum, basegfx::B2DPoint(aC1.X(), aC1.Y())); 657 } 658 659 if (bC2) 660 { 661 aNewXP.setNextControlPoint(nPointNum, basegfx::B2DPoint(aC2.X(), aC2.Y())); 662 } 663 664 aXPP.setB2DPolygon(nPolyNum, aNewXP); 665 } 666 } 667 668 pPath->SetPathPoly(aXPP); 669 } 670 } 671 } 672 673 //////////////////////////////////////////////////////////////////////////////////////////////////// 674 675 static void ImpMove(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* /*p3*/, const void* /*p4*/, const void* /*p5*/) 676 { 677 MovePoint(rPt,*(const Size*)p1); 678 if (pC1!=NULL) MovePoint(*pC1,*(const Size*)p1); 679 if (pC2!=NULL) MovePoint(*pC2,*(const Size*)p1); 680 } 681 682 void SdrPolyEditView::MoveMarkedPoints(const Size& rSiz, bool bCopy) 683 { 684 bCopy=sal_False; // noch nicht implementiert 685 ForceUndirtyMrkPnt(); 686 XubString aStr(ImpGetResStr(STR_EditMove)); 687 if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); 688 BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_MOVE); 689 if (bCopy) ImpCopyMarkedPoints(); 690 ImpTransformMarkedPoints(ImpMove,&rSiz); 691 EndUndo(); 692 AdjustMarkHdl(); 693 } 694 695 //////////////////////////////////////////////////////////////////////////////////////////////////// 696 697 static void ImpResize(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* p2, const void* p3, const void* /*p4*/, const void* /*p5*/) 698 { 699 ResizePoint(rPt,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); 700 if (pC1!=NULL) ResizePoint(*pC1,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); 701 if (pC2!=NULL) ResizePoint(*pC2,*(const Point*)p1,*(const Fraction*)p2,*(const Fraction*)p3); 702 } 703 704 void SdrPolyEditView::ResizeMarkedPoints(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bCopy) 705 { 706 bCopy=sal_False; // noch nicht implementiert 707 ForceUndirtyMrkPnt(); 708 XubString aStr(ImpGetResStr(STR_EditResize)); 709 if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); 710 BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_RESIZE); 711 if (bCopy) ImpCopyMarkedPoints(); 712 ImpTransformMarkedPoints(ImpResize,&rRef,&xFact,&yFact); 713 EndUndo(); 714 AdjustMarkHdl(); 715 } 716 717 //////////////////////////////////////////////////////////////////////////////////////////////////// 718 719 static void ImpRotate(Point& rPt, Point* pC1, Point* pC2, const void* p1, const void* /*p2*/, const void* p3, const void* p4, const void* /*p5*/) 720 { 721 RotatePoint(rPt,*(const Point*)p1,*(const double*)p3,*(const double*)p4); 722 if (pC1!=NULL) RotatePoint(*pC1,*(const Point*)p1,*(const double*)p3,*(const double*)p4); 723 if (pC2!=NULL) RotatePoint(*pC2,*(const Point*)p1,*(const double*)p3,*(const double*)p4); 724 } 725 726 void SdrPolyEditView::RotateMarkedPoints(const Point& rRef, long nWink, bool bCopy) 727 { 728 bCopy=sal_False; // noch nicht implementiert 729 ForceUndirtyMrkPnt(); 730 XubString aStr(ImpGetResStr(STR_EditResize)); 731 if (bCopy) aStr+=ImpGetResStr(STR_EditWithCopy); 732 BegUndo(aStr,GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_ROTATE); 733 if (bCopy) ImpCopyMarkedPoints(); 734 double nSin=sin(nWink*nPi180); 735 double nCos=cos(nWink*nPi180); 736 ImpTransformMarkedPoints(ImpRotate,&rRef,&nWink,&nSin,&nCos); 737 EndUndo(); 738 AdjustMarkHdl(); 739 } 740 741 // eof 742