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