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_sd.hxx"
26 
27 
28 #include <com/sun/star/util/XChangesNotifier.hpp>
29 
30 #include <basegfx/matrix/b2dhommatrix.hxx>
31 #include <basegfx/polygon/b2dpolygontools.hxx>
32 #include <basegfx/matrix/b2dhommatrixtools.hxx>
33 
34 #include <sfx2/viewfrm.hxx>
35 #include <sfx2/dispatch.hxx>
36 
37 #include <svx/sdr/overlay/overlaymanager.hxx>
38 #include <svx/sdr/overlay/overlaypolypolygon.hxx>
39 #include <svx/svdpagv.hxx>
40 #include <svx/sdrpagewindow.hxx>
41 #include <svx/sdrpaintwindow.hxx>
42 #include <svx/svdopath.hxx>
43 #include <svx/xlndsit.hxx>
44 #include <svx/xlnclit.hxx>
45 #include <svx/xlnstit.hxx>
46 #include <svx/xlnedit.hxx>
47 #include <svx/xlnstwit.hxx>
48 #include <svx/xlnedwit.hxx>
49 #include <svx/xlnstcit.hxx>
50 #include <svx/xlnedcit.hxx>
51 #include <svx/xlntrit.hxx>
52 #include <svx/svxids.hrc>
53 #include <svx/polypolygoneditor.hxx>
54 #include <svx/svddrgmt.hxx>
55 
56 #include "CustomAnimationPane.hxx"
57 #include "View.hxx"
58 #include "motionpathtag.hxx"
59 #include "sdpage.hxx"
60 #include "ViewShell.hxx"
61 #include "app.hrc"
62 #include "Window.hxx"
63 
64 #include <svx/sdr/contact/viewcontact.hxx>
65 #include <svx/sdr/overlay/overlayprimitive2dsequenceobject.hxx>
66 
67 using ::rtl::OUString;
68 using ::sdr::PolyPolygonEditor;
69 using namespace ::com::sun::star::uno;
70 using namespace ::com::sun::star::lang;
71 using namespace ::com::sun::star::util;
72 using namespace ::com::sun::star::drawing;
73 
74 namespace sd
75 {
76 
77 const sal_uInt32 SMART_TAG_HDL_NUM = SAL_MAX_UINT32;
78 static const int DRGPIX     = 2;                               // Drag MinMove in Pixel
79 
80 // --------------------------------------------------------------------
81 
82 class PathDragMove : public SdrDragMove
83 {
84 private:
85 	basegfx::B2DPolyPolygon			maPathPolyPolygon;
86 
87 protected:
88     virtual void createSdrDragEntries();
89 
90 public:
PathDragMove(SdrDragView & rNewView,const rtl::Reference<MotionPathTag> & xTag,const basegfx::B2DPolyPolygon & rPathPolyPolygon)91 	PathDragMove(SdrDragView& rNewView,
92 		const rtl::Reference <MotionPathTag >& xTag,
93 		const basegfx::B2DPolyPolygon& rPathPolyPolygon)
94 	:	SdrDragMove(rNewView),
95 		maPathPolyPolygon(rPathPolyPolygon),
96 		mxTag( xTag )
97 	{}
98 
PathDragMove(SdrDragView & rNewView,const rtl::Reference<MotionPathTag> & xTag)99 	PathDragMove(SdrDragView& rNewView,
100 		const rtl::Reference <MotionPathTag >& xTag)
101 	:	SdrDragMove(rNewView),
102 		maPathPolyPolygon(),
103 		mxTag( xTag )
104 	{}
105 
106 	virtual bool BeginSdrDrag();
107 	virtual bool EndSdrDrag(bool bCopy);
108 
109 	rtl::Reference <MotionPathTag > mxTag;
110 };
111 
createSdrDragEntries()112 void PathDragMove::createSdrDragEntries()
113 {
114 	// call parent
115 	SdrDragMove::createSdrDragEntries();
116 
117 	if(maPathPolyPolygon.count())
118 	{
119 	    addSdrDragEntry(new SdrDragEntryPolyPolygon(maPathPolyPolygon));
120 	}
121 }
122 
BeginSdrDrag()123 bool PathDragMove::BeginSdrDrag()
124 {
125 	if( mxTag.is() )
126 	{
127 		SdrPathObj* pPathObj = mxTag->getPathObj();
128 		if( pPathObj )
129 		{
130 			DragStat().SetActionRect(pPathObj->GetCurrentBoundRect());
131 		}
132 	}
133 	Show();
134 	return sal_True;
135 }
136 
EndSdrDrag(bool)137 bool PathDragMove::EndSdrDrag(bool /*bCopy*/)
138 {
139 	Hide();
140 	if( mxTag.is() )
141 		mxTag->MovePath( DragStat().GetDX(), DragStat().GetDY() );
142 	return sal_True;
143 }
144 // --------------------------------------------------------------------
145 
146 class PathDragResize : public SdrDragResize
147 {
148 private:
149 	basegfx::B2DPolyPolygon			maPathPolyPolygon;
150 
151 protected:
152     virtual void createSdrDragEntries();
153 
154 public:
PathDragResize(SdrDragView & rNewView,const rtl::Reference<MotionPathTag> & xTag,const basegfx::B2DPolyPolygon & rPathPolyPolygon)155 	PathDragResize(SdrDragView& rNewView,
156 		const rtl::Reference <MotionPathTag >& xTag,
157 		const basegfx::B2DPolyPolygon& rPathPolyPolygon)
158 	:	SdrDragResize(rNewView),
159 		maPathPolyPolygon(rPathPolyPolygon),
160 		mxTag( xTag )
161 	{}
162 
PathDragResize(SdrDragView & rNewView,const rtl::Reference<MotionPathTag> & xTag)163 	PathDragResize(SdrDragView& rNewView,
164 		const rtl::Reference <MotionPathTag >& xTag)
165 	:	SdrDragResize(rNewView),
166 		maPathPolyPolygon(),
167 		mxTag( xTag )
168 	{}
169 
170 	virtual bool EndSdrDrag(bool bCopy);
171 	rtl::Reference <MotionPathTag > mxTag;
172 };
173 
createSdrDragEntries()174 void PathDragResize::createSdrDragEntries()
175 {
176 	// call parent
177 	SdrDragResize::createSdrDragEntries();
178 
179 	if(maPathPolyPolygon.count())
180 	{
181 	    addSdrDragEntry(new SdrDragEntryPolyPolygon(maPathPolyPolygon));
182 	}
183 }
184 
EndSdrDrag(bool)185 bool PathDragResize::EndSdrDrag(bool /*bCopy*/)
186 {
187 	Hide();
188 	if( mxTag.is() )
189 	{
190 		SdrPathObj* pPathObj = mxTag->getPathObj();
191 		if( pPathObj )
192 		{
193 			const Point aRef( DragStat().Ref1() );
194             basegfx::B2DHomMatrix aTrans(basegfx::tools::createTranslateB2DHomMatrix(-aRef.X(), -aRef.Y()));
195 			aTrans.scale(double(aXFact), double(aYFact));
196 			aTrans.translate(aRef.X(), aRef.Y());
197 			basegfx::B2DPolyPolygon aDragPoly(pPathObj->GetPathPoly());
198 			aDragPoly.transform(aTrans);
199 			pPathObj->SetPathPoly( aDragPoly );
200 		}
201 	}
202 	return sal_True;
203 }
204 
205 // --------------------------------------------------------------------
206 
207 class PathDragObjOwn : public SdrDragObjOwn
208 {
209 private:
210 	basegfx::B2DPolyPolygon			maPathPolyPolygon;
211 
212 protected:
213     virtual void createSdrDragEntries();
214 
215 public:
PathDragObjOwn(SdrDragView & rNewView,const basegfx::B2DPolyPolygon & rPathPolyPolygon)216 	PathDragObjOwn(SdrDragView& rNewView,
217 		const basegfx::B2DPolyPolygon& rPathPolyPolygon)
218 	:	SdrDragObjOwn(rNewView),
219 		maPathPolyPolygon(rPathPolyPolygon)
220 	{}
221 
PathDragObjOwn(SdrDragView & rNewView)222 	PathDragObjOwn(SdrDragView& rNewView)
223 	:	SdrDragObjOwn(rNewView),
224 		maPathPolyPolygon()
225 	{}
226 
227 	virtual bool EndSdrDrag(bool bCopy);
228 };
229 
createSdrDragEntries()230 void PathDragObjOwn::createSdrDragEntries()
231 {
232 	// call parent
233 	SdrDragObjOwn::createSdrDragEntries();
234 
235 	if(maPathPolyPolygon.count())
236 	{
237 	    addSdrDragEntry(new SdrDragEntryPolyPolygon(maPathPolyPolygon));
238 	}
239 }
240 
EndSdrDrag(bool)241 bool PathDragObjOwn::EndSdrDrag(bool /*bCopy*/)
242 {
243 	Hide();
244 
245     SdrObject* pObj = GetDragObj();
246 
247     if(pObj)
248     {
249 		return pObj->applySpecialDrag(DragStat());
250     }
251 	else
252     {
253 		return false;
254     }
255 }
256 
257 // --------------------------------------------------------------------
258 
259 class SdPathHdl : public SmartHdl
260 {
261 public:
262 	SdPathHdl( const SmartTagReference& xTag, SdrPathObj* mpPathObj );
263 	virtual ~SdPathHdl();
264 	virtual void CreateB2dIAObject();
265 	virtual sal_Bool IsFocusHdl() const;
266 	virtual Pointer GetSdrDragPointer() const;
267 	virtual bool isMarkable() const;
268 
269 private:
270 	SdrPathObj* mpPathObj;
271 	rtl::Reference< MotionPathTag > mxTag;
272 };
273 
274 // --------------------------------------------------------------------
275 
SdPathHdl(const SmartTagReference & xTag,SdrPathObj * pPathObj)276 SdPathHdl::SdPathHdl( const SmartTagReference& xTag, SdrPathObj* pPathObj )
277 : SmartHdl( xTag, pPathObj->GetCurrentBoundRect().TopLeft() )
278 , mpPathObj( pPathObj )
279 , mxTag( dynamic_cast< MotionPathTag* >( xTag.get() ) )
280 {
281 }
282 
283 // --------------------------------------------------------------------
284 
~SdPathHdl()285 SdPathHdl::~SdPathHdl()
286 {
287 }
288 
289 // --------------------------------------------------------------------
290 
CreateB2dIAObject()291 void SdPathHdl::CreateB2dIAObject()
292 {
293 	// first throw away old one
294 	GetRidOfIAObject();
295 
296 	if(pHdlList)
297 	{
298 		SdrMarkView* pView = pHdlList->GetView();
299 
300 		if(pView && !pView->areMarkHandlesHidden())
301 		{
302 			SdrPageView* pPageView = pView->GetSdrPageView();
303 
304 			if(pPageView)
305 			{
306 				for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
307 				{
308 					const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
309 
310 					if(rPageWindow.GetPaintWindow().OutputToWindow())
311 					{
312 						if(rPageWindow.GetOverlayManager() && mpPathObj)
313 						{
314 							const sdr::contact::ViewContact& rVC = mpPathObj->GetViewContact();
315 							const drawinglayer::primitive2d::Primitive2DSequence aSequence = rVC.getViewIndependentPrimitive2DSequence();
316 							sdr::overlay::OverlayObject* pNew = new sdr::overlay::OverlayPrimitive2DSequenceObject(aSequence);
317 
318 							rPageWindow.GetOverlayManager()->add(*pNew);
319 							maOverlayGroup.append(*pNew);
320 						}
321 					}
322 				}
323 			}
324 		}
325 	}
326 }
327 
328 // --------------------------------------------------------------------
329 
IsFocusHdl() const330 sal_Bool SdPathHdl::IsFocusHdl() const
331 {
332 	return sal_False;
333 }
334 
335 // --------------------------------------------------------------------
336 
isMarkable() const337 bool SdPathHdl::isMarkable() const
338 {
339 	return false;
340 }
341 
342 // --------------------------------------------------------------------
343 
GetSdrDragPointer() const344 Pointer SdPathHdl::GetSdrDragPointer() const
345 {
346 	PointerStyle eStyle = POINTER_NOTALLOWED;
347 	if( mxTag.is() )
348 	{
349 		if( mxTag->isSelected() )
350 		{
351 			if( !mxTag->getView().IsFrameDragSingles() && mxTag->getView().IsInsObjPointMode() )
352 				eStyle = POINTER_CROSS;
353 			else
354 				eStyle = POINTER_MOVE;
355 		}
356 		else
357 		{
358 			eStyle = POINTER_ARROW;
359 
360 		}
361 	}
362 	return Pointer( eStyle );
363 }
364 
365 // ====================================================================
366 
MotionPathTag(CustomAnimationPane & rPane,::sd::View & rView,const CustomAnimationEffectPtr & pEffect)367 MotionPathTag::MotionPathTag( CustomAnimationPane& rPane, ::sd::View& rView, const CustomAnimationEffectPtr& pEffect )
368 : SmartTag( rView )
369 , mrPane( rPane )
370 , mpEffect( pEffect )
371 , mxOrigin( pEffect->getTargetShape() )
372 , msLastPath( pEffect->getPath() )
373 , mbInUpdatePath( false )
374 {
375 	mpPathObj = mpEffect->createSdrPathObjFromPath();
376 	mxPolyPoly = mpPathObj->GetPathPoly();
377 	maOriginPos = mxOrigin->getPosition();
378 
379 	SdrPage* pPage = mrView.GetSdrPageView()->GetPage();
380 	if( pPage )
381 	{
382 		mpPathObj->SetPage( pPage );
383 		mpPathObj->SetObjList( pPage );
384 	}
385 
386 	XDash aDash( XDASH_RECT, 1, 80, 1, 80, 80);
387 	String aEmpty( RTL_CONSTASCII_USTRINGPARAM("?") );
388 	mpPathObj->SetMergedItem( XLineDashItem( aEmpty, aDash ) );
389 	mpPathObj->SetMergedItem( XLineStyleItem( XLINE_DASH ) );
390 	mpPathObj->SetMergedItem( XLineColorItem(aEmpty, ::Color(COL_GRAY)) );
391 	mpPathObj->SetMergedItem( XFillStyleItem( XFILL_NONE ) );
392 
393 	::basegfx::B2DPolygon aStartArrow;
394 	aStartArrow.append(::basegfx::B2DPoint(20.0, 0.0));
395 	aStartArrow.append(::basegfx::B2DPoint(0.0,  0.0));
396 	aStartArrow.append(::basegfx::B2DPoint(10.0, 30.0));
397 	aStartArrow.setClosed(true);
398 	mpPathObj->SetMergedItem(XLineStartItem(aEmpty,::basegfx::B2DPolyPolygon(aStartArrow)));
399 	mpPathObj->SetMergedItem(XLineStartWidthItem(400));
400 	mpPathObj->SetMergedItem(XLineStartCenterItem(sal_True));
401 
402 	updatePathAttributes();
403 
404 	mpPathObj->SetMergedItem(XLineTransparenceItem(50));
405 
406 	mpMark = new SdrMark( mpPathObj, mrView.GetSdrPageView() );
407 
408 	mpPathObj->AddListener( *this );
409 
410 	Reference< XChangesNotifier > xNotifier( mpEffect->getNode(), UNO_QUERY );
411 	if( xNotifier.is() )
412 	{
413 		Reference< XChangesListener > xListener( this );
414 		xNotifier->addChangesListener( this );
415 	}
416 }
417 
418 // --------------------------------------------------------------------
419 
~MotionPathTag()420 MotionPathTag::~MotionPathTag()
421 {
422 	DBG_ASSERT( mpPathObj == 0, "sd::MotionPathTag::~MotionPathTag(), dispose me first!" );
423 	Dispose();
424 }
425 
426 // --------------------------------------------------------------------
427 
updatePathAttributes()428 void MotionPathTag::updatePathAttributes()
429 {
430 	String aEmpty( RTL_CONSTASCII_USTRINGPARAM("?") );
431 
432 	::basegfx::B2DPolygon aCandidate;
433 	if( mxPolyPoly.count() )
434 	{
435 		aCandidate = mxPolyPoly.getB2DPolygon(0);
436 		::basegfx::tools::checkClosed( aCandidate );
437 	}
438 
439 	if( !aCandidate.isClosed() )
440 	{
441 		::basegfx::B2DPolygon aEndArrow;
442 		aEndArrow.append(::basegfx::B2DPoint(10.0, 0.0));
443 		aEndArrow.append(::basegfx::B2DPoint(0.0, 30.0));
444 		aEndArrow.append(::basegfx::B2DPoint(20.0, 30.0));
445 		aEndArrow.setClosed(true);
446 		mpPathObj->SetMergedItem(XLineEndItem(aEmpty,::basegfx::B2DPolyPolygon(aEndArrow)));
447 		mpPathObj->SetMergedItem(XLineEndWidthItem(400));
448 		mpPathObj->SetMergedItem(XLineEndCenterItem(sal_True));
449 	}
450 	else
451 	{
452 		mpPathObj->SetMergedItem(XLineEndItem());
453 	}
454 }
455 
456 // --------------------------------------------------------------------
457 
Notify(SfxBroadcaster &,const SfxHint & rHint)458 void MotionPathTag::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
459 {
460 	if( mpPathObj && !mbInUpdatePath && dynamic_cast< const SdrHint* >( &rHint ) && (mpEffect.get() != 0) )
461 	{
462 		if( mxPolyPoly != mpPathObj->GetPathPoly() )
463 		{
464 			mbInUpdatePath = true;
465 			mxPolyPoly = mpPathObj->GetPathPoly();
466 			rtl::Reference< MotionPathTag > xTag( this );
467 			mrPane.updatePathFromMotionPathTag( xTag );
468 			msLastPath = mpEffect->getPath();
469 			updatePathAttributes();
470 			mbInUpdatePath = false;
471 		}
472 	}
473 }
474 
475 // --------------------------------------------------------------------
476 
MovePath(int nDX,int nDY)477 void MotionPathTag::MovePath( int nDX, int nDY )
478 {
479 	if( mpPathObj )
480 	{
481 		mpPathObj->Move( Size( nDX, nDY ) );
482 		mrView.updateHandles();
483 	}
484 }
485 
486 // --------------------------------------------------------------------
487 
488 /** returns true if the MotionPathTag handled the event. */
MouseButtonDown(const MouseEvent & rMEvt,SmartHdl & rHdl)489 bool MotionPathTag::MouseButtonDown( const MouseEvent& rMEvt, SmartHdl& rHdl )
490 {
491 	if( !mpPathObj )
492 		return false;
493 
494 	if( !isSelected() )
495 	{
496 		SmartTagReference xTag( this );
497 		mrView.getSmartTags().select( xTag );
498         selectionChanged();
499 		return true;
500 	}
501 	else
502 	{
503 		if( rMEvt.IsLeft() && (rMEvt.GetClicks() == 2) )
504 		{
505 			mrView.GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_BEZIER_EDIT, SFX_CALLMODE_ASYNCHRON);
506 			return true;
507 		}
508 		else if( rMEvt.IsLeft() )
509 		{
510 			OutputDevice* pOut = mrView.GetViewShell()->GetActiveWindow();
511 			Point aMDPos( pOut->PixelToLogic( rMEvt.GetPosPixel() ) );
512 
513 			if( !mrView.IsFrameDragSingles() && mrView.IsInsObjPointMode() && (rHdl.GetObjHdlNum() == SMART_TAG_HDL_NUM) )
514 			{
515 				// insert a point in edit mode
516 				const bool bNewObj = rMEvt.IsMod1();
517 
518 				mrView.BrkAction();
519 
520 				Point aPt(aMDPos); // - pMarkedPV->GetOffset());
521 
522 				if(bNewObj)
523 					aPt = mrView.GetSnapPos(aPt,mrView.GetSdrPageView());
524 
525 				sal_Bool bClosed0(mpPathObj->IsClosedObj());
526 
527 				sal_uInt32 nInsPointNum = mpPathObj->NbcInsPointOld(aPt, bNewObj, sal_True);
528 
529 				if(bClosed0 != mpPathObj->IsClosedObj())
530 				{
531 					// Obj was closed implicit
532 					// object changed
533 					mpPathObj->SetChanged();
534 					mpPathObj->BroadcastObjectChange();
535 				}
536 
537 				if(0xffffffff != nInsPointNum)
538 				{
539 					mrView.UnmarkAllPoints();
540 					mrView.updateHandles();
541 
542 					bool bRet = mrView.BegDragObj(aMDPos, pOut, mrView.GetHdl(nInsPointNum+1), 0, new PathDragObjOwn( mrView ) );
543 
544 					if (bRet)
545 					{
546 						const_cast< SdrDragStat* >( &mrView.GetDragStat() )->SetMinMoved();
547 						mrView.MovDragObj(aMDPos);
548 					}
549 				}
550 				return true;
551 			}
552 			else
553 			{
554 				SmartHdl* pHdl = &rHdl;
555 				if (!mrView.IsPointMarked(*pHdl) || rMEvt.IsShift())
556 		        {
557 					if (!rMEvt.IsShift())
558 	                {
559 		                mrView.UnmarkAllPoints();
560 			            pHdl = dynamic_cast< SmartHdl* >( mrView.PickHandle(aMDPos) );
561 				    }
562 					else
563 	                {
564 		                if (mrView.IsPointMarked(*pHdl) )
565 			            {
566 				            mrView.UnmarkPoint(*pHdl);
567 					        pHdl = NULL;
568 	                    }
569 		                else
570 			            {
571 				            pHdl = dynamic_cast< SmartHdl* >( mrView.PickHandle(aMDPos) );
572 					    }
573 					}
574 
575 		            if (pHdl)
576 				        mrView.MarkPoint(*pHdl);
577                 }
578 
579 
580 				if( pHdl && !rMEvt.IsRight() )
581 				{
582 					mrView.BrkAction();
583 					const sal_uInt16 nDrgLog = (sal_uInt16)pOut->PixelToLogic(Size(DRGPIX,0)).Width();
584 
585 					rtl::Reference< MotionPathTag > xTag( this );
586 					SdrDragMethod* pDragMethod;
587 
588 					// #i95646# add DragPoly as geometry to each local SdrDragMethod to be able
589 					// to create the needed local SdrDragEntry for it in createSdrDragEntries()
590 					const basegfx::B2DPolyPolygon aDragPoly(mpPathObj->GetPathPoly());
591 
592 					if( (pHdl->GetKind() == HDL_MOVE) || (pHdl->GetKind() == HDL_SMARTTAG) )
593 					{
594 						pDragMethod = new PathDragMove( mrView, xTag, aDragPoly );
595 						pHdl->SetPos( aMDPos );
596 					}
597 					else if( pHdl->GetKind() == HDL_POLY )
598 					{
599 						pDragMethod = new PathDragObjOwn( mrView, aDragPoly );
600 					}
601 					else
602 					{
603 						pDragMethod = new PathDragResize( mrView, xTag, aDragPoly );
604 					}
605 
606 					mrView.BegDragObj(aMDPos, NULL, pHdl, nDrgLog, pDragMethod );
607 				}
608 				return true;
609 			}
610 		}
611 	}
612 
613 	return false;
614 }
615 
616 // --------------------------------------------------------------------
617 
618 /** returns true if the SmartTag consumes this event. */
KeyInput(const KeyEvent & rKEvt)619 bool MotionPathTag::KeyInput( const KeyEvent& rKEvt )
620 {
621 	if( !mpPathObj )
622 		return false;
623 
624 	sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
625 	switch( nCode )
626 	{
627 	case KEY_DELETE:
628 		return OnDelete();
629 
630 	case KEY_DOWN:
631 	case KEY_UP:
632 	case KEY_LEFT:
633 	case KEY_RIGHT:
634 		return OnMove( rKEvt );
635 
636 	case KEY_ESCAPE:
637 	{
638 		SmartTagReference xThis( this );
639 		mrView.getSmartTags().deselect();
640 		return true;
641 	}
642 
643 	case KEY_TAB:
644 		return OnTabHandles( rKEvt );
645 
646 	case KEY_SPACE:
647 		return OnMarkHandle( rKEvt );
648 
649 	default:
650 		break;
651 	}
652 	return false;
653 }
654 
OnDelete()655 bool MotionPathTag::OnDelete()
656 {
657 	mrPane.remove( mpEffect );
658 	return true;
659 }
660 
OnTabHandles(const KeyEvent & rKEvt)661 bool MotionPathTag::OnTabHandles( const KeyEvent& rKEvt )
662 {
663 	if(rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
664 	{
665 		const SdrHdlList& rHdlList = mrView.GetHdlList();
666 		sal_Bool bForward(!rKEvt.GetKeyCode().IsShift());
667 
668 		((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
669 
670 		// guarantee visibility of focused handle
671 		SdrHdl* pHdl = rHdlList.GetFocusHdl();
672 
673 		if(pHdl)
674 		{
675 			Window* pWindow = mrView.GetViewShell()->GetActiveWindow();
676 			if( pWindow )
677 			{
678 				Point aHdlPosition(pHdl->GetPos());
679 				Rectangle aVisRect(aHdlPosition - Point(100, 100), Size(200, 200));
680 				mrView.MakeVisible(aVisRect, *pWindow);
681 			}
682 		}
683 
684 		return true;
685 	}
686 
687 	return false;
688 }
689 
OnMarkHandle(const KeyEvent & rKEvt)690 bool MotionPathTag::OnMarkHandle( const KeyEvent& rKEvt )
691 {
692 	const SdrHdlList& rHdlList = mrView.GetHdlList();
693 	SdrHdl* pHdl = rHdlList.GetFocusHdl();
694 
695 	if(pHdl && pHdl->GetKind() == HDL_POLY )
696 	{
697 		// rescue ID of point with focus
698 		sal_uInt32 nPol(pHdl->GetPolyNum());
699 		sal_uInt32 nPnt(pHdl->GetPointNum());
700 
701 		if(mrView.IsPointMarked(*pHdl))
702 		{
703 			if(rKEvt.GetKeyCode().IsShift())
704 			{
705 				mrView.UnmarkPoint(*pHdl);
706 			}
707 		}
708 		else
709 		{
710 			if(!rKEvt.GetKeyCode().IsShift())
711 			{
712 				mrView.UnmarkAllPoints();
713 			}
714 			mrView.MarkPoint(*pHdl);
715 		}
716 
717 		if(0L == rHdlList.GetFocusHdl())
718 		{
719 			// restore point with focus
720 			SdrHdl* pNewOne = 0L;
721 
722 			for(sal_uInt32 a(0); !pNewOne && a < rHdlList.GetHdlCount(); a++)
723 			{
724 				SdrHdl* pAct = rHdlList.GetHdl(a);
725 
726 				if(pAct && pAct->GetKind() == HDL_POLY && pAct->GetPolyNum() == nPol && pAct->GetPointNum() == nPnt)
727 					pNewOne = pAct;
728 			}
729 
730 			if(pNewOne)
731 				((SdrHdlList&)rHdlList).SetFocusHdl(pNewOne);
732 		}
733 	}
734 
735 	return true;
736 }
737 
OnMove(const KeyEvent & rKEvt)738 bool MotionPathTag::OnMove( const KeyEvent& rKEvt )
739 {
740 	long nX = 0;
741 	long nY = 0;
742 
743 	switch( rKEvt.GetKeyCode().GetCode() )
744 	{
745 	case KEY_UP:	nY = -1; break;
746 	case KEY_DOWN:	nY =  1; break;
747 	case KEY_LEFT:	nX = -1; break;
748 	case KEY_RIGHT:	nX =  1; break;
749 	default: break;
750 	}
751 
752 	if(rKEvt.GetKeyCode().IsMod2())
753 	{
754 		OutputDevice* pOut = mrView.GetViewShell()->GetActiveWindow();
755 		Size aLogicSizeOnePixel = (pOut) ? pOut->PixelToLogic(Size(1,1)) : Size(100, 100);
756 		nX *= aLogicSizeOnePixel.Width();
757 		nY *= aLogicSizeOnePixel.Height();
758 	}
759 	else
760 	{
761 		// old, fixed move distance
762 		nX *= 100;
763 		nY *= 100;
764 	}
765 
766 	if( nX || nY )
767 	{
768 		// in point edit mode move the handle with the focus
769 		const SdrHdlList& rHdlList = mrView.GetHdlList();
770 		SdrHdl* pHdl = rHdlList.GetFocusHdl();
771 
772 		if(pHdl)
773 		{
774 			// now move the Handle (nX, nY)
775 			Point aStartPoint(pHdl->GetPos());
776 			Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
777 
778 			// start dragging
779 			rtl::Reference< MotionPathTag > xTag( this );
780 			SdrDragMethod* pDragMethod = 0;
781 			if( (pHdl->GetKind() == HDL_MOVE) || (pHdl->GetKind() == HDL_SMARTTAG) )
782 			{
783 				pDragMethod = new PathDragMove( mrView, xTag );
784 			}
785 			else if( pHdl->GetKind() == HDL_POLY )
786 			{
787 				pDragMethod = new PathDragObjOwn( mrView );
788 			}
789 			else if( pHdl->GetKind() != HDL_BWGT )
790 			{
791 				pDragMethod = new PathDragResize( mrView, xTag );
792 			}
793 			mrView.BegDragObj(aStartPoint, 0, pHdl, 0, pDragMethod);
794 
795 			if(mrView.IsDragObj())
796 			{
797 				FASTBOOL bWasNoSnap = mrView.GetDragStat().IsNoSnap();
798 				sal_Bool bWasSnapEnabled = mrView.IsSnapEnabled();
799 
800 				// switch snapping off
801 				if(!bWasNoSnap)
802 					((SdrDragStat&)mrView.GetDragStat()).SetNoSnap(sal_True);
803 				if(bWasSnapEnabled)
804 					mrView.SetSnapEnabled(sal_False);
805 
806 				mrView.MovAction(aEndPoint);
807 				mrView.EndDragObj();
808 
809 				// restore snap
810 				if(!bWasNoSnap)
811 					((SdrDragStat&)mrView.GetDragStat()).SetNoSnap(bWasNoSnap);
812 				if(bWasSnapEnabled)
813 					mrView.SetSnapEnabled(bWasSnapEnabled);
814 			}
815 		}
816 		else
817 		{
818 			// move the path
819 			MovePath( nX, nY );
820 		}
821 	}
822 
823 	return true;
824 }
825 
826 // --------------------------------------------------------------------
827 
GetMarkablePointCount() const828 sal_uLong MotionPathTag::GetMarkablePointCount() const
829 {
830 	if( mpPathObj && isSelected() )
831 	{
832 		return mpPathObj->GetPointCount();
833 	}
834 	else
835 	{
836 		return 0;
837 	}
838 }
839 
840 // --------------------------------------------------------------------
841 
GetMarkedPointCount() const842 sal_uLong MotionPathTag::GetMarkedPointCount() const
843 {
844 	if( mpMark )
845 	{
846 		const SdrUShortCont* pPts=mpMark->GetMarkedPoints();
847 		return pPts ? pPts->GetCount() : 0;
848 	}
849 	else
850 	{
851 		return 0;
852 	}
853 }
854 
855 // --------------------------------------------------------------------
856 
MarkPoint(SdrHdl & rHdl,sal_Bool bUnmark)857 sal_Bool MotionPathTag::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark )
858 {
859 	sal_Bool bRet=sal_False;
860 	if( mpPathObj && mrView.IsPointMarkable( rHdl ) && (rHdl.GetKind() != HDL_SMARTTAG) )
861 	{
862 		SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( &rHdl );
863 		if( pSmartHdl && pSmartHdl->getTag().get() == this )
864 		{
865 			SdrUShortCont* pPts=mpMark->ForceMarkedPoints();
866 			pPts->ForceSort();
867 			if (mrView.MarkPointHelper(&rHdl,mpMark,bUnmark))
868 			{
869 				pPts->ForceSort();
870 				mrView.MarkListHasChanged();
871 				bRet=sal_True;
872 			}
873 		}
874 	}
875 	return bRet;
876 }
877 
878 // --------------------------------------------------------------------
879 
MarkPoints(const Rectangle * pRect,sal_Bool bUnmark)880 sal_Bool MotionPathTag::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark )
881 {
882 	sal_Bool bChgd=sal_False;
883 
884 	if( mpPathObj && isSelected() )
885 	{
886 		sal_Int32 nHdlNum = mrView.GetHdlList().GetHdlCount() - 1;
887 		while( nHdlNum > 0 )
888 		{
889 			SmartHdl* pHdl = dynamic_cast< SmartHdl* >( mrView.GetHdl( sal::static_int_cast< sal_uLong >( nHdlNum-- ) ) );
890 
891 			if( pHdl && (pHdl->getTag().get() == this) && mrView.IsPointMarkable(*pHdl) && pHdl->IsSelected()==bUnmark)
892 			{
893 				Point aPos(pHdl->GetPos());
894 				if( pRect==NULL || pRect->IsInside(aPos))
895 				{
896 					if( mrView.MarkPointHelper(pHdl,mpMark,bUnmark) )
897 						bChgd=sal_True;
898 				}
899 			}
900 		}
901 
902 		if(bChgd)
903 			mrView.MarkListHasChanged();
904 	}
905 
906 	return bChgd;
907 }
908 
909 // --------------------------------------------------------------------
910 
getContext(SdrViewContext & rContext)911 bool MotionPathTag::getContext( SdrViewContext& rContext )
912 {
913 	if( mpPathObj && isSelected() && !mrView.IsFrameDragSingles() )
914 	{
915 		rContext = SDRCONTEXT_POINTEDIT;
916 		return true;
917 	}
918 	else
919 	{
920 		return false;
921 	}
922 }
923 
924 // --------------------------------------------------------------------
925 
CheckPossibilities()926 void MotionPathTag::CheckPossibilities()
927 {
928 	if( mpPathObj )
929 	{
930 		if( isSelected() )
931 		{
932 			mrView.SetMoveAllowed( true );
933 			mrView.SetMoveProtected( false );
934 			mrView.SetResizeFreeAllowed( true );
935 			mrView.SetResizePropAllowed( true );
936 			mrView.SetResizeProtected( false );
937 
938             if( !mrView.IsFrameDragSingles() )
939 			{
940 				bool b1stSmooth(true);
941 				bool b1stSegm(true);
942 				bool bCurve(false);
943 				bool bSmoothFuz(false);
944 				bool bSegmFuz(false);
945 				basegfx::B2VectorContinuity eSmooth = basegfx::CONTINUITY_NONE;
946 
947 				mrView.CheckPolyPossibilitiesHelper( mpMark, b1stSmooth, b1stSegm, bCurve, bSmoothFuz, bSegmFuz, eSmooth );
948 			}
949 		}
950 	}
951 }
952 
953 // --------------------------------------------------------------------
954 
addCustomHandles(SdrHdlList & rHandlerList)955 void MotionPathTag::addCustomHandles( SdrHdlList& rHandlerList )
956 {
957 	if( mpPathObj )
958 	{
959 		::com::sun::star::awt::Point aPos( mxOrigin->getPosition() );
960 		if( (aPos.X != maOriginPos.X) || (aPos.Y != maOriginPos.Y) )
961 		{
962             const basegfx::B2DHomMatrix aTransform(basegfx::tools::createTranslateB2DHomMatrix(
963                 aPos.X - maOriginPos.X, aPos.Y - maOriginPos.Y));
964 			mxPolyPoly.transform( aTransform );
965 			mpPathObj->SetPathPoly( mxPolyPoly );
966 			maOriginPos = aPos;
967 		}
968 
969 		SmartTagReference xThis( this );
970 		SdPathHdl* pHdl = new SdPathHdl( xThis, mpPathObj );
971 		pHdl->SetObjHdlNum( SMART_TAG_HDL_NUM );
972 		pHdl->SetPageView( mrView.GetSdrPageView() );
973 
974 
975 		pHdl->SetObj(mpPathObj);
976 		rHandlerList.AddHdl( pHdl );
977 
978 		if( isSelected() )
979 		{
980 			mrView.GetSdrPageView()->SetHasMarkedObj(sal_True);
981 
982 			if( !mrView.IsFrameDragSingles() )
983 			{
984 				SdrHdlList aTemp( rHandlerList.GetView() );
985 				mpPathObj->AddToHdlList( aTemp );
986 				const SdrUShortCont* pMrkPnts=mpMark->GetMarkedPoints();
987 
988 				sal_uInt32 nHandle;
989 				for( nHandle = 0; nHandle < aTemp.GetHdlCount(); ++nHandle )
990 				{
991 					SdrHdl* pTempHdl = aTemp.GetHdl( nHandle );
992 
993 					SmartHdl* pSmartHdl = new SmartHdl( xThis, mpPathObj, pTempHdl->GetPos(), pTempHdl->GetKind() );
994 					pSmartHdl->SetObjHdlNum( nHandle );
995 					pSmartHdl->SetPolyNum( pTempHdl->GetPolyNum() );
996 					pSmartHdl->SetPointNum( pTempHdl->GetPointNum() );
997 					pSmartHdl->SetPlusHdl(  pTempHdl->IsPlusHdl() );
998 					pSmartHdl->SetSourceHdlNum( pTempHdl->GetSourceHdlNum() );
999 					pSmartHdl->SetPageView( mrView.GetSdrPageView() );
1000 
1001 					rHandlerList.AddHdl( pSmartHdl );
1002 
1003 					const bool bSelected= pMrkPnts && pMrkPnts->Exist(sal::static_int_cast< sal_uInt16 >(nHandle));
1004 					pSmartHdl->SetSelected(bSelected);
1005 
1006 					if( mrView.IsPlusHandlesAlwaysVisible() || bSelected )
1007 					{
1008 						sal_uInt32 nPlusAnz=mpPathObj->GetPlusHdlCount(*pSmartHdl);
1009 						for (sal_uInt32 nPlusNum=0; nPlusNum<nPlusAnz; nPlusNum++)
1010 						{
1011 							SdrHdl* pPlusHdl = mpPathObj->GetPlusHdl(*pSmartHdl,nPlusNum);
1012 							if (pPlusHdl!=NULL)
1013 							{
1014 								pPlusHdl->SetObj(mpPathObj);
1015 								pPlusHdl->SetPageView(mrView.GetSdrPageView());
1016 								pPlusHdl->SetPlusHdl(sal_True);
1017 								rHandlerList.AddHdl(pPlusHdl);
1018 							}
1019 						}
1020 					}
1021 				}
1022 			}
1023 			else
1024 			{
1025 				Rectangle aRect(mpPathObj->GetCurrentBoundRect());
1026 
1027 				if(!aRect.IsEmpty())
1028 				{
1029 					sal_uLong nCount = rHandlerList.GetHdlCount();
1030 
1031 					sal_Bool bWdt0=aRect.Left()==aRect.Right();
1032 					sal_Bool bHgt0=aRect.Top()==aRect.Bottom();
1033 					if (bWdt0 && bHgt0)
1034 					{
1035 						rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.TopLeft(),HDL_UPLFT));
1036 					}
1037 					else if (bWdt0 || bHgt0)
1038 					{
1039 						rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.TopLeft()    ,HDL_UPLFT));
1040 						rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.BottomRight(),HDL_LWRGT));
1041 					}
1042 					else
1043 					{
1044 						if (!bWdt0 && !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.TopLeft()     ,HDL_UPLFT));
1045 						if (          !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.TopCenter()   ,HDL_UPPER));
1046 						if (!bWdt0 && !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.TopRight()    ,HDL_UPRGT));
1047 						if (!bWdt0          ) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.LeftCenter()  ,HDL_LEFT ));
1048 						if (!bWdt0          ) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.RightCenter() ,HDL_RIGHT));
1049 						if (!bWdt0 && !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.BottomLeft()  ,HDL_LWLFT));
1050 						if (          !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.BottomCenter(),HDL_LOWER));
1051 						if (!bWdt0 && !bHgt0) rHandlerList.AddHdl(new SmartHdl( xThis, mpPathObj, aRect.BottomRight() ,HDL_LWRGT));
1052 					}
1053 
1054 					while( nCount < rHandlerList.GetHdlCount() )
1055 					{
1056 						rHandlerList.GetHdl(nCount++)->SetPageView( mrView.GetSdrPageView() );
1057 					}
1058 				}
1059 			}
1060 		}
1061 	}
1062 }
1063 
1064 // --------------------------------------------------------------------
1065 
disposing()1066 void MotionPathTag::disposing()
1067 {
1068 	Reference< XChangesNotifier > xNotifier( mpEffect->getNode(), UNO_QUERY );
1069 	if( xNotifier.is() )
1070 	{
1071 		Reference< XChangesListener > xListener( this );
1072 		xNotifier->removeChangesListener( this );
1073 	}
1074 
1075 	if( mpPathObj )
1076 	{
1077 		SdrPathObj* pPathObj = mpPathObj;
1078 		mpPathObj = 0;
1079 		mrView.updateHandles();
1080 		delete pPathObj;
1081 	}
1082 
1083 	if( mpMark )
1084 	{
1085 		delete mpMark;
1086 		mpMark = 0;
1087 	}
1088 
1089 	SmartTag::disposing();
1090 }
1091 
1092 // --------------------------------------------------------------------
1093 
deselect()1094 void MotionPathTag::deselect()
1095 {
1096 	SmartTag::deselect();
1097 
1098 	if( mpMark )
1099 	{
1100 		SdrUShortCont* pPts = mpMark->GetMarkedPoints();
1101 
1102 		if( pPts )
1103 			pPts->Clear();
1104 	}
1105 
1106     selectionChanged();
1107 }
1108 
selectionChanged()1109 void MotionPathTag::selectionChanged()
1110 {
1111     if( mrView.GetViewShell() && mrView.GetViewShell()->GetViewFrame() )
1112     {
1113         SfxBindings& rBindings = mrView.GetViewShell()->GetViewFrame()->GetBindings();
1114         rBindings.InvalidateAll(sal_True);
1115     }
1116 }
1117 // --------------------------------------------------------------------
1118 // IPolyPolygonEditorController
1119 // --------------------------------------------------------------------
1120 
DeleteMarkedPoints()1121 void MotionPathTag::DeleteMarkedPoints()
1122 {
1123 	if( mpPathObj && IsDeleteMarkedPointsPossible() )
1124 	{
1125 		mrView.BrkAction();
1126 
1127 		// Description
1128 //		BegUndo(ImpGetResStr(STR_EditDelete),GetDescriptionOfMarkedPoints(),SDRREPFUNC_OBJ_DELETE);
1129 
1130 		SdrUShortCont* pPts = mpMark->GetMarkedPoints();
1131 
1132 		if( pPts )
1133 		{
1134 			PolyPolygonEditor aEditor( mpPathObj->GetPathPoly(), mpPathObj->IsClosed() );
1135 			if( aEditor.DeletePoints( pPts->getContainer() ) )
1136 			{
1137 				if( aEditor.GetPolyPolygon().count() )
1138 				{
1139 //					AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath ));
1140 					mpPathObj->SetPathPoly( aEditor.GetPolyPolygon() );
1141 				}
1142 				else
1143 				{
1144 //					AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pPath ) );
1145 //					pM->GetPageView()->GetObjList()->RemoveObject(pObj->GetOrdNum());
1146 				}
1147 
1148 				mrView.UnmarkAllPoints();
1149 				mrView.MarkListHasChanged();
1150 				mrView.updateHandles();
1151 			}
1152 		}
1153 
1154 //		EndUndo();
1155 	}
1156 }
1157 
IsDeleteMarkedPointsPossible() const1158 sal_Bool MotionPathTag::IsDeleteMarkedPointsPossible() const
1159 {
1160 	return mpPathObj && isSelected() && (GetMarkedPointCount() != 0);
1161 }
1162 
RipUpAtMarkedPoints()1163 void MotionPathTag::RipUpAtMarkedPoints()
1164 {
1165 	// not supported for motion path
1166 }
1167 
IsRipUpAtMarkedPointsPossible() const1168 bool MotionPathTag::IsRipUpAtMarkedPointsPossible() const
1169 {
1170 	// not supported for motion path
1171 	return false;
1172 }
1173 
IsSetMarkedSegmentsKindPossible() const1174 sal_Bool MotionPathTag::IsSetMarkedSegmentsKindPossible() const
1175 {
1176 	if( mpPathObj )
1177 		return mrView.IsSetMarkedSegmentsKindPossible();
1178 	else
1179 		return sal_False;
1180 }
1181 
GetMarkedSegmentsKind() const1182 SdrPathSegmentKind MotionPathTag::GetMarkedSegmentsKind() const
1183 {
1184 	if( mpPathObj )
1185 		return mrView.GetMarkedSegmentsKind();
1186 	else
1187 		return SDRPATHSEGMENT_LINE;
1188 }
1189 
SetMarkedSegmentsKind(SdrPathSegmentKind eKind)1190 void MotionPathTag::SetMarkedSegmentsKind(SdrPathSegmentKind eKind)
1191 {
1192 	if(mpPathObj && isSelected() && (GetMarkedPointCount() != 0))
1193 	{
1194 		SdrUShortCont* pPts = mpMark->GetMarkedPoints();
1195 		if(pPts)
1196 		{
1197 			PolyPolygonEditor aEditor( mpPathObj->GetPathPoly(), mpPathObj->IsClosed() );
1198 			if(aEditor.SetSegmentsKind( eKind, pPts->getContainer()) )
1199 			{
1200 //				AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
1201 				mpPathObj->SetPathPoly(aEditor.GetPolyPolygon());
1202 				mrView.MarkListHasChanged();
1203 				mrView.updateHandles();
1204 			}
1205 		}
1206 	}
1207 }
1208 
IsSetMarkedPointsSmoothPossible() const1209 sal_Bool MotionPathTag::IsSetMarkedPointsSmoothPossible() const
1210 {
1211 	if( mpPathObj )
1212 		return mrView.IsSetMarkedPointsSmoothPossible();
1213 	else
1214 		return sal_False;
1215 }
1216 
GetMarkedPointsSmooth() const1217 SdrPathSmoothKind MotionPathTag::GetMarkedPointsSmooth() const
1218 {
1219 	if( mpPathObj )
1220 		return mrView.GetMarkedPointsSmooth();
1221 	else
1222 		return SDRPATHSMOOTH_ANGULAR;
1223 }
1224 
SetMarkedPointsSmooth(SdrPathSmoothKind eKind)1225 void MotionPathTag::SetMarkedPointsSmooth(SdrPathSmoothKind eKind)
1226 {
1227 	basegfx::B2VectorContinuity eFlags;
1228 
1229 	if(SDRPATHSMOOTH_ANGULAR == eKind)
1230 	{
1231 		eFlags = basegfx::CONTINUITY_NONE;
1232 	}
1233 	else if(SDRPATHSMOOTH_ASYMMETRIC == eKind)
1234 	{
1235 		eFlags = basegfx::CONTINUITY_C1;
1236 	}
1237 	else if(SDRPATHSMOOTH_SYMMETRIC == eKind)
1238 	{
1239 		eFlags = basegfx::CONTINUITY_C2;
1240 	}
1241 	else
1242 	{
1243 		return;
1244 	}
1245 
1246 	if(mpPathObj && mpMark && isSelected() && (GetMarkedPointCount() != 0))
1247 	{
1248 		SdrUShortCont* pPts = mpMark->GetMarkedPoints();
1249 		if(pPts)
1250 		{
1251 			PolyPolygonEditor aEditor( mpPathObj->GetPathPoly(), mpPathObj->IsClosed() );
1252 			if(aEditor.SetPointsSmooth( eFlags, pPts->getContainer() ) )
1253 			{
1254 //				AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPath));
1255 				mpPathObj->SetPathPoly(aEditor.GetPolyPolygon());
1256 				mrView.MarkListHasChanged();
1257 				mrView.updateHandles();
1258 			}
1259 		}
1260 	}
1261 }
1262 
CloseMarkedObjects(sal_Bool,sal_Bool)1263 void MotionPathTag::CloseMarkedObjects(sal_Bool /*bToggle*/, sal_Bool /*bOpen*/ )
1264 {
1265 	// not supported for motion path
1266 }
1267 
IsOpenCloseMarkedObjectsPossible() const1268 bool MotionPathTag::IsOpenCloseMarkedObjectsPossible() const
1269 {
1270 	// not supported for motion path
1271 	return false;
1272 }
1273 
GetMarkedObjectsClosedState() const1274 SdrObjClosedKind MotionPathTag::GetMarkedObjectsClosedState() const
1275 {
1276 	// not supported for motion path
1277 	return SDROBJCLOSED_OPEN;
1278 }
1279 
1280 // XChangesListener
changesOccurred(const ChangesEvent &)1281 void SAL_CALL MotionPathTag::changesOccurred( const ChangesEvent& /*Event*/ ) throw (RuntimeException)
1282 {
1283 	if( mpPathObj && !mbInUpdatePath && (mpEffect->getPath() != msLastPath) )
1284 	{
1285 		mbInUpdatePath =true;
1286 		msLastPath = mpEffect->getPath();
1287 		mpEffect->updateSdrPathObjFromPath( *mpPathObj );
1288 		mbInUpdatePath = false;
1289 		updatePathAttributes();
1290 		mrView.updateHandles();
1291 	}
1292 }
1293 
disposing(const EventObject &)1294 void SAL_CALL MotionPathTag::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
1295 {
1296 	if( mpPathObj )
1297 		Dispose();
1298 }
1299 
queryInterface(const::com::sun::star::uno::Type & aType)1300 Any SAL_CALL MotionPathTag::queryInterface( const ::com::sun::star::uno::Type& aType ) throw (RuntimeException)
1301 {
1302 	if( aType == XChangesListener::static_type() )
1303 		return Any( Reference< XChangesListener >( this ) );
1304 	if( aType == XEventListener::static_type() )
1305 		return Any( Reference< XEventListener >( this ) );
1306 	if( aType == XInterface::static_type() )
1307 		return Any( Reference< XInterface >( this ) );
1308 
1309 	return Any();
1310 }
1311 
acquire()1312 void SAL_CALL MotionPathTag::acquire() throw ()
1313 {
1314 	SimpleReferenceComponent::acquire();
1315 }
1316 
release()1317 void SAL_CALL MotionPathTag::release(  ) throw ()
1318 {
1319 	SimpleReferenceComponent::release();
1320 }
1321 
1322 } // end of namespace sd
1323 
1324