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(pHdl && (pHdl->GetKind() == HDL_SMARTTAG) && pForcedMeth )
 286         {
 287             // just use the forced method for smart tags
 288         }
 289         else if(bDragHdl)
 290         {
 291             mpCurrentSdrDragMethod = new SdrDragMovHdl(*this);
 292         }
 293         else if(!bNotDraggable)
 294         {
 295             switch (eDragMode)
 296             {
 297                 case SDRDRAG_ROTATE: case SDRDRAG_SHEAR: case SDRDRAG_DISTORT:
 298                 {
 299                     switch (eDragHdl)
 300                     {
 301                         case HDL_LEFT:  case HDL_RIGHT:
 302                         case HDL_UPPER: case HDL_LOWER:
 303                         {
 304                             // Sind 3D-Objekte selektiert?
 305                             BOOL b3DObjSelected = FALSE;
 306                             for(UINT32 a=0;!b3DObjSelected && a<GetMarkedObjectCount();a++)
 307                             {
 308                                 SdrObject* pObj = GetMarkedObjectByIndex(a);
 309                                 if(pObj && pObj->ISA(E3dObject))
 310                                     b3DObjSelected = TRUE;
 311                             }
 312                             // Falls ja, Shear auch bei !IsShearAllowed zulassen,
 313                             // da es sich bei 3D-Objekten um eingeschraenkte
 314                             // Rotationen handelt
 315                             if (!b3DObjSelected && !IsShearAllowed())
 316                                 return FALSE;
 317                             mpCurrentSdrDragMethod = new SdrDragShear(*this,eDragMode==SDRDRAG_ROTATE);
 318                         } break;
 319                         case HDL_UPLFT: case HDL_UPRGT:
 320                         case HDL_LWLFT: case HDL_LWRGT:
 321                         {
 322                             if (eDragMode==SDRDRAG_SHEAR || eDragMode==SDRDRAG_DISTORT)
 323                             {
 324                                 if (!IsDistortAllowed(TRUE) && !IsDistortAllowed(FALSE)) return FALSE;
 325                                 mpCurrentSdrDragMethod = new SdrDragDistort(*this);
 326                             }
 327                             else
 328                             {
 329                                 if (!IsRotateAllowed(TRUE)) return FALSE;
 330                                 mpCurrentSdrDragMethod = new SdrDragRotate(*this);
 331                             }
 332                         } break;
 333                         default:
 334                         {
 335                             if (IsMarkedHitMovesAlways() && eDragHdl==HDL_MOVE)
 336                             { // HDL_MOVE ist auch wenn Obj direkt getroffen
 337                                 if (!IsMoveAllowed()) return FALSE;
 338                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
 339                             }
 340                             else
 341                             {
 342                                 if (!IsRotateAllowed(TRUE)) return FALSE;
 343                                 mpCurrentSdrDragMethod = new SdrDragRotate(*this);
 344                             }
 345                         }
 346                     }
 347                 } break;
 348                 case SDRDRAG_MIRROR:
 349                 {
 350                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 351                     {
 352                         if (!IsMoveAllowed()) return FALSE;
 353                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 354                     }
 355                     else
 356                     {
 357                         if (!IsMirrorAllowed(TRUE,TRUE)) return FALSE;
 358                         mpCurrentSdrDragMethod = new SdrDragMirror(*this);
 359                     }
 360                 } break;
 361
 362                 case SDRDRAG_CROP:
 363                 {
 364                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 365                     {
 366                         if (!IsMoveAllowed())
 367                             return FALSE;
 368                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 369                     }
 370                     else
 371                     {
 372                         if (!IsCrookAllowed(TRUE) && !IsCrookAllowed(FALSE))
 373                             return FALSE;
 374                         mpCurrentSdrDragMethod = new SdrDragCrop(*this);
 375                     }
 376                 }
 377                 break;
 378
 379                 case SDRDRAG_TRANSPARENCE:
 380                 {
 381                     if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
 382                     {
 383                         if(!IsMoveAllowed())
 384                             return FALSE;
 385                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 386                     }
 387                     else
 388                     {
 389                         if(!IsTransparenceAllowed())
 390                             return FALSE;
 391
 392                         mpCurrentSdrDragMethod = new SdrDragGradient(*this, FALSE);
 393                     }
 394                     break;
 395                 }
 396                 case SDRDRAG_GRADIENT:
 397                 {
 398                     if(eDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
 399                     {
 400                         if(!IsMoveAllowed())
 401                             return FALSE;
 402                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 403                     }
 404                     else
 405                     {
 406                         if(!IsGradientAllowed())
 407                             return FALSE;
 408
 409                         mpCurrentSdrDragMethod = new SdrDragGradient(*this);
 410                     }
 411                     break;
 412                 }
 413
 414                 case SDRDRAG_CROOK :
 415                 {
 416                     if (eDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
 417                     {
 418                         if (!IsMoveAllowed()) return FALSE;
 419                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 420                     }
 421                     else
 422                     {
 423                         if (!IsCrookAllowed(TRUE) && !IsCrookAllowed(FALSE)) return FALSE;
 424                         mpCurrentSdrDragMethod = new SdrDragCrook(*this);
 425                     }
 426                 } break;
 427
 428                 default:
 429                 {
 430                     // SDRDRAG_MOVE
 431                     if((eDragHdl == HDL_MOVE) && !IsMoveAllowed())
 432                     {
 433                         return FALSE;
 434                     }
 435                     else if(eDragHdl == HDL_GLUE)
 436                     {
 437                         mpCurrentSdrDragMethod = new SdrDragMove(*this);
 438                     }
 439                     else
 440                     {
 441                         if(bFramDrag)
 442                         {
 443                             if(eDragHdl == HDL_MOVE)
 444                             {
 445                                 mpCurrentSdrDragMethod = new SdrDragMove(*this);
 446                             }
 447                             else
 448                             {
 449                                 if(!IsResizeAllowed(TRUE))
 450                                 {
 451                                     return FALSE;
 452                                 }
 453
 454                                 sal_Bool bSingleTextObjMark = sal_False;        // SJ: #i100490#
 455                                 if ( GetMarkedObjectCount() == 1 )
 456                                 {
 457                                     pMarkedObj=GetMarkedObjectByIndex(0);
 458                                     if ( pMarkedObj &&
 459                                         pMarkedObj->ISA( SdrTextObj ) &&
 460                                         static_cast<SdrTextObj*>(pMarkedObj)->IsTextFrame() )
 461                                         bSingleTextObjMark = sal_True;
 462                                 }
 463                                 if ( bSingleTextObjMark )
 464                                     mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
 465                                 else
 466                                     mpCurrentSdrDragMethod = new SdrDragResize(*this);
 467                             }
 468                         }
 469                         else
 470                         {
 471                             if(HDL_MOVE == eDragHdl)
 472                             {
 473                                 const bool bCustomShapeSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrObjCustomShape));
 474
 475                                 if(bCustomShapeSelected)
 476                                 {
 477                                     mpCurrentSdrDragMethod = new SdrDragMove( *this );
 478                                 }
 479                             }
 480                             else if(HDL_POLY == eDragHdl)
 481                             {
 482                                 const bool bConnectorSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrEdgeObj));
 483
 484                                 if(bConnectorSelected)
 485                                 {
 486                                     // #i97784#
 487                                     // fallback to old behaviour for connectors (see
 488                                     // text in task description for more details)
 489                                 }
 490                                 else if(!IsMoveAllowed() || !IsResizeAllowed())
 491                                 {
 492                                     // #i77187#
 493                                     // do not allow move of polygon points if object is move or size protected
 494                                     return FALSE;
 495                                 }
 496                             }
 497
 498                             if(!mpCurrentSdrDragMethod)
 499                             {
 500                                 // fallback to DragSpecial if no interaction defined
 501                                 bDragSpecial = TRUE;
 502                                 mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
 503                             }
 504                         }
 505                     }
 506                 }
 507             }
 508         }
 509         if (pForcedMeth!=NULL)
 510         {
 511             delete mpCurrentSdrDragMethod;
 512             mpCurrentSdrDragMethod = pForcedMeth;
 513         }
 514         aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 515         if (mpCurrentSdrDragMethod)
 516         {
 517             bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
 518             if (!bRet)
 519             {
 520                 if (pHdl==NULL && IS_TYPE(SdrDragObjOwn,mpCurrentSdrDragMethod))
 521                 {
 522                     // Aha, Obj kann nicht Move SpecialDrag, also MoveFrameDrag versuchen
 523                     delete mpCurrentSdrDragMethod;
 524                     mpCurrentSdrDragMethod = 0;
 525                     bDragSpecial=FALSE;
 526
 527                     if (!IsMoveAllowed())
 528                         return FALSE;
 529
 530                     bFramDrag=TRUE;
 531                     mpCurrentSdrDragMethod = new SdrDragMove(*this);
 532                     aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 533                     bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
 534                 }
 535             }
 536             if (!bRet)
 537             {
 538                 delete mpCurrentSdrDragMethod;
 539                 mpCurrentSdrDragMethod = 0;
 540                 aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
 541             }
 542         }
 543     }
 544
 545     return bRet;
 546 }
 547
 548 void SdrDragView::MovDragObj(const Point& rPnt)
 549 {
 550     if (mpCurrentSdrDragMethod)
 551     {
 552         Point aPnt(rPnt);
 553         ImpLimitToWorkArea(aPnt);
 554         mpCurrentSdrDragMethod->MoveSdrDrag(aPnt); // this call already makes a Hide()/Show combination
 555     }
 556 }
 557
 558 BOOL SdrDragView::EndDragObj(BOOL bCopy)
 559 {
 560     bool bRet(false);
 561
 562     // #i73341# If insert GluePoint, do not insist on last points being different
 563     if(mpCurrentSdrDragMethod && aDragStat.IsMinMoved() && (IsInsertGluePoint() || aDragStat.GetNow() != aDragStat.GetPrev()))
 564     {
 565         ULONG nHdlAnzMerk=0;
 566
 567         if (bEliminatePolyPoints)
 568         { // IBM Special
 569             nHdlAnzMerk=GetMarkablePointCount();
 570         }
 571
 572         const bool bUndo = IsUndoEnabled();
 573         if (IsInsertGluePoint() && bUndo)
 574         {
 575             BegUndo(aInsPointUndoStr);
 576             AddUndo(pInsPointUndo);
 577         }
 578
 579         bRet = mpCurrentSdrDragMethod->EndSdrDrag(bCopy);
 580
 581         if( IsInsertGluePoint() && bUndo)
 582             EndUndo();
 583
 584         delete mpCurrentSdrDragMethod;
 585         mpCurrentSdrDragMethod = 0;
 586
 587         if (bEliminatePolyPoints)
 588         { // IBM Special
 589             if (nHdlAnzMerk!=GetMarkablePointCount())
 590             {
 591                 UnmarkAllPoints();
 592             }
 593         }
 594
 595         if (bInsPolyPoint)
 596         {
 597             SetMarkHandles();
 598             bInsPolyPoint=FALSE;
 599             if( bUndo )
 600             {
 601                 BegUndo(aInsPointUndoStr);
 602                 AddUndo(pInsPointUndo);
 603                 EndUndo();
 604             }
 605         }
 606
 607         eDragHdl=HDL_MOVE;
 608         pDragHdl=NULL;
 609
 610         if (!bSomeObjChgdFlag)
 611         {
 612             // Aha, Obj hat nicht gebroadcastet (z.B. Writer FlyFrames)
 613             if(!bDragHdl)
 614             {
 615                 AdjustMarkHdl();
 616             }
 617         }
 618     }
 619     else
 620     {
 621         BrkDragObj();
 622     }
 623
 624     bInsPolyPoint=FALSE;
 625     SetInsertGluePoint(FALSE);
 626
 627     return bRet;
 628 }
 629
 630 void SdrDragView::BrkDragObj()
 631 {
 632     if (mpCurrentSdrDragMethod)
 633     {
 634         mpCurrentSdrDragMethod->CancelSdrDrag();
 635
 636         delete mpCurrentSdrDragMethod;
 637         mpCurrentSdrDragMethod = 0;
 638
 639         if (bInsPolyPoint)
 640         {
 641             pInsPointUndo->Undo(); // Den eingefuegten Punkt wieder raus
 642             delete pInsPointUndo;
 643             pInsPointUndo=NULL;
 644             SetMarkHandles();
 645             bInsPolyPoint=FALSE;
 646         }
 647
 648         if (IsInsertGluePoint())
 649         {
 650             pInsPointUndo->Undo(); // Den eingefuegten Klebepunkt wieder raus
 651             delete pInsPointUndo;
 652             pInsPointUndo=NULL;
 653             SetInsertGluePoint(FALSE);
 654         }
 655
 656         eDragHdl=HDL_MOVE;
 657         pDragHdl=NULL;
 658     }
 659 }
 660
 661 BOOL SdrDragView::IsInsObjPointPossible() const
 662 {
 663     return pMarkedObj!=NULL && pMarkedObj->IsPolyObj();
 664 }
 665
 666 sal_Bool SdrDragView::ImpBegInsObjPoint(sal_Bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, sal_Bool bNewObj, OutputDevice* pOut)
 667 {
 668     sal_Bool bRet(sal_False);
 669
 670     if(pMarkedObj && pMarkedObj->ISA(SdrPathObj))
 671     {
 672         SdrPathObj* pMarkedPath = (SdrPathObj*)pMarkedObj;
 673         BrkAction();
 674         pInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pMarkedObj) );
 675         DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
 676
 677         XubString aStr(ImpGetResStr(STR_DragInsertPoint));
 678         XubString aName;
 679         pMarkedObj->TakeObjNameSingul(aName);
 680         xub_StrLen nPos(aStr.SearchAscii("%1"));
 681
 682         if(STRING_NOTFOUND != nPos)
 683         {
 684             aStr.Erase(nPos, 2);
 685             aStr.Insert(aName, nPos);
 686         }
 687
 688         aInsPointUndoStr = aStr;
 689         Point aPt(rPnt);
 690
 691         if(bNewObj)
 692             aPt = GetSnapPos(aPt,pMarkedPV);
 693
 694         sal_Bool bClosed0(pMarkedPath->IsClosedObj());
 695
 696         if(bIdxZwang)
 697         {
 698             mnInsPointNum = pMarkedPath->NbcInsPoint(nIdx, aPt, bNewObj, sal_True);
 699         }
 700         else
 701         {
 702             mnInsPointNum = pMarkedPath->NbcInsPointOld(aPt, bNewObj, sal_True);
 703         }
 704
 705         if(bClosed0 != pMarkedPath->IsClosedObj())
 706         {
 707             // Obj was closed implicit
 708             // object changed
 709             pMarkedPath->SetChanged();
 710             pMarkedPath->BroadcastObjectChange();
 711         }
 712
 713         if(0xffffffff != mnInsPointNum)
 714         {
 715             bInsPolyPoint = sal_True;
 716             UnmarkAllPoints();
 717             AdjustMarkHdl();
 718
 719             bRet = BegDragObj(rPnt, pOut, aHdl.GetHdl(mnInsPointNum), 0);
 720
 721             if (bRet)
 722             {
 723                 aDragStat.SetMinMoved();
 724                 MovDragObj(rPnt);
 725             }
 726         }
 727         else
 728         {
 729             delete pInsPointUndo;
 730             pInsPointUndo = NULL;
 731         }
 732     }
 733
 734     return bRet;
 735 }
 736
 737 BOOL SdrDragView::EndInsObjPoint(SdrCreateCmd eCmd)
 738 {
 739     if(IsInsObjPoint())
 740     {
 741         sal_uInt32 nNextPnt(mnInsPointNum);
 742         Point aPnt(aDragStat.GetNow());
 743         BOOL bOk=EndDragObj(FALSE);
 744         if (bOk==TRUE && eCmd!=SDRCREATE_FORCEEND)
 745         {
 746             // Ret=True bedeutet: Action ist vorbei.
 747             bOk=!(ImpBegInsObjPoint(sal_True, nNextPnt, aPnt, eCmd == SDRCREATE_NEXTOBJECT, pDragWin));
 748         }
 749
 750         return bOk;
 751     } else return FALSE;
 752 }
 753
 754 BOOL SdrDragView::IsInsGluePointPossible() const
 755 {
 756     BOOL bRet=FALSE;
 757     if (IsInsGluePointMode() && AreObjectsMarked())
 758     {
 759         if (GetMarkedObjectCount()==1)
 760         {
 761             // FALSE liefern, wenn 1 Objekt und dieses ein Verbinder ist.
 762             const SdrObject* pObj=GetMarkedObjectByIndex(0);
 763             if (!HAS_BASE(SdrEdgeObj,pObj))
 764             {
 765                bRet=TRUE;
 766             }
 767         }
 768         else
 769         {
 770             bRet=TRUE;
 771         }
 772     }
 773     return bRet;
 774 }
 775
 776 BOOL SdrDragView::BegInsGluePoint(const Point& rPnt)
 777 {
 778     BOOL bRet=FALSE;
 779     SdrObject* pObj;
 780     SdrPageView* pPV;
 781     ULONG nMarkNum;
 782     if (PickMarkedObj(rPnt,pObj,pPV,&nMarkNum,SDRSEARCH_PASS2BOUND))
 783     {
 784         BrkAction();
 785         UnmarkAllGluePoints();
 786         pInsPointUndo= dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
 787         DBG_ASSERT( pInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
 788         XubString aStr(ImpGetResStr(STR_DragInsertGluePoint));
 789         XubString aName; pObj->TakeObjNameSingul(aName);
 790
 791         aStr.SearchAndReplaceAscii("%1", aName);
 792
 793         aInsPointUndoStr=aStr;
 794         SdrGluePointList* pGPL=pObj->ForceGluePointList();
 795         if (pGPL!=NULL)
 796         {
 797             USHORT nGlueIdx=pGPL->Insert(SdrGluePoint());
 798             SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
 799             USHORT nGlueId=rGP.GetId();
 800             rGP.SetAbsolutePos(rPnt,*pObj);
 801
 802             SdrHdl* pHdl=NULL;
 803             if (MarkGluePoint(pObj,nGlueId,pPV))
 804             {
 805                 pHdl=GetGluePointHdl(pObj,nGlueId);
 806             }
 807             if (pHdl!=NULL && pHdl->GetKind()==HDL_GLUE && pHdl->GetObj()==pObj && pHdl->GetObjHdlNum()==nGlueId)
 808             {
 809                 SetInsertGluePoint(TRUE);
 810                 bRet=BegDragObj(rPnt,NULL,pHdl,0);
 811                 if (bRet)
 812                 {
 813                     aDragStat.SetMinMoved();
 814                     MovDragObj(rPnt);
 815                 }
 816                 else
 817                 {
 818                     SetInsertGluePoint(FALSE);
 819                     delete pInsPointUndo;
 820                     pInsPointUndo=NULL;
 821                 }
 822             }
 823             else
 824             {
 825                 DBG_ERROR("BegInsGluePoint(): GluePoint-Handle nicht gefunden");
 826             }
 827         }
 828         else
 829         {
 830             // Keine Klebepunkte moeglich bei diesem Objekt (z.B. Edge)
 831             SetInsertGluePoint(FALSE);
 832             delete pInsPointUndo;
 833             pInsPointUndo=NULL;
 834         }
 835     }
 836
 837     return bRet;
 838 }
 839
 840 void SdrDragView::ShowDragObj()
 841 {
 842     if(mpCurrentSdrDragMethod && !aDragStat.IsShown())
 843     {
 844         for(sal_uInt32 a(0); a < PaintWindowCount(); a++)
 845         {
 846             SdrPaintWindow* pCandidate = GetPaintWindow(a);
 847             sdr::overlay::OverlayManager* pOverlayManager = pCandidate->GetOverlayManager();
 848
 849             if(pOverlayManager)
 850             {
 851                 mpCurrentSdrDragMethod->CreateOverlayGeometry(*pOverlayManager);
 852
 853                 // #i101679# Force changed overlay to be shown
 854                 pOverlayManager->flush();
 855             }
 856         }
 857
 858         aDragStat.SetShown(TRUE);
 859     }
 860 }
 861
 862 void SdrDragView::HideDragObj()
 863 {
 864     if(mpCurrentSdrDragMethod && aDragStat.IsShown())
 865     {
 866         mpCurrentSdrDragMethod->destroyOverlayGeometry();
 867         aDragStat.SetShown(FALSE);
 868     }
 869 }
 870
 871 ////////////////////////////////////////////////////////////////////////////////////////////////////
 872
 873 void SdrDragView::SetNoDragXorPolys(BOOL bOn)
 874 {
 875     if (IsNoDragXorPolys()!=bOn)
 876     {
 877         const bool bDragging(mpCurrentSdrDragMethod);
 878         const bool bShown(bDragging && aDragStat.IsShown());
 879
 880         if(bShown)
 881         {
 882             HideDragObj();
 883         }
 884
 885         bNoDragXorPolys = bOn;
 886
 887         if(bDragging)
 888         {
 889             // force recreation of drag content
 890             mpCurrentSdrDragMethod->resetSdrDragEntries();
 891         }
 892
 893         if(bShown)
 894         {
 895             ShowDragObj();
 896         }
 897     }
 898 }
 899
 900 void SdrDragView::SetDragStripes(BOOL bOn)
 901 {
 902     if (mpCurrentSdrDragMethod && aDragStat.IsShown())
 903     {
 904         HideDragObj();
 905         bDragStripes=bOn;
 906         ShowDragObj();
 907     }
 908     else
 909     {
 910         bDragStripes=bOn;
 911     }
 912 }
 913
 914 BOOL SdrDragView::IsOrthoDesired() const
 915 {
 916     if(mpCurrentSdrDragMethod && (IS_TYPE(SdrDragObjOwn, mpCurrentSdrDragMethod) || IS_TYPE(SdrDragResize, mpCurrentSdrDragMethod)))
 917     {
 918         return bOrthoDesiredOnMarked;
 919     }
 920
 921     return FALSE;
 922 }
 923
 924 ////////////////////////////////////////////////////////////////////////////////////////////////////
 925
 926 void SdrDragView::SetRubberEdgeDragging(BOOL bOn)
 927 {
 928     if (bOn!=IsRubberEdgeDragging())
 929     {
 930         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 931         BOOL bShowHide=nAnz!=0 && IsDragObj() &&
 932                  (nRubberEdgeDraggingLimit>=nAnz);
 933         if (bShowHide)
 934             HideDragObj();
 935         bRubberEdgeDragging=bOn;
 936         if (bShowHide)
 937             ShowDragObj();
 938     }
 939 }
 940
 941 void SdrDragView::SetRubberEdgeDraggingLimit(USHORT nEdgeObjAnz)
 942 {
 943     if (nEdgeObjAnz!=nRubberEdgeDraggingLimit)
 944     {
 945         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 946         BOOL bShowHide=IsRubberEdgeDragging() && nAnz!=0 && IsDragObj() &&
 947                  (nEdgeObjAnz>=nAnz)!=(nRubberEdgeDraggingLimit>=nAnz);
 948         if (bShowHide)
 949             HideDragObj();
 950         nRubberEdgeDraggingLimit=nEdgeObjAnz;
 951         if (bShowHide)
 952             ShowDragObj();
 953     }
 954 }
 955
 956 void SdrDragView::SetDetailedEdgeDragging(BOOL bOn)
 957 {
 958     if (bOn!=IsDetailedEdgeDragging())
 959     {
 960         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 961         BOOL bShowHide=nAnz!=0 && IsDragObj() &&
 962                  (nDetailedEdgeDraggingLimit>=nAnz);
 963         if (bShowHide)
 964             HideDragObj();
 965         bDetailedEdgeDragging=bOn;
 966         if (bShowHide)
 967             ShowDragObj();
 968     }
 969 }
 970
 971 void SdrDragView::SetDetailedEdgeDraggingLimit(USHORT nEdgeObjAnz)
 972 {
 973     if (nEdgeObjAnz!=nDetailedEdgeDraggingLimit)
 974     {
 975         ULONG nAnz = GetEdgesOfMarkedNodes().GetMarkCount();
 976         BOOL bShowHide=IsDetailedEdgeDragging() && nAnz!=0 && IsDragObj() &&
 977                  (nEdgeObjAnz>=nAnz)!=(nDetailedEdgeDraggingLimit>=nAnz);
 978         if (bShowHide)
 979             HideDragObj();
 980         nDetailedEdgeDraggingLimit=nEdgeObjAnz;
 981         if (bShowHide)
 982             ShowDragObj();
 983     }
 984 }
 985
 986 void SdrDragView::SetMarkHandles()
 987 {
 988     if( pDragHdl )
 989         pDragHdl = 0;
 990
 991     SdrExchangeView::SetMarkHandles();
 992 }
 993
 994 void SdrDragView::SetSolidDragging(bool bOn)
 995 {
 996     if((bool)mbSolidDragging != bOn)
 997     {
 998         mbSolidDragging = bOn;
 999     }
1000 }
1001
1002 bool SdrDragView::IsSolidDragging() const
1003 {
1004     // allow each user to disable by having a local setting, but using AND for
1005     // checking allowance
1006     return mbSolidDragging && getOptionsDrawinglayer().IsSolidDragCreate();
1007 }
1008
1009 // eof