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