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