svx/source/svdraw/svdcrtv.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/svdcrtv.hxx>
  22 #include <svx/xlnclit.hxx>
  23 #include <svx/svdocapt.hxx>
  24 #include <svx/svdoedge.hxx>
  25 #include <svx/svdpagv.hxx>
  26 #include <svx/svdpage.hxx>
  27 #include <svx/scene3d.hxx>
  28 #include <svx/view3d.hxx>
  29 #include <svx/xfillit0.hxx>
  30 #include <svx/xflclit.hxx>
  31 #include <svx/xlineit0.hxx>
  32 #include <svx/svdouno.hxx>
  33 #include <svx/svdopath.hxx>
  34 #include <svx/sdr/overlay/overlaypolypolygon.hxx>
  35 #include <svx/sdr/overlay/overlaymanager.hxx>
  36 #include <svx/sdrpaintwindow.hxx>
  37 #include <fmobj.hxx>
  38 #include <svx/svdocirc.hxx>
  39 #include <svx/sdr/contact/viewcontact.hxx>
  40 #include <svx/sdr/overlay/overlayprimitive2dsequenceobject.hxx>
  41 #include <vcl/ptrstyle.hxx>
  42
  43 using namespace com::sun::star;
  44
  45 class ImplConnectMarkerOverlay
  46 {
  47     // The OverlayObjects
  48     sdr::overlay::OverlayObjectList               maObjects;
  49
  50     // The remembered target object
  51     const SdrObject&                                mrObject;
  52
  53 public:
  54     ImplConnectMarkerOverlay(const SdrCreateView& rView, SdrObject const & rObject);
  55
  56     // The OverlayObjects are cleared using the destructor of OverlayObjectList.
  57     // That destructor calls clear() at the list which removes all objects from the
  58     // OverlayManager and deletes them.
  59
  60     const SdrObject& GetTargetObject() const { return mrObject; }
  61 };
  62
  63 ImplConnectMarkerOverlay::ImplConnectMarkerOverlay(const SdrCreateView& rView, SdrObject const & rObject)
  64 :   mrObject(rObject)
  65 {
  66     basegfx::B2DPolyPolygon aB2DPolyPolygon(rObject.TakeXorPoly());
  67
  68     for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
  69     {
  70         SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
  71         const rtl::Reference< sdr::overlay::OverlayManager >& xTargetOverlay = pCandidate->GetOverlayManager();
  72
  73         if(xTargetOverlay.is())
  74         {
  75             float fScalingFactor = xTargetOverlay->getOutputDevice().GetDPIScaleFactor();
  76             Size aHalfLogicSize(xTargetOverlay->getOutputDevice().PixelToLogic(Size(4 * fScalingFactor, 4 * fScalingFactor)));
  77
  78             // object
  79             std::unique_ptr<sdr::overlay::OverlayPolyPolygonStripedAndFilled> pNew(new sdr::overlay::OverlayPolyPolygonStripedAndFilled(
  80                 aB2DPolyPolygon));
  81             xTargetOverlay->add(*pNew);
  82             maObjects.append(std::move(pNew));
  83
  84             // gluepoints
  85             for(sal_uInt16 i(0); i < 4; i++)
  86             {
  87                 SdrGluePoint aGluePoint(rObject.GetVertexGluePoint(i));
  88                 const Point& rPosition = aGluePoint.GetAbsolutePos(rObject);
  89
  90                 basegfx::B2DPoint aTopLeft(rPosition.X() - aHalfLogicSize.Width(), rPosition.Y() - aHalfLogicSize.Height());
  91                 basegfx::B2DPoint aBottomRight(rPosition.X() + aHalfLogicSize.Width(), rPosition.Y() + aHalfLogicSize.Height());
  92
  93                 basegfx::B2DPolygon aTempPoly;
  94                 aTempPoly.append(aTopLeft);
  95                 aTempPoly.append(basegfx::B2DPoint(aBottomRight.getX(), aTopLeft.getY()));
  96                 aTempPoly.append(aBottomRight);
  97                 aTempPoly.append(basegfx::B2DPoint(aTopLeft.getX(), aBottomRight.getY()));
  98                 aTempPoly.setClosed(true);
  99
 100                 basegfx::B2DPolyPolygon aTempPolyPoly;
 101                 aTempPolyPoly.append(aTempPoly);
 102
 103                 std::unique_ptr<sdr::overlay::OverlayPolyPolygonStripedAndFilled> pNew2(new sdr::overlay::OverlayPolyPolygonStripedAndFilled(
 104                     std::move(aTempPolyPoly)));
 105                 xTargetOverlay->add(*pNew2);
 106                 maObjects.append(std::move(pNew2));
 107             }
 108         }
 109     }
 110 }
 111
 112 class ImpSdrCreateViewExtraData
 113 {
 114     // The OverlayObjects for XOR replacement
 115     sdr::overlay::OverlayObjectList               maObjects;
 116
 117 public:
 118     ImpSdrCreateViewExtraData();
 119     ~ImpSdrCreateViewExtraData();
 120
 121     void CreateAndShowOverlay(const SdrCreateView& rView, const SdrObject* pObject, const basegfx::B2DPolyPolygon& rPolyPoly);
 122     void HideOverlay();
 123 };
 124
 125 ImpSdrCreateViewExtraData::ImpSdrCreateViewExtraData()
 126 {
 127 }
 128
 129 ImpSdrCreateViewExtraData::~ImpSdrCreateViewExtraData()
 130 {
 131     HideOverlay();
 132 }
 133
 134 void ImpSdrCreateViewExtraData::CreateAndShowOverlay(const SdrCreateView& rView, const SdrObject* pObject, const basegfx::B2DPolyPolygon& rPolyPoly)
 135 {
 136     for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
 137     {
 138         SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
 139         const rtl::Reference<sdr::overlay::OverlayManager>& xOverlayManager = pCandidate->GetOverlayManager();
 140
 141         if (xOverlayManager.is())
 142         {
 143             if(pObject)
 144             {
 145                 const sdr::contact::ViewContact& rVC = pObject->GetViewContact();
 146                 drawinglayer::primitive2d::Primitive2DContainer aSequence;
 147                 rVC.getViewIndependentPrimitive2DContainer(aSequence);
 148                 std::unique_ptr<sdr::overlay::OverlayObject> pNew(new sdr::overlay::OverlayPrimitive2DSequenceObject(std::move(aSequence)));
 149
 150                 xOverlayManager->add(*pNew);
 151                 maObjects.append(std::move(pNew));
 152             }
 153
 154             if(rPolyPoly.count())
 155             {
 156                 std::unique_ptr<sdr::overlay::OverlayPolyPolygonStripedAndFilled> pNew(new sdr::overlay::OverlayPolyPolygonStripedAndFilled(
 157                     rPolyPoly));
 158                 xOverlayManager->add(*pNew);
 159                 maObjects.append(std::move(pNew));
 160             }
 161         }
 162     }
 163 }
 164
 165 void ImpSdrCreateViewExtraData::HideOverlay()
 166 {
 167     // the clear() call of the list removes all objects from the
 168     // OverlayManager and deletes them.
 169     maObjects.clear();
 170 }
 171
 172
 173 // CreateView
 174
 175
 176 void SdrCreateView::ImpClearConnectMarker()
 177 {
 178     mpCoMaOverlay.reset();
 179 }
 180
 181 SdrCreateView::SdrCreateView(SdrModel& rSdrModel, OutputDevice* pOut)
 182     : SdrDragView(rSdrModel, pOut)
 183     , mpCreatePV(nullptr)
 184     , mpCreateViewExtraData(new ImpSdrCreateViewExtraData())
 185     , maCurrentCreatePointer(PointerStyle::Cross)
 186     , mnAutoCloseDistPix(5)
 187     , mnFreeHandMinDistPix(10)
 188     , mnCurrentInvent(SdrInventor::Default)
 189     , mnCurrentIdent(SdrObjKind::NONE)
 190     , mb1stPointAsCenter(false)
 191     , mbUseIncompatiblePathCreateInterface(false)
 192 {
 193 }
 194
 195 SdrCreateView::~SdrCreateView()
 196 {
 197     ImpClearConnectMarker();
 198     mpCreateViewExtraData.reset();
 199 }
 200
 201 bool SdrCreateView::IsAction() const
 202 {
 203     return SdrDragView::IsAction() || mpCurrentCreate!=nullptr;
 204 }
 205
 206 void SdrCreateView::MovAction(const Point& rPnt)
 207 {
 208     SdrDragView::MovAction(rPnt);
 209     if (mpCurrentCreate != nullptr) {
 210         MovCreateObj(rPnt);
 211     }
 212 }
 213
 214 void SdrCreateView::EndAction()
 215 {
 216     if (mpCurrentCreate != nullptr) EndCreateObj(SdrCreateCmd::ForceEnd);
 217     SdrDragView::EndAction();
 218 }
 219
 220 void SdrCreateView::BckAction()
 221 {
 222     if (mpCurrentCreate != nullptr) BckCreateObj();
 223     SdrDragView::BckAction();
 224 }
 225
 226 void SdrCreateView::BrkAction()
 227 {
 228     SdrDragView::BrkAction();
 229     BrkCreateObj();
 230 }
 231
 232 void SdrCreateView::TakeActionRect(tools::Rectangle& rRect) const
 233 {
 234     if (mpCurrentCreate != nullptr)
 235     {
 236         rRect=maDragStat.GetActionRect();
 237         if (rRect.IsEmpty())
 238         {
 239             rRect=tools::Rectangle(maDragStat.GetPrev(),maDragStat.GetNow());
 240         }
 241     }
 242     else
 243     {
 244         SdrDragView::TakeActionRect(rRect);
 245     }
 246 }
 247
 248 bool SdrCreateView::CheckEdgeMode()
 249 {
 250     if (mpCurrentCreate != nullptr)
 251     {
 252         // is managed by EdgeObj
 253         if (mnCurrentInvent==SdrInventor::Default && mnCurrentIdent==SdrObjKind::Edge) return false;
 254     }
 255
 256     if (!IsCreateMode() || mnCurrentInvent!=SdrInventor::Default || mnCurrentIdent!=SdrObjKind::Edge)
 257     {
 258         ImpClearConnectMarker();
 259         return false;
 260     }
 261     else
 262     {
 263         // sal_True, if MouseMove should check Connect
 264         return !IsAction();
 265     }
 266 }
 267
 268 void SdrCreateView::SetConnectMarker(const SdrObjConnection& rCon)
 269 {
 270     SdrObject* pTargetObject = rCon.pObj;
 271
 272     if(pTargetObject)
 273     {
 274         // if target object changes, throw away overlay object to make room for changes
 275         if(mpCoMaOverlay && pTargetObject != &mpCoMaOverlay->GetTargetObject())
 276         {
 277             ImpClearConnectMarker();
 278         }
 279
 280         if(!mpCoMaOverlay)
 281         {
 282             mpCoMaOverlay.reset(new ImplConnectMarkerOverlay(*this, *pTargetObject));
 283         }
 284     }
 285     else
 286     {
 287         ImpClearConnectMarker();
 288     }
 289 }
 290
 291 void SdrCreateView::HideConnectMarker()
 292 {
 293     ImpClearConnectMarker();
 294 }
 295
 296 bool SdrCreateView::MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin)
 297 {
 298     if(CheckEdgeMode() && pWin)
 299     {
 300         SdrPageView* pPV = GetSdrPageView();
 301
 302         if(pPV)
 303         {
 304             // TODO: Change default hit tolerance at IsMarkedHit() some time!
 305             Point aPos(pWin->PixelToLogic(rMEvt.GetPosPixel()));
 306             bool bMarkHit=PickHandle(aPos)!=nullptr || IsMarkedObjHit(aPos);
 307             SdrObjConnection aCon;
 308             if (!bMarkHit) SdrEdgeObj::ImpFindConnector(aPos,*pPV,aCon,nullptr,pWin);
 309             SetConnectMarker(aCon);
 310         }
 311     }
 312     return SdrDragView::MouseMove(rMEvt,pWin);
 313 }
 314
 315 bool SdrCreateView::IsTextTool() const
 316 {
 317     return meEditMode==SdrViewEditMode::Create
 318         && mnCurrentInvent==SdrInventor::Default
 319         && (mnCurrentIdent==SdrObjKind::Text
 320             || mnCurrentIdent==SdrObjKind::TitleText
 321             || mnCurrentIdent==SdrObjKind::OutlineText);
 322 }
 323
 324 bool SdrCreateView::IsEdgeTool() const
 325 {
 326     return meEditMode==SdrViewEditMode::Create && mnCurrentInvent==SdrInventor::Default && (mnCurrentIdent==SdrObjKind::Edge);
 327 }
 328
 329 bool SdrCreateView::IsMeasureTool() const
 330 {
 331     return meEditMode==SdrViewEditMode::Create && mnCurrentInvent==SdrInventor::Default && (mnCurrentIdent==SdrObjKind::Measure);
 332 }
 333
 334 void SdrCreateView::SetCurrentObj(SdrObjKind nIdent, SdrInventor nInvent)
 335 {
 336     if (mnCurrentInvent!=nInvent || mnCurrentIdent!=nIdent)
 337     {
 338         mnCurrentInvent=nInvent;
 339         mnCurrentIdent=nIdent;
 340         rtl::Reference<SdrObject> pObj = (nIdent == SdrObjKind::NONE) ? nullptr :
 341             SdrObjFactory::MakeNewObject(
 342                 GetModel(),
 343                 nInvent,
 344                 nIdent);
 345
 346         if(pObj)
 347         {
 348             // Using text tool, mouse cursor is usually I-Beam,
 349             // crosshairs with tiny I-Beam appears only on MouseButtonDown.
 350             if(IsTextTool())
 351             {
 352                 // Here the correct pointer needs to be used
 353                 // if the default is set to vertical writing
 354                 maCurrentCreatePointer = PointerStyle::Text;
 355             }
 356             else
 357                 maCurrentCreatePointer = pObj->GetCreatePointer();
 358         }
 359         else
 360         {
 361             maCurrentCreatePointer = PointerStyle::Cross;
 362         }
 363     }
 364
 365     CheckEdgeMode();
 366     ImpSetGlueVisible3(IsEdgeTool());
 367 }
 368
 369 bool SdrCreateView::ImpBegCreateObj(SdrInventor nInvent, SdrObjKind nIdent, const Point& rPnt, OutputDevice* pOut,
 370     sal_Int16 nMinMov, const tools::Rectangle& rLogRect, SdrObject* pPreparedFactoryObject)
 371 {
 372     bool bRet=false;
 373     UnmarkAllObj();
 374     BrkAction();
 375
 376     ImpClearConnectMarker();
 377
 378     mpCreatePV = GetSdrPageView();
 379
 380     if (mpCreatePV != nullptr)
 381     { // otherwise no side registered!
 382         OUString aLay(maActualLayer);
 383
 384         if(nInvent == SdrInventor::Default && nIdent == SdrObjKind::Measure && !maMeasureLayer.isEmpty())
 385         {
 386             aLay = maMeasureLayer;
 387         }
 388
 389         SdrLayerID nLayer = mpCreatePV->GetPage()->GetLayerAdmin().GetLayerID(aLay);
 390         if (nLayer==SDRLAYER_NOTFOUND) nLayer = SdrLayerID(0);
 391         if (!mpCreatePV->GetLockedLayers().IsSet(nLayer) && mpCreatePV->GetVisibleLayers().IsSet(nLayer))
 392         {
 393             if(pPreparedFactoryObject)
 394             {
 395                 mpCurrentCreate = pPreparedFactoryObject;
 396             }
 397             else
 398             {
 399                 mpCurrentCreate = SdrObjFactory::MakeNewObject(
 400                     GetModel(), nInvent, nIdent);
 401             }
 402
 403             Point aPnt(rPnt);
 404             if (mnCurrentInvent != SdrInventor::Default || (mnCurrentIdent != SdrObjKind::Edge &&
 405                                             mnCurrentIdent != SdrObjKind::FreehandLine &&
 406                                             mnCurrentIdent != SdrObjKind::FreehandFill )) { // no snapping for Edge and Freehand
 407                 aPnt=GetSnapPos(aPnt, mpCreatePV);
 408             }
 409             if (mpCurrentCreate!=nullptr)
 410             {
 411                 if (mpDefaultStyleSheet!=nullptr) mpCurrentCreate->NbcSetStyleSheet(mpDefaultStyleSheet, false);
 412
 413                 // SW uses a naked SdrObject for frame construction. Normally, such an
 414                 // object should not be created. Since it is possible to use it as a helper
 415                 // object (e.g. in letting the user define an area with the interactive
 416                 // construction) at least no items should be set at that object.
 417                 if(nInvent != SdrInventor::Default || nIdent != SdrObjKind::NewFrame)
 418                 {
 419                     mpCurrentCreate->SetMergedItemSet(maDefaultAttr);
 420                 }
 421
 422                 if (dynamic_cast<const SdrCaptionObj *>(mpCurrentCreate.get()) != nullptr)
 423                 {
 424                     SfxItemSet aSet(GetModel().GetItemPool());
 425                     aSet.Put(XFillColorItem(OUString(),COL_WHITE)); // in case someone turns on Solid
 426                     aSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
 427
 428                     mpCurrentCreate->SetMergedItemSet(aSet);
 429                 }
 430                 if (nInvent == SdrInventor::Default && (nIdent==SdrObjKind::Text || nIdent==SdrObjKind::TitleText || nIdent==SdrObjKind::OutlineText))
 431                 {
 432                     // default for all text frames: no background, no border
 433                     SfxItemSet aSet(GetModel().GetItemPool());
 434                     aSet.Put(XFillColorItem(OUString(),COL_WHITE)); // in case someone turns on Solid
 435                     aSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
 436                     aSet.Put(XLineColorItem(OUString(),COL_BLACK)); // in case someone turns on Solid
 437                     aSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
 438
 439                     mpCurrentCreate->SetMergedItemSet(aSet);
 440                 }
 441                 if (!rLogRect.IsEmpty()) mpCurrentCreate->NbcSetLogicRect(rLogRect);
 442
 443                 // make sure drag start point is inside WorkArea
 444                 const tools::Rectangle& rWorkArea = GetWorkArea();
 445
 446                 if(!rWorkArea.IsEmpty())
 447                 {
 448                     if(aPnt.X() < rWorkArea.Left())
 449                     {
 450                         aPnt.setX( rWorkArea.Left() );
 451                     }
 452
 453                     if(aPnt.X() > rWorkArea.Right())
 454                     {
 455                         aPnt.setX( rWorkArea.Right() );
 456                     }
 457
 458                     if(aPnt.Y() < rWorkArea.Top())
 459                     {
 460                         aPnt.setY( rWorkArea.Top() );
 461                     }
 462
 463                     if(aPnt.Y() > rWorkArea.Bottom())
 464                     {
 465                         aPnt.setY( rWorkArea.Bottom() );
 466                     }
 467                 }
 468
 469                 maDragStat.Reset(aPnt);
 470                 maDragStat.SetView(static_cast<SdrView*>(this));
 471                 maDragStat.SetPageView(mpCreatePV);
 472                 maDragStat.SetMinMove(ImpGetMinMovLogic(nMinMov,pOut));
 473                 mpDragWin=pOut;
 474                 if (mpCurrentCreate->BegCreate(maDragStat))
 475                 {
 476                     ShowCreateObj(/*pOut,sal_True*/);
 477                     bRet=true;
 478                 }
 479                 else
 480                 {
 481                     mpCurrentCreate = nullptr;
 482                     mpCreatePV = nullptr;
 483                 }
 484             }
 485         }
 486     }
 487     return bRet;
 488 }
 489
 490 bool SdrCreateView::BegCreateObj(const Point& rPnt, OutputDevice* pOut, short nMinMov)
 491 {
 492     return ImpBegCreateObj(mnCurrentInvent,mnCurrentIdent,rPnt,pOut,nMinMov,tools::Rectangle(), nullptr);
 493 }
 494
 495 bool SdrCreateView::BegCreatePreparedObject(const Point& rPnt, sal_Int16 nMinMov, SdrObject* pPreparedFactoryObject)
 496 {
 497     SdrInventor nInvent(mnCurrentInvent);
 498     SdrObjKind nIdent(mnCurrentIdent);
 499
 500     if(pPreparedFactoryObject)
 501     {
 502         nInvent = pPreparedFactoryObject->GetObjInventor();
 503         nIdent = pPreparedFactoryObject->GetObjIdentifier();
 504     }
 505
 506     return ImpBegCreateObj(nInvent, nIdent, rPnt, nullptr, nMinMov, tools::Rectangle(), pPreparedFactoryObject);
 507 }
 508
 509 bool SdrCreateView::BegCreateCaptionObj(const Point& rPnt, const Size& rObjSiz,
 510     OutputDevice* pOut, short nMinMov)
 511 {
 512     return ImpBegCreateObj(SdrInventor::Default,SdrObjKind::Caption,rPnt,pOut,nMinMov,
 513         tools::Rectangle(rPnt,Size(rObjSiz.Width()+1,rObjSiz.Height()+1)), nullptr);
 514 }
 515
 516 void SdrCreateView::MovCreateObj(const Point& rPnt)
 517 {
 518     if (mpCurrentCreate==nullptr)
 519         return;
 520
 521     Point aPnt(rPnt);
 522     if (!maDragStat.IsNoSnap())
 523     {
 524         aPnt=GetSnapPos(aPnt, mpCreatePV);
 525     }
 526     if (IsOrtho())
 527     {
 528         if (maDragStat.IsOrtho8Possible()) OrthoDistance8(maDragStat.GetPrev(),aPnt,IsBigOrtho());
 529         else if (maDragStat.IsOrtho4Possible()) OrthoDistance4(maDragStat.GetPrev(),aPnt,IsBigOrtho());
 530     }
 531
 532     // If the drag point was limited and Ortho is active, do
 533     // the small ortho correction (reduction) -> last parameter to FALSE.
 534     bool bDidLimit(ImpLimitToWorkArea(aPnt));
 535     if(bDidLimit && IsOrtho())
 536     {
 537         if(maDragStat.IsOrtho8Possible())
 538             OrthoDistance8(maDragStat.GetPrev(), aPnt, false);
 539         else if(maDragStat.IsOrtho4Possible())
 540             OrthoDistance4(maDragStat.GetPrev(), aPnt, false);
 541     }
 542
 543     if (aPnt==maDragStat.GetNow()) return;
 544     bool bIsMinMoved(maDragStat.IsMinMoved());
 545     if (!maDragStat.CheckMinMoved(aPnt))
 546         return;
 547
 548     if (!bIsMinMoved) maDragStat.NextPoint();
 549     maDragStat.NextMove(aPnt);
 550     mpCurrentCreate->MovCreate(maDragStat);
 551
 552     // MovCreate changes the object, so use ActionChanged() on it
 553     mpCurrentCreate->ActionChanged();
 554
 555     // replace for DrawCreateObjDiff
 556     HideCreateObj();
 557     ShowCreateObj();
 558 }
 559
 560 void SdrCreateView::SetupObjLayer(const SdrPageView* pPageView, const OUString& aActiveLayer, SdrObject* pObj)
 561 {
 562     const SdrLayerAdmin& rAd = pPageView->GetPage()->GetLayerAdmin();
 563     SdrLayerID nLayer(0);
 564
 565     // #i72535#
 566     if(dynamic_cast<const FmFormObj*>( pObj) !=  nullptr)
 567     {
 568         // for FormControls, force to form layer
 569         nLayer = rAd.GetLayerID(rAd.GetControlLayerName());
 570     }
 571     else
 572     {
 573         nLayer = rAd.GetLayerID(aActiveLayer);
 574     }
 575
 576     if(SDRLAYER_NOTFOUND == nLayer)
 577     {
 578         nLayer = SdrLayerID(0);
 579     }
 580
 581     pObj->SetLayer(nLayer);
 582 }
 583
 584 bool SdrCreateView::EndCreateObj(SdrCreateCmd eCmd)
 585 {
 586     bool bRet=false;
 587     SdrObject* pObjCreated=mpCurrentCreate.get();
 588
 589     if (mpCurrentCreate!=nullptr)
 590     {
 591         sal_uInt32 nCount=maDragStat.GetPointCount();
 592
 593         if (nCount<=1 && eCmd==SdrCreateCmd::ForceEnd)
 594         {
 595             BrkCreateObj(); // objects with only a single point don't exist (at least today)
 596             return false; // sal_False = event not interpreted
 597         }
 598
 599         bool bPntsEq=nCount>1;
 600         sal_uInt32 i=1;
 601         Point aP0=maDragStat.GetPoint(0);
 602         while (bPntsEq && i<nCount) { bPntsEq=aP0==maDragStat.GetPoint(i); i++; }
 603
 604         if (mpCurrentCreate->EndCreate(maDragStat,eCmd))
 605         {
 606             HideCreateObj();
 607
 608             if (!bPntsEq)
 609             {
 610                 // otherwise Brk, because all points are equal
 611                 rtl::Reference<SdrObject> pObj = std::move(mpCurrentCreate);
 612
 613                 SetupObjLayer(mpCreatePV, maActualLayer, pObj.get());
 614
 615                 // recognize creation of a new 3D object inside a 3D scene
 616                 bool bSceneIntoScene(false);
 617
 618                 E3dScene* pObjScene = DynCastE3dScene(pObjCreated);
 619                 E3dScene* pCurrentScene = pObjScene ? DynCastE3dScene(mpCreatePV->GetCurrentGroup()) : nullptr;
 620                 if (pCurrentScene)
 621                 {
 622                     bool bDidInsert = static_cast<E3dView*>(this)->ImpCloneAll3DObjectsToDestScene(
 623                         pObjScene, pCurrentScene, Point(0, 0));
 624
 625                     if(bDidInsert)
 626                     {
 627                         pObjCreated = nullptr;
 628                         bSceneIntoScene = true;
 629                     }
 630                 }
 631
 632                 if(!bSceneIntoScene)
 633                 {
 634                     // Here an interactively created SdrObject gets added, so
 635                     // take into account that interaction created an object in
 636                     // model coordinates. If we have e.g. a GirdOffset, this is a
 637                     // little bit tricky - we have an object in model coordinates,
 638                     // so the fetched offset is at the wrong point in principle
 639                     // since we need to 'substract' the offset here to get to
 640                     // 'real' model coordinates. But we have nothing better here,
 641                     // so go for it.
 642                     // The 2nd a little tricky thing is that this will early-create
 643                     // a ViewObjectContact for the new SdrObject, but these VOCs
 644                     // are anyways layouted for being create-on-demand. This will
 645                     // be adapted/replaced correctly later on.
 646                     // This *should* be the right place for getting all interactively
 647                     // created objects, see InsertObjectAtView below that calls
 648                     // CreateUndoNewObject.
 649                     basegfx::B2DVector aGridOffset(0.0, 0.0);
 650                     if(getPossibleGridOffsetForSdrObject(aGridOffset, pObj.get(), mpCreatePV))
 651                     {
 652                         const Size aOffset(
 653                             basegfx::fround(-aGridOffset.getX()),
 654                             basegfx::fround(-aGridOffset.getY()));
 655
 656                         pObj->NbcMove(aOffset);
 657                     }
 658
 659                     // do the same as before
 660                     InsertObjectAtView(pObj.get(), *mpCreatePV);
 661                 }
 662
 663                 mpCreatePV = nullptr;
 664                 bRet=true; // sal_True = event interpreted
 665             }
 666             else
 667             {
 668                 BrkCreateObj();
 669             }
 670         }
 671         else
 672         { // more points
 673             if (eCmd==SdrCreateCmd::ForceEnd || // nothing there -- force ending
 674                 nCount==0 ||                             // no existing points (should never happen)
 675                 (nCount<=1 && !maDragStat.IsMinMoved())) { // MinMove not met
 676                 BrkCreateObj();
 677             }
 678             else
 679             {
 680                 // replace for DrawCreateObjDiff
 681                 HideCreateObj();
 682                 ShowCreateObj();
 683                 maDragStat.ResetMinMoved(); // NextPoint is at MovCreateObj()
 684                 bRet=true;
 685             }
 686         }
 687     }
 688     return bRet;
 689 }
 690
 691 void SdrCreateView::BckCreateObj()
 692 {
 693     if (mpCurrentCreate==nullptr)
 694         return;
 695
 696     if (maDragStat.GetPointCount()<=2 )
 697     {
 698         BrkCreateObj();
 699     }
 700     else
 701     {
 702         HideCreateObj();
 703         maDragStat.PrevPoint();
 704         if (mpCurrentCreate->BckCreate(maDragStat))
 705         {
 706             ShowCreateObj();
 707         }
 708         else
 709         {
 710             BrkCreateObj();
 711         }
 712     }
 713 }
 714
 715 void SdrCreateView::BrkCreateObj()
 716 {
 717     if (mpCurrentCreate!=nullptr)
 718     {
 719         HideCreateObj();
 720         mpCurrentCreate->BrkCreate(maDragStat);
 721         mpCurrentCreate = nullptr;
 722         mpCreatePV = nullptr;
 723     }
 724 }
 725
 726 void SdrCreateView::ShowCreateObj(/*OutputDevice* pOut, sal_Bool bFull*/)
 727 {
 728     if(!IsCreateObj() || maDragStat.IsShown())
 729         return;
 730
 731     if (mpCurrentCreate)
 732     {
 733         // for migration from XOR, replace DrawDragObj here to create
 734         // overlay objects instead.
 735         bool bUseSolidDragging(IsSolidDragging());
 736
 737         // #i101648# check if dragged object is a SdrObjKind::NewFrame.
 738         // This is e.g. used in SW Frame construction as placeholder.
 739         // Do not use SolidDragging for SdrObjKind::NewFrame kind of objects,
 740         // they cannot have a valid optical representation.
 741         if (bUseSolidDragging && SdrObjKind::NewFrame == mpCurrentCreate->GetObjIdentifier())
 742         {
 743             bUseSolidDragging = false;
 744         }
 745
 746         // check for objects with no fill and no line
 747         if(bUseSolidDragging)
 748         {
 749             const SfxItemSet& rSet = mpCurrentCreate->GetMergedItemSet();
 750             const drawing::FillStyle eFill(rSet.Get(XATTR_FILLSTYLE).GetValue());
 751             const drawing::LineStyle eLine(rSet.Get(XATTR_LINESTYLE).GetValue());
 752
 753             if(drawing::LineStyle_NONE == eLine && drawing::FillStyle_NONE == eFill)
 754             {
 755                 bUseSolidDragging = false;
 756             }
 757         }
 758
 759         // check for form controls
 760         if(bUseSolidDragging)
 761         {
 762             if (dynamic_cast<const SdrUnoObj*>(mpCurrentCreate.get()) != nullptr)
 763             {
 764                 bUseSolidDragging = false;
 765             }
 766         }
 767
 768           // #i101781# force to non-solid dragging when not creating a full circle
 769         if(bUseSolidDragging)
 770         {
 771             SdrCircObj* pCircObj = dynamic_cast<SdrCircObj*>(mpCurrentCreate.get());
 772
 773             if(pCircObj && SdrObjKind::CircleOrEllipse != pCircObj->GetObjIdentifier())
 774             {
 775                 // #i103058# Allow SolidDragging with four points
 776                 if(maDragStat.GetPointCount() < 4)
 777                 {
 778                     bUseSolidDragging = false;
 779                 }
 780             }
 781         }
 782
 783         if(bUseSolidDragging)
 784         {
 785             basegfx::B2DPolyPolygon aDragPolyPolygon;
 786
 787             if (dynamic_cast<const SdrRectObj*>(mpCurrentCreate.get()) != nullptr)
 788             {
 789                 // ensure object has some size, necessary for SdrTextObj because
 790                 // there are still untested divisions by that sizes
 791                 tools::Rectangle aCurrentSnapRect(mpCurrentCreate->GetSnapRect());
 792
 793                 if(aCurrentSnapRect.GetWidth() <= 1 || aCurrentSnapRect.GetHeight() <= 1)
 794                 {
 795                     tools::Rectangle aNewRect(maDragStat.GetStart(), maDragStat.GetStart() + Point(2, 2));
 796                     mpCurrentCreate->NbcSetSnapRect(aNewRect);
 797                 }
 798             }
 799
 800             if (auto pPathObj = dynamic_cast<SdrPathObj*>(mpCurrentCreate.get()))
 801             {
 802                 // The up-to-now created path needs to be set at the object to have something
 803                 // that can be visualized
 804                 const basegfx::B2DPolyPolygon aCurrentPolyPolygon(pPathObj->getObjectPolyPolygon(maDragStat));
 805
 806                 if(aCurrentPolyPolygon.count())
 807                 {
 808                     pPathObj->NbcSetPathPoly(aCurrentPolyPolygon);
 809                 }
 810
 811                 aDragPolyPolygon = pPathObj->getDragPolyPolygon(maDragStat);
 812             }
 813
 814             // use the SdrObject directly for overlay
 815             mpCreateViewExtraData->CreateAndShowOverlay(*this, mpCurrentCreate.get(), aDragPolyPolygon);
 816         }
 817         else
 818         {
 819             const ::basegfx::B2DPolyPolygon aPoly(mpCurrentCreate->TakeCreatePoly(maDragStat));
 820
 821             mpCreateViewExtraData->CreateAndShowOverlay(*this, nullptr, aPoly);
 822         }
 823
 824         // #i101679# Force changed overlay to be shown
 825         for(sal_uInt32 a(0); a < PaintWindowCount(); a++)
 826         {
 827             SdrPaintWindow* pCandidate = GetPaintWindow(a);
 828             const rtl::Reference<sdr::overlay::OverlayManager>& xOverlayManager = pCandidate->GetOverlayManager();
 829
 830             if (xOverlayManager.is())
 831             {
 832                 xOverlayManager->flush();
 833             }
 834         }
 835     }
 836
 837     maDragStat.SetShown(true);
 838 }
 839
 840 void SdrCreateView::HideCreateObj()
 841 {
 842     if(IsCreateObj() && maDragStat.IsShown())
 843     {
 844         // for migration from XOR, replace DrawDragObj here to create
 845         // overlay objects instead.
 846         mpCreateViewExtraData->HideOverlay();
 847
 848         //DrawCreateObj(pOut,bFull);
 849         maDragStat.SetShown(false);
 850     }
 851 }
 852
 853
 854 void SdrCreateView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
 855 {
 856     if (mpCurrentCreate)
 857     {
 858         rTargetSet.Put(mpCurrentCreate->GetMergedItemSet());
 859     }
 860     else
 861     {
 862         SdrDragView::GetAttributes(rTargetSet, bOnlyHardAttr);
 863     }
 864 }
 865
 866 bool SdrCreateView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
 867 {
 868     if (mpCurrentCreate)
 869     {
 870         mpCurrentCreate->SetMergedItemSetAndBroadcast(rSet, bReplaceAll);
 871
 872         return true;
 873     }
 874     else
 875     {
 876         return SdrDragView::SetAttributes(rSet,bReplaceAll);
 877     }
 878 }
 879
 880 SfxStyleSheet* SdrCreateView::GetStyleSheet() const
 881 {
 882     if (mpCurrentCreate != nullptr)
 883     {
 884         return mpCurrentCreate->GetStyleSheet();
 885     }
 886     else
 887     {
 888         return SdrDragView::GetStyleSheet();
 889     }
 890 }
 891
 892 void SdrCreateView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
 893 {
 894     if (mpCurrentCreate != nullptr)
 895     {
 896         mpCurrentCreate->SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
 897     }
 898     else
 899     {
 900         SdrDragView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
 901     }
 902 }
 903
 904 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */