sd/source/ui/animations/motionpathtag.cxx

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