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