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