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
ImpResetPolyPossibilityFlags()46 void SdrPolyEditView::ImpResetPolyPossibilityFlags()
47 {
48 eMarkedPointsSmooth=SDRPATHSMOOTH_DONTCARE;
49 eMarkedSegmentsKind=SDRPATHSEGMENT_DONTCARE;
50 bSetMarkedPointsSmoothPossible=sal_False;
51 bSetMarkedSegmentsKindPossible=sal_False;
52 }
53
ImpClearVars()54 void SdrPolyEditView::ImpClearVars()
55 {
56 ImpResetPolyPossibilityFlags();
57 }
58
SdrPolyEditView(SdrModel * pModel1,OutputDevice * pOut)59 SdrPolyEditView::SdrPolyEditView(SdrModel* pModel1, OutputDevice* pOut):
60 SdrEditView(pModel1,pOut)
61 {
62 ImpClearVars();
63 }
64
~SdrPolyEditView()65 SdrPolyEditView::~SdrPolyEditView()
66 {
67 }
68
ImpCheckPolyPossibilities()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
CheckPolyPossibilitiesHelper(SdrMark * pM,bool & b1stSmooth,bool & b1stSegm,bool & bCurve,bool & bSmoothFuz,bool & bSegmFuz,basegfx::B2VectorContinuity & eSmooth)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
SetMarkedPointsSmooth(SdrPathSmoothKind eKind)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
SetMarkedSegmentsKind(SdrPathSegmentKind eKind)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
IsSetMarkedPointsSmoothPossible() const274 sal_Bool SdrPolyEditView::IsSetMarkedPointsSmoothPossible() const
275 {
276 ForcePossibilities();
277 return bSetMarkedPointsSmoothPossible;
278 }
279
GetMarkedPointsSmooth() const280 SdrPathSmoothKind SdrPolyEditView::GetMarkedPointsSmooth() const
281 {
282 ForcePossibilities();
283 return eMarkedPointsSmooth;
284 }
285
IsSetMarkedSegmentsKindPossible() const286 sal_Bool SdrPolyEditView::IsSetMarkedSegmentsKindPossible() const
287 {
288 ForcePossibilities();
289 return bSetMarkedSegmentsKindPossible;
290 }
291
GetMarkedSegmentsKind() const292 SdrPathSegmentKind SdrPolyEditView::GetMarkedSegmentsKind() const
293 {
294 ForcePossibilities();
295 return eMarkedSegmentsKind;
296 }
297
IsDeleteMarkedPointsPossible() const298 sal_Bool SdrPolyEditView::IsDeleteMarkedPointsPossible() const
299 {
300 return HasMarkedPoints();
301 }
302
DeleteMarkedPoints()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
RipUpAtMarkedPoints()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
IsRipUpAtMarkedPointsPossible() const437 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
IsOpenCloseMarkedObjectsPossible() const481 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
GetMarkedObjectsClosedState() const511 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
ShutMarkedObjects()549 void SdrPolyEditView::ShutMarkedObjects()
550 {
551 CloseMarkedObjects();
552 }
553
CloseMarkedObjects(sal_Bool bToggle,sal_Bool bOpen)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
ImpCopyMarkedPoints()594 void SdrPolyEditView::ImpCopyMarkedPoints()
595 {
596 }
597
598 ////////////////////////////////////////////////////////////////////////////////////////////////////
599
ImpTransformMarkedPoints(PPolyTrFunc pTrFunc,const void * p1,const void * p2,const void * p3,const void * p4,const void * p5)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
ImpMove(Point & rPt,Point * pC1,Point * pC2,const void * p1,const void *,const void *,const void *,const void *)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
MoveMarkedPoints(const Size & rSiz,bool bCopy)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
ImpResize(Point & rPt,Point * pC1,Point * pC2,const void * p1,const void * p2,const void * p3,const void *,const void *)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
ResizeMarkedPoints(const Point & rRef,const Fraction & xFact,const Fraction & yFact,bool bCopy)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
ImpRotate(Point & rPt,Point * pC1,Point * pC2,const void * p1,const void *,const void * p3,const void * p4,const void *)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
RotateMarkedPoints(const Point & rRef,long nWink,bool bCopy)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