svx/source/svdraw/svddrgv.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: svddrgv.cxx,v $
  10  * $Revision: 1.27.18.1 $
  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_svx.hxx"
  33
  34 #include <svx/svddrgv.hxx>
  35 #include "xattr.hxx"
  36 #include <svx/xpoly.hxx>
  37 #include <svx/svdetc.hxx>
  38 #include <svx/svdtrans.hxx>
  39 #include <svx/svdundo.hxx>
  40 #include <svx/svdocapt.hxx>
  41 #include <svx/svdpagv.hxx>
  42 #include <svx/svdopath.hxx>
  43 #include <svx/svdoedge.hxx>
  44 #include "svdstr.hrc"
  45 #include "svdglob.hxx"
  46 #include "svddrgm1.hxx"
  47 #include <svx/obj3d.hxx>
  48 #include <svx/svdoashp.hxx>
  49 #include <sdrpaintwindow.hxx>
  50 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  51 #include <basegfx/polygon/b2dpolygontools.hxx>
  52 #include <svx/polypolygoneditor.hxx>
  53 #include <basegfx/matrix/b2dhommatrix.hxx>
  54 #include <svx/sdr/overlay/overlaymanager.hxx>
  55
  56 using namespace sdr;
  57
  58 ////////////////////////////////////////////////////////////////////////////////////////////////////
  59 ////////////////////////////////////////////////////////////////////////////////////////////////////
  60 //
  61 //  @@@@@  @@@@@   @@@@   @@@@   @@ @@ @@ @@@@@ @@   @@
  62 //  @@  @@ @@  @@ @@  @@ @@  @@  @@ @@ @@ @@    @@   @@
  63 //  @@  @@ @@  @@ @@  @@ @@      @@ @@ @@ @@    @@ @ @@
  64 //  @@  @@ @@@@@  @@@@@@ @@ @@@  @@@@@ @@ @@@@  @@@@@@@
  65 //  @@  @@ @@  @@ @@  @@ @@  @@   @@@  @@ @@    @@@@@@@
  66 //  @@  @@ @@  @@ @@  @@ @@  @@   @@@  @@ @@    @@@ @@@
  67 //  @@@@@  @@  @@ @@  @@  @@@@@    @   @@ @@@@@ @@   @@
  68 //
  69 ////////////////////////////////////////////////////////////////////////////////////////////////////
  70 ////////////////////////////////////////////////////////////////////////////////////////////////////
  71
  72 void SdrDragView::ImpClearVars()
  73 {
  74     bFramDrag=FALSE;
  75     eDragMode=SDRDRAG_MOVE;
  76     bDragLimit=FALSE;
  77     bMarkedHitMovesAlways=FALSE;
  78     eDragHdl=HDL_MOVE;
  79     pDragHdl=NULL;
  80     bDragHdl=FALSE;
  81     bDragSpecial=FALSE;
  82     mpCurrentSdrDragMethod=NULL;
  83     bDragStripes=FALSE;
  84     bMirrRefDragObj=TRUE;
  85     bDragWithCopy=FALSE;
  86     pInsPointUndo=NULL;
  87     bInsGluePoint=FALSE;
  88     bInsObjPointMode=FALSE;
  89     bInsGluePointMode=FALSE;
  90     nDragXorPolyLimit=100;
  91     nDragXorPointLimit=500;
  92     bNoDragXorPolys=FALSE;
  93     bAutoVertexCon=TRUE;
  94     bAutoCornerCon=FALSE;
  95     bRubberEdgeDragging=TRUE;
  96     nRubberEdgeDraggingLimit=100;
  97     bDetailedEdgeDragging=TRUE;
  98     nDetailedEdgeDraggingLimit=10;
  99     bResizeAtCenter=FALSE;
 100     bCrookAtCenter=FALSE;
 101     bMouseHideWhileDraggingPoints=FALSE;
 102
 103     // init using default
 104     mbSolidDragging = getOptionsDrawinglayer().IsSolidDragCreate();
 105 }
 106
 107 void SdrDragView::ImpMakeDragAttr()
 108 {
 109     ImpDelDragAttr();
 110 }
 111
 112 SdrDragView::SdrDragView(SdrModel* pModel1, OutputDevice* pOut)
 113 :       SdrExchangeView(pModel1,pOut)
 114 {
 115     ImpClearVars();
 116     ImpMakeDragAttr();
 117 }
 118
 119 SdrDragView::~SdrDragView()
 120 {
 121     ImpDelDragAttr();
 122 }
 123
 124 void SdrDragView::ImpDelDragAttr()
 125 {
 126 }
 127
 128 BOOL SdrDragView::IsAction() const
 129 {
 130     return (mpCurrentSdrDragMethod || SdrExchangeView::IsAction());
 131 }
 132
 133 void SdrDragView::MovAction(const Point& rPnt)
 134 {
 135     SdrExchangeView::MovAction(rPnt);
 136     if (mpCurrentSdrDragMethod)
 137     {
 138         MovDragObj(rPnt);
 139     }
 140 }
 141
 142 void SdrDragView::EndAction()
 143 {
 144     if (mpCurrentSdrDragMethod)
 145     {
 146         EndDragObj(FALSE);
 147     }
 148     SdrExchangeView::EndAction();
 149 }
 150
 151 void SdrDragView::BckAction()
 152 {
 153     SdrExchangeView::BckAction();
 154     BrkDragObj();
 155 }
 156
 157 void SdrDragView::BrkAction()
 158 {
 159     SdrExchangeView::BrkAction();
 160     BrkDragObj();
 161 }
 162
 163 void SdrDragView::TakeActionRect(Rectangle& rRect) const
 164 {
 165     if (mpCurrentSdrDragMethod)
 166     {
 167         rRect=aDragStat.GetActionRect();
 168         if (rRect.IsEmpty())
 169         {
 170             SdrPageView* pPV = GetSdrPageView();
 171
 172             if(pPV&& pPV->HasMarkedObjPageView())
 173             {
 174                 // #i95646# is this used..?
 175                 const basegfx::B2DRange aBoundRange(mpCurrentSdrDragMethod->getCurrentRange());
 176                 rRect = Rectangle(
 177                     basegfx::fround(aBoundRange.getMinX()), basegfx::fround(aBoundRange.getMinY()),
 178                     basegfx::fround(aBoundRange.getMaxX()), basegfx::fround(aBoundRange.getMaxY()));
 179             }
 180         }
 181         if (rRect.IsEmpty())
 182         {
 183             rRect=Rectangle(aDragStat.GetNow(),aDragStat.GetNow());
 184         }
 185     }
 186     else
 187     {
 188         SdrExchangeView::TakeActionRect(rRect);
 189     }
 190 }
 191
 192 BOOL SdrDragView::TakeDragObjAnchorPos(Point& rPos, BOOL bTR ) const
 193 {
 194     Rectangle aR;
 195     TakeActionRect(aR);
 196     rPos = bTR ? aR.TopRight() : aR.TopLeft();
 197     if (GetMarkedObjectCount()==1 && IsDragObj() && // nur bei Einzelselektion
 198         !IsDraggingPoints() && !IsDraggingGluePoints() && // nicht beim Punkteschieben
 199         !mpCurrentSdrDragMethod->ISA(SdrDragMovHdl)) // nicht beim Handlesschieben
 200     {
 201         SdrObject* pObj=GetMarkedObjectByIndex(0);
 202         if (pObj->ISA(SdrCaptionObj))
 203         {
 204             Point aPt(((SdrCaptionObj*)pObj)->GetTailPos());
 205             BOOL bTail=eDragHdl==HDL_POLY; // Schwanz wird gedraggt (nicht so ganz feine Abfrage hier)
 206             BOOL bOwn=mpCurrentSdrDragMethod->ISA(SdrDragObjOwn); // Objektspeziefisch
 207             if (!bTail)
 208             { // bei bTail liefert TakeActionRect schon das richtige
 209                 if (bOwn)
 210                 { // bOwn kann sein MoveTextFrame, ResizeTextFrame aber eben nicht mehr DragTail
 211                     rPos=aPt;
 212                 }
 213                 else
 214                 {
 215                     // drag the whole Object (Move, Resize, ...)
 216                     const basegfx::B2DPoint aTransformed(mpCurrentSdrDragMethod->getCurrentTransformation() * basegfx::B2DPoint(aPt.X(), aPt.Y()));
 217                     rPos.X() = basegfx::fround(aTransformed.getX());
 218                     rPos.Y() = basegfx::fround(aTransformed.getY());
 219                 }
 220             }
 221         }
 222         return TRUE;
 223     }
 224     return FALSE;
 225 }
 226
 227 ////////////////////////////////////////////////////////////////////////////////////////////////////
 228
 229 BOOL SdrDragView::TakeDragLimit(SdrDragMode /*eMode*/, Rectangle& /*rRect*/) const
 230 {
 231     return FALSE;
 232 }
 233
 234 BOOL SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl, short nMinMov, SdrDragMethod* pForcedMeth)
 235 {
 236     BrkAction();
 237
 238     bool bRet=false;
 239     {
 240         SetDragWithCopy(FALSE);
 241         //ForceEdgesOfMarkedNodes();
 242         //TODO: aAni.Reset();
 243         mpCurrentSdrDragMethod=NULL;
 244         bDragSpecial=FALSE;
 245         bDragLimit=FALSE;
 246         SdrDragMode eTmpMode=eDragMode;
 247         if (eTmpMode==SDRDRAG_MOVE && pHdl!=NULL && pHdl->GetKind()!=HDL_MOVE) {
 248             eTmpMode=SDRDRAG_RESIZE;
 249         }
 250         bDragLimit=TakeDragLimit(eTmpMode,aDragLimit);
 251         bFramDrag=ImpIsFrameHandles();
 252         if (!bFramDrag &&
 253             (pMarkedObj==NULL || !pMarkedObj->hasSpecialDrag()) &&
 254             (pHdl==NULL || pHdl->GetObj()==NULL)) {
 255             bFramDrag=TRUE;
 256         }
 257
 258         Point aPnt(rPnt);
 259         if(pHdl == NULL
 260             || pHdl->GetKind() == HDL_MOVE
 261             || pHdl->GetKind() == HDL_MIRX
 262             || pHdl->GetKind() == HDL_TRNS
 263             || pHdl->GetKind() == HDL_GRAD)
 264         {
 265             aDragStat.Reset(aPnt);
 266         }
 267         else
 268         {
 269             aDragStat.Reset(pHdl->GetPos());
 270         }
 271
 272         aDragStat.SetView((SdrView*)this);
 273         aDragStat.SetPageView(pMarkedPV);  // <<-- hier muss die DragPV rein!!!
 274         aDragStat.SetMinMove(ImpGetMinMovLogic(nMinMov,pOut));
 275         aDragStat.SetHdl(pHdl);
 276         aDragStat.NextPoint();
 277         pDragWin=pOut;
 278         pDragHdl=pHdl;
 279         eDragHdl= pHdl==NULL ? HDL_MOVE : pHdl->GetKind();
 280         bDragHdl=eDragHdl==HDL_REF1 || eDragHdl==HDL_REF2 || eDragHdl==HDL_MIRX;
 281
 282         // #103894# Expand test for HDL_ANCHOR_TR
 283         BOOL bNotDraggable = (HDL_ANCHOR == eDragHdl || HDL_ANCHOR_TR == eDragHdl);
 284
 285         if(bDragHdl)
 286         {
 287             mpCurrentSdrDragMethod = new SdrDragMovHdl(*this);
 288         }
 289         else if(!bNotDraggable)
 290         {
 291             switch (eDragMode)
 292             {
 293                 case SDRDRAG_ROTATE: case SDRDRAG_SHEAR: case SDRDRAG_DISTORT:
 294                 {
 295                     switch (eDragHdl)
 296                     {
 297                         case HDL_LEFT:  case HDL_RIGHT:
 298                         case HDL_UPPER: case HDL_LOWER:
 299                         {
 300                             // Sind 3D-Objekte selektiert?
 301                             BOOL b3DObjSelected = FALSE;
 302                             for(UINT32 a=0;!b3DObjSelected && a<GetMarkedObjectCount();a++)
 303                             {
 304                                 SdrObject* pObj = GetMarkedObjectByIndex(a);
 305                                 if(pObj && pObj->ISA(E3dObject))
 306                                     b3DObjSelected = TRUE;
 307                             }
 308                             // Falls ja, Shear auch bei !IsShearAllowed zulassen,
 309                             // da es sich bei 3D-Objekten um eingeschraenkte
 310                             // Rotationen handelt
 311                             if (!b3DObjSelected && !IsShearAllowed())
 312                                 return FALSE;
 313                             mpCurrentSdrDragMethod = new SdrDragShear(*this,eDragMode==SDRDRAG_ROTATE);
 314                         } break;
 315                         case HDL_UPLFT: case HDL_UPRGT:
 316                         case HDL_LWLFT: case HDL_LWRGT:
 317                         {
 318                             if (eDragMode==SDRDRAG_SHEAR || eDragMode==SDRDRAG_DISTORT)
 319                             {
 320                                 if (!IsDistortAllowed(TRUE) && !IsDistortAllowed(FALSE)) return FALSE;
 321                                 mpCurrentSdrDragMethod = new SdrDragDistort(*this);
 322                             }
 323                             else
 324                             {
 325                                 if (!IsRotateAllowed(TRUE)) return FALSE;
 326                                 mpCurrentSdrDragMethod = new SdrDragRotate(*this);
 327                             }
 328                         } break;
 329                         default:
 330                         {
 331                             if (IsMarkedHitMovesAlways() && eDragHdl==HDL_MOVE)
 332                             { // HDL_MOVE ist auch wenn Obj direkt getroffen
 333                                 if (!IsMoveAllowed()) return FALSE;
 334                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
 335                             }
 336                             else
 337                             {
 338                                 if (!IsRotateAllowed(TRUE)) return FALSE;
 339                                 mpCurrentSdrDragMethod = new SdrDragRotate(*this);
 340                             }
 341                         }
 342                     }
 343                 } break;
 344                 case SDRDRAG_MIRROR:
 345                 {
 346                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 347                     {
 348                         if (!IsMoveAllowed()) return FALSE;
 349                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 350                     }
 351                     else
 352                     {
 353                         if (!IsMirrorAllowed(TRUE,TRUE)) return FALSE;
 354                         mpCurrentSdrDragMethod = new SdrDragMirror(*this);
 355                     }
 356                 } break;
 357
 358                 case SDRDRAG_CROP:
 359                 {
 360                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 361                     {
 362                         if (!IsMoveAllowed())
 363                             return FALSE;
 364                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 365                     }
 366                     else
 367                     {
 368                         if (!IsCrookAllowed(TRUE) && !IsCrookAllowed(FALSE))
 369                             return FALSE;
 370                         mpCurrentSdrDragMethod = new SdrDragCrop(*this);
 371                     }
 372                 }
 373                 break;
 374
 375                 case SDRDRAG_TRANSPARENCE:
 376                 {
 377                     if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
 378                     {
 379                         if(!IsMoveAllowed())
 380                             return FALSE;
 381                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 382                     }
 383                     else
 384                     {
 385                         if(!IsTransparenceAllowed())
 386                             return FALSE;
 387
 388                         mpCurrentSdrDragMethod = new SdrDragGradient(*this, FALSE);
 389                     }
 390                     break;
 391                 }
 392                 case SDRDRAG_GRADIENT:
 393                 {
 394                     if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
 395                     {
 396                         if(!IsMoveAllowed())
 397                             return FALSE;
 398                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 399                     }
 400                     else
 401                     {
 402                         if(!IsGradientAllowed())
 403                             return FALSE;
 404
 405                         mpCurrentSdrDragMethod = new SdrDragGradient(*this);
 406                     }
 407                     break;
 408                 }
 409
 410                 case SDRDRAG_CROOK :
 411                 {
 412                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 413                     {
 414                         if (!IsMoveAllowed()) return FALSE;
 415                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 416                     }
 417                     else
 418                     {
 419                         if (!IsCrookAllowed(TRUE) && !IsCrookAllowed(FALSE)) return FALSE;
 420                         mpCurrentSdrDragMethod = new SdrDragCrook(*this);
 421                     }
 422                 } break;
 423
 424                 default:
 425                 {
 426                     // SDRDRAG_MOVE
 427                     if((eDragHdl == HDL_MOVE) && !IsMoveAllowed())
 428                     {
 429                         return FALSE;
 430                     }
 431                     else if(eDragHdl == HDL_GLUE)
 432                     {
 433                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 434                     }
 435                     else
 436                     {
 437                         if(bFramDrag)
 438                         {
 439                             if(eDragHdl == HDL_MOVE)
 440                             {
 441                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
 442                             }
 443                             else
 444                             {
 445                                 if(!IsResizeAllowed(TRUE))
 446                                 {
 447                                     return FALSE;
 448                                 }
 449
 450                                 sal_Bool bSingleTextObjMark = sal_False;        // SJ: #i100490#
 451                                 if ( GetMarkedObjectCount() == 1 )
 452                                 {
 453                                     pMarkedObj=GetMarkedObjectByIndex(0);
 454                                     if ( pMarkedObj &&
 455                                         pMarkedObj->ISA( SdrTextObj ) &&
 456                                         static_cast<SdrTextObj*>(pMarkedObj)->IsTextFrame() )
 457                                         bSingleTextObjMark = sal_True;
 458                                 }
 459                                 if ( bSingleTextObjMark )
 460                                     mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
 461                                 else
 462                                     mpCurrentSdrDragMethod = new SdrDragResize(*this);
 463                             }
 464                         }
 465                         else
 466                         {
 467                             if(HDL_MOVE == eDragHdl)
 468                             {
 469                                 const bool bCustomShapeSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrObjCustomShape));
 470
 471                                 if(bCustomShapeSelected)
 472                                 {
 473                                     mpCurrentSdrDragMethod = new SdrDragMove( *this );
 474                                 }
 475                             }
 476                             else if(HDL_POLY == eDragHdl)
 477                             {
 478                                 const bool bConnectorSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrEdgeObj));
 479
 480                                 if(bConnectorSelected)
 481                                 {
 482                                     // #i97784#
 483                                     // fallback to old behaviour for connectors (see
 484                                     // text in task description for more details)
 485                                 }
 486                                 else if(!IsMoveAllowed() || !IsResizeAllowed())
 487                                 {
 488                                     // #i77187#
 489                                     // do not allow move of polygon points if object is move or size protected
 490                                     return FALSE;
 491                                 }
 492                             }
 493
 494                             if(!mpCurrentSdrDragMethod)
 495                             {
 496                                 // fallback to DragSpecial if no interaction defined
 497                                 bDragSpecial = TRUE;
 498                                 mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
 499                             }
 500                         }
 501                     }
 502                 }
 503             }
 504         }
 505         if (pForcedMeth!=NULL)
 506         {
 507             delete mpCurrentSdrDragMethod;
 508             mpCurrentSdrDragMethod = pForcedMeth;
 509         }
 510         aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 511         if (mpCurrentSdrDragMethod)
 512         {
 513             bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
 514             if (!bRet)
 515             {
 516                 if (pHdl==NULL && IS_TYPE(SdrDragObjOwn,mpCurrentSdrDragMethod))
 517                 {
 518                     // Aha, Obj kann nicht Move SpecialDrag, also MoveFrameDrag versuchen
 519                     delete mpCurrentSdrDragMethod;
 520                     mpCurrentSdrDragMethod = 0;
 521                     bDragSpecial=FALSE;
 522
 523                     if (!IsMoveAllowed())
 524                         return FALSE;
 525
 526                     bFramDrag=TRUE;
 527                     mpCurrentSdrDragMethod = new SdrDragMove(*this);
 528                     aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 529                     bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
 530                 }
 531             }
 532             if (!bRet)
 533             {
 534                 delete mpCurrentSdrDragMethod;
 535                 mpCurrentSdrDragMethod = 0;
 536                 aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 537             }
 538         }
 539     }
 540
 541     return bRet;
 542 }
 543
 544 void SdrDragView::MovDragObj(const Point& rPnt)
 545 {
 546     if (mpCurrentSdrDragMethod)
 547     {
 548         Point aPnt(rPnt);
 549         ImpLimitToWorkArea(aPnt);
 550         mpCurrentSdrDragMethod->MoveSdrDrag(aPnt); // this call already makes a Hide()/Show combination
 551     }
 552 }
 553
 554 BOOL SdrDragView::EndDragObj(BOOL bCopy)
 555 {
 556     bool bRet(false);
 557
 558     // #i73341# If insert GluePoint, do not insist on last points being different
 559     if(mpCurrentSdrDragMethod && aDragStat.IsMinMoved() && (IsInsertGluePoint() || aDragStat.GetNow() != aDragStat.GetPrev()))
 560     {
 561         ULONG nHdlAnzMerk=0;
 562
 563         if (bEliminatePolyPoints)
 564         { // IBM Special
 565             nHdlAnzMerk=GetMarkablePointCount();
 566         }
 567
 568         const bool bUndo = IsUndoEnabled();
 569         if (IsInsertGluePoint() && bUndo)
 570         {
 571             BegUndo(aInsPointUndoStr);
 572             AddUndo(pInsPointUndo);
 573         }
 574
 575         bRet = mpCurrentSdrDragMethod->EndSdrDrag(bCopy);
 576
 577         if( IsInsertGluePoint() && bUndo)
 578             EndUndo();
 579
 580         delete mpCurrentSdrDragMethod;
 581         mpCurrentSdrDragMethod = 0;
 582
 583         if (bEliminatePolyPoints)
 584         { // IBM Special
 585             if (nHdlAnzMerk!=GetMarkablePointCount())
 586             {
 587                 UnmarkAllPoints();
 588             }
 589         }
 590
 591         if (bInsPolyPoint)
 592         {
 593             SetMarkHandles();
 594             bInsPolyPoint=FALSE;
 595             if( bUndo )
 596             {
 597                 BegUndo(aInsPointUndoStr);
 598                 AddUndo(pInsPointUndo);
 599                 EndUndo();
 600             }
 601         }
 602
 603         eDragHdl=HDL_MOVE;
 604         pDragHdl=NULL;
 605
 606         if (!bSomeObjChgdFlag)
 607         {
 608             // Aha, Obj hat nicht gebroadcastet (z.B. Writer FlyFrames)
 609             if(!bDragHdl)
 610             {
 611                 AdjustMarkHdl();
 612             }
 613         }
 614     }
 615     else
 616     {
 617         BrkDragObj();
 618     }
 619
 620     bInsPolyPoint=FALSE;
 621     SetInsertGluePoint(FALSE);
 622
 623     return bRet;
 624 }
 625
 626 void SdrDragView::BrkDragObj()
 627 {
 628     if (mpCurrentSdrDragMethod)
 629     {
 630         mpCurrentSdrDragMethod->CancelSdrDrag();
 631
 632         delete mpCurrentSdrDragMethod;
 633         mpCurrentSdrDragMethod = 0;
 634
 635         if (bInsPolyPoint)
 636         {
 637             pInsPointUndo->Undo(); // Den eingefuegten Punkt wieder raus
 638             delete pInsPointUndo;
 639             pInsPointUndo=NULL;
 640             SetMarkHandles();
 641             bInsPolyPoint=FALSE;
 642         }
 643
 644         if (IsInsertGluePoint())
 645         {
 646             pInsPointUndo->Undo(); // Den eingefuegten Klebepunkt wieder raus
 647             delete pInsPointUndo;
 648             pInsPointUndo=NULL;
 649             SetInsertGluePoint(FALSE);
 650         }
 651
 652         eDragHdl=HDL_MOVE;
 653         pDragHdl=NULL;
 654     }
 655 }
 656
 657 BOOL SdrDragView::IsInsObjPointPossible() const
 658 {
 659     return pMarkedObj!=NULL && pMarkedObj->IsPolyObj();
 660 }
 661
 662 sal_Bool SdrDragView::ImpBegInsObjPoint(sal_Bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, sal_Bool bNewObj, OutputDevice* pOut)
 663 {
 664     sal_Bool bRet(sal_False);
 665
 666     if(pMarkedObj && pMarkedObj->ISA(SdrPathObj))
 667     {
 668         SdrPathObj* pMarkedPath = (SdrPathObj*)pMarkedObj;
 669         BrkAction();
 670         pInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pMarkedObj) );
 671         DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
 672
 673         XubString aStr(ImpGetResStr(STR_DragInsertPoint));
 674         XubString aName;
 675         pMarkedObj->TakeObjNameSingul(aName);
 676         xub_StrLen nPos(aStr.SearchAscii("%1"));
 677
 678         if(STRING_NOTFOUND != nPos)
 679         {
 680             aStr.Erase(nPos, 2);
 681             aStr.Insert(aName, nPos);
 682         }
 683
 684         aInsPointUndoStr = aStr;
 685         Point aPt(rPnt);
 686
 687         if(bNewObj)
 688             aPt = GetSnapPos(aPt,pMarkedPV);
 689
 690         sal_Bool bClosed0(pMarkedPath->IsClosedObj());
 691
 692         if(bIdxZwang)
 693         {
 694             mnInsPointNum = pMarkedPath->NbcInsPoint(nIdx, aPt, bNewObj, sal_True);
 695         }
 696         else
 697         {
 698             mnInsPointNum = pMarkedPath->NbcInsPointOld(aPt, bNewObj, sal_True);
 699         }
 700
 701         if(bClosed0 != pMarkedPath->IsClosedObj())
 702         {
 703             // Obj was closed implicit
 704             // object changed
 705             pMarkedPath->SetChanged();
 706             pMarkedPath->BroadcastObjectChange();
 707         }
 708
 709         if(0xffffffff != mnInsPointNum)
 710         {
 711             bInsPolyPoint = sal_True;
 712             UnmarkAllPoints();
 713             AdjustMarkHdl();
 714
 715             bRet = BegDragObj(rPnt, pOut, aHdl.GetHdl(mnInsPointNum), 0);
 716
 717             if (bRet)
 718             {
 719                 aDragStat.SetMinMoved();
 720                 MovDragObj(rPnt);
 721             }
 722         }
 723         else
 724         {
 725             delete pInsPointUndo;
 726             pInsPointUndo = NULL;
 727         }
 728     }
 729
 730     return bRet;
 731 }
 732
 733 BOOL SdrDragView::EndInsObjPoint(SdrCreateCmd eCmd)
 734 {
 735     if(IsInsObjPoint())
 736     {
 737         sal_uInt32 nNextPnt(mnInsPointNum);
 738         Point aPnt(aDragStat.GetNow());
 739         BOOL bOk=EndDragObj(FALSE);
 740         if (bOk==TRUE && eCmd!=SDRCREATE_FORCEEND)
 741         {
 742             // Ret=True bedeutet: Action ist vorbei.
 743             bOk=!(ImpBegInsObjPoint(sal_True, nNextPnt, aPnt, eCmd == SDRCREATE_NEXTOBJECT, pDragWin));
 744         }
 745
 746         return bOk;
 747     } else return FALSE;
 748 }
 749
 750 BOOL SdrDragView::IsInsGluePointPossible() const
 751 {
 752     BOOL bRet=FALSE;
 753     if (IsInsGluePointMode() && AreObjectsMarked())
 754     {
 755         if (GetMarkedObjectCount()==1)
 756         {
 757             // FALSE liefern, wenn 1 Objekt und dieses ein Verbinder ist.
 758             const SdrObject* pObj=GetMarkedObjectByIndex(0);
 759             if (!HAS_BASE(SdrEdgeObj,pObj))
 760             {
 761                bRet=TRUE;
 762             }
 763         }
 764         else
 765         {
 766             bRet=TRUE;
 767         }
 768     }
 769     return bRet;
 770 }
 771
 772 BOOL SdrDragView::BegInsGluePoint(const Point& rPnt)
 773 {
 774     BOOL bRet=FALSE;
 775     SdrObject* pObj;
 776     SdrPageView* pPV;
 777     ULONG nMarkNum;
 778     if (PickMarkedObj(rPnt,pObj,pPV,&nMarkNum,SDRSEARCH_PASS2BOUND))
 779     {
 780         BrkAction();
 781         UnmarkAllGluePoints();
 782         pInsPointUndo= dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
 783         DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
 784         XubString aStr(ImpGetResStr(STR_DragInsertGluePoint));
 785         XubString aName; pObj->TakeObjNameSingul(aName);
 786
 787         aStr.SearchAndReplaceAscii("%1", aName);
 788
 789         aInsPointUndoStr=aStr;
 790         SdrGluePointList* pGPL=pObj->ForceGluePointList();
 791         if (pGPL!=NULL)
 792         {
 793             USHORT nGlueIdx=pGPL->Insert(SdrGluePoint());
 794             SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
 795             USHORT nGlueId=rGP.GetId();
 796             rGP.SetAbsolutePos(rPnt,*pObj);
 797
 798             SdrHdl* pHdl=NULL;
 799             if (MarkGluePoint(pObj,nGlueId,pPV))
 800             {
 801                 pHdl=GetGluePointHdl(pObj,nGlueId);
 802             }
 803             if (pHdl!=NULL && pHdl->GetKind()==HDL_GLUE && pHdl->GetObj()==pObj && pHdl->GetObjHdlNum()==nGlueId)
 804             {
 805                 SetInsertGluePoint(TRUE);
 806                 bRet=BegDragObj(rPnt,NULL,pHdl,0);
 807                 if (bRet)
 808                 {
 809                     aDragStat.SetMinMoved();
 810                     MovDragObj(rPnt);
 811                 }
 812                 else
 813                 {
 814                     SetInsertGluePoint(FALSE);
 815                     delete pInsPointUndo;
 816                     pInsPointUndo=NULL;
 817                 }
 818             }
 819             else
 820             {
 821                 DBG_ERROR("BegInsGluePoint(): GluePoint-Handle nicht gefunden");
 822             }
 823         }
 824         else
 825         {
 826             // Keine Klebepunkte moeglich bei diesem Objekt (z.B. Edge)
 827             SetInsertGluePoint(FALSE);
 828             delete pInsPointUndo;
 829             pInsPointUndo=NULL;
 830         }
 831     }
 832
 833     return bRet;
 834 }
 835
 836 void SdrDragView::ShowDragObj()
 837 {
 838     if(mpCurrentSdrDragMethod && !aDragStat.IsShown())
 839     {
 840         for(sal_uInt32 a(0); a < PaintWindowCount(); a++)
 841         {
 842             SdrPaintWindow* pCandidate = GetPaintWindow(a);
 843             sdr::overlay::OverlayManager* pOverlayManager = pCandidate->GetOverlayManager();
 844
 845             if(pOverlayManager)
 846             {
 847                 mpCurrentSdrDragMethod->CreateOverlayGeometry(*pOverlayManager);
 848
 849                 // #i101679# Force changed overlay to be shown
 850                 pOverlayManager->flush();
 851             }
 852         }
 853
 854         aDragStat.SetShown(TRUE);
 855     }
 856 }
 857
 858 void SdrDragView::HideDragObj()
 859 {
 860     if(mpCurrentSdrDragMethod && aDragStat.IsShown())
 861     {
 862         mpCurrentSdrDragMethod->destroyOverlayGeometry();
 863         aDragStat.SetShown(FALSE);
 864     }
 865 }
 866
 867 ////////////////////////////////////////////////////////////////////////////////////////////////////
 868
 869 void SdrDragView::SetNoDragXorPolys(BOOL bOn)
 870 {
 871     if (IsNoDragXorPolys()!=bOn)
 872     {
 873         const bool bDragging(mpCurrentSdrDragMethod);
 874         const bool bShown(bDragging && aDragStat.IsShown());
 875
 876         if(bShown)
 877         {
 878             HideDragObj();
 879         }
 880
 881         bNoDragXorPolys = bOn;
 882
 883         if(bDragging)
 884         {
 885             // force recreation of drag content
 886             mpCurrentSdrDragMethod->resetSdrDragEntries();
 887         }
 888
 889         if(bShown)
 890         {
 891             ShowDragObj();
 892         }
 893     }
 894 }
 895
 896 void SdrDragView::SetDragStripes(BOOL bOn)
 897 {
 898     if (mpCurrentSdrDragMethod && aDragStat.IsShown())
 899     {
 900         HideDragObj();
 901         bDragStripes=bOn;
 902         ShowDragObj();
 903     }
 904     else
 905     {
 906         bDragStripes=bOn;
 907     }
 908 }
 909
 910 BOOL SdrDragView::IsOrthoDesired() const
 911 {
 912     if(mpCurrentSdrDragMethod && (IS_TYPE(SdrDragObjOwn, mpCurrentSdrDragMethod) || IS_TYPE(SdrDragResize, mpCurrentSdrDragMethod)))
 913     {
 914         return bOrthoDesiredOnMarked;
 915     }
 916
 917     return FALSE;
 918 }
 919
 920 ////////////////////////////////////////////////////////////////////////////////////////////////////
 921
 922 void SdrDragView::SetRubberEdgeDragging(BOOL bOn)
 923 {
 924     if (bOn!=IsRubberEdgeDragging())
 925     {
 926         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 927         BOOL bShowHide=nAnz!=0 && IsDragObj() &&
 928                  (nRubberEdgeDraggingLimit>=nAnz);
 929         if (bShowHide)
 930             HideDragObj();
 931         bRubberEdgeDragging=bOn;
 932         if (bShowHide)
 933             ShowDragObj();
 934     }
 935 }
 936
 937 void SdrDragView::SetRubberEdgeDraggingLimit(USHORT nEdgeObjAnz)
 938 {
 939     if (nEdgeObjAnz!=nRubberEdgeDraggingLimit)
 940     {
 941         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 942         BOOL bShowHide=IsRubberEdgeDragging() && nAnz!=0 && IsDragObj() &&
 943                  (nEdgeObjAnz>=nAnz)!=(nRubberEdgeDraggingLimit>=nAnz);
 944         if (bShowHide)
 945             HideDragObj();
 946         nRubberEdgeDraggingLimit=nEdgeObjAnz;
 947         if (bShowHide)
 948             ShowDragObj();
 949     }
 950 }
 951
 952 void SdrDragView::SetDetailedEdgeDragging(BOOL bOn)
 953 {
 954     if (bOn!=IsDetailedEdgeDragging())
 955     {
 956         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 957         BOOL bShowHide=nAnz!=0 && IsDragObj() &&
 958                  (nDetailedEdgeDraggingLimit>=nAnz);
 959         if (bShowHide)
 960             HideDragObj();
 961         bDetailedEdgeDragging=bOn;
 962         if (bShowHide)
 963             ShowDragObj();
 964     }
 965 }
 966
 967 void SdrDragView::SetDetailedEdgeDraggingLimit(USHORT nEdgeObjAnz)
 968 {
 969     if (nEdgeObjAnz!=nDetailedEdgeDraggingLimit)
 970     {
 971         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 972         BOOL bShowHide=IsDetailedEdgeDragging() && nAnz!=0 && IsDragObj() &&
 973                  (nEdgeObjAnz>=nAnz)!=(nDetailedEdgeDraggingLimit>=nAnz);
 974         if (bShowHide)
 975             HideDragObj();
 976         nDetailedEdgeDraggingLimit=nEdgeObjAnz;
 977         if (bShowHide)
 978             ShowDragObj();
 979     }
 980 }
 981
 982 void SdrDragView::SetMarkHandles()
 983 {
 984     if( pDragHdl )
 985         pDragHdl = 0;
 986
 987     SdrExchangeView::SetMarkHandles();
 988 }
 989
 990 void SdrDragView::SetSolidDragging(bool bOn)
 991 {
 992     if((bool)mbSolidDragging != bOn)
 993     {
 994         mbSolidDragging = bOn;
 995     }
 996 }
 997
 998 bool SdrDragView::IsSolidDragging() const
 999 {
1000     // allow each user to disable by having a local setting, but using AND for
1001     // checking allowance
1002     return mbSolidDragging && getOptionsDrawinglayer().IsSolidDragCreate();
1003 }
1004
1005 // eof