sd/source/ui/animations/motionpathtag.cxx

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