svx/source/svdraw/svdovirt.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/svdovirt.hxx>
  22 #include <svx/svdhdl.hxx>
  23 #include <svx/sdr/contact/viewcontactofvirtobj.hxx>
  24 #include <svx/svdograf.hxx>
  25 #include <svx/svddrgv.hxx>
  26 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  27
  28 sdr::properties::BaseProperties& SdrVirtObj::GetProperties() const
  29 {
  30     return mxRefObj->GetProperties();
  31 }
  32
  33
  34 // #i27224#
  35 std::unique_ptr<sdr::contact::ViewContact> SdrVirtObj::CreateObjectSpecificViewContact()
  36 {
  37     return std::make_unique<sdr::contact::ViewContactOfVirtObj>(*this);
  38 }
  39
  40 SdrVirtObj::SdrVirtObj(
  41     SdrModel& rSdrModel,
  42     SdrObject& rNewObj)
  43 :   SdrObject(rSdrModel),
  44     mxRefObj(&rNewObj)
  45 {
  46     m_bVirtObj=true; // this is only a virtual object
  47     mxRefObj->AddReference(*this);
  48     m_bClosedObj = mxRefObj->IsClosedObj();
  49 }
  50
  51 SdrVirtObj::SdrVirtObj(
  52     SdrModel& rSdrModel, SdrVirtObj const & rSource)
  53 :   SdrObject(rSdrModel, rSource),
  54     mxRefObj(rSource.mxRefObj)
  55 {
  56     m_bVirtObj=true; // this is only a virtual object
  57     m_bClosedObj = mxRefObj->IsClosedObj();
  58
  59     mxRefObj->AddReference(*this);
  60
  61     aSnapRect = rSource.aSnapRect;
  62     m_aAnchor = rSource.m_aAnchor;
  63 }
  64
  65 SdrVirtObj::~SdrVirtObj()
  66 {
  67     mxRefObj->DelReference(*this);
  68 }
  69
  70 const SdrObject& SdrVirtObj::GetReferencedObj() const
  71 {
  72     return *mxRefObj;
  73 }
  74
  75 SdrObject& SdrVirtObj::ReferencedObj()
  76 {
  77     return *mxRefObj;
  78 }
  79
  80 void SdrVirtObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/)
  81 {
  82     m_bClosedObj = mxRefObj->IsClosedObj();
  83     SetBoundAndSnapRectsDirty(); // TODO: Optimize this.
  84
  85     // Only a repaint here, rRefObj may have changed and broadcasts
  86     ActionChanged();
  87 }
  88
  89 void SdrVirtObj::NbcSetAnchorPos(const Point& rAnchorPos)
  90 {
  91     m_aAnchor=rAnchorPos;
  92 }
  93
  94 void SdrVirtObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
  95 {
  96     mxRefObj->TakeObjInfo(rInfo);
  97 }
  98
  99 SdrInventor SdrVirtObj::GetObjInventor() const
 100 {
 101     return mxRefObj->GetObjInventor();
 102 }
 103
 104 SdrObjKind SdrVirtObj::GetObjIdentifier() const
 105 {
 106     return mxRefObj->GetObjIdentifier();
 107 }
 108
 109 SdrObjList* SdrVirtObj::GetSubList() const
 110 {
 111     return mxRefObj->GetSubList();
 112 }
 113
 114 void SdrVirtObj::SetName(const OUString& rStr, const bool bSetChanged)
 115 {
 116     return mxRefObj->SetName(rStr, bSetChanged);
 117 }
 118
 119 const OUString & SdrVirtObj::GetName() const
 120 {
 121     return mxRefObj->GetName();
 122 }
 123
 124 void SdrVirtObj::SetTitle(const OUString& rStr)
 125 {
 126     return mxRefObj->SetTitle(rStr);
 127 }
 128
 129 OUString SdrVirtObj::GetTitle() const
 130 {
 131     return mxRefObj->GetTitle();
 132 }
 133
 134 void SdrVirtObj::SetDescription(const OUString& rStr)
 135 {
 136     return mxRefObj->SetDescription(rStr);
 137 }
 138
 139 OUString SdrVirtObj::GetDescription() const
 140 {
 141     return mxRefObj->GetDescription();
 142 }
 143
 144 void SdrVirtObj::SetDecorative(bool const isDecorative)
 145 {
 146     return mxRefObj->SetDecorative(isDecorative);
 147 }
 148
 149 bool SdrVirtObj::IsDecorative() const
 150 {
 151     return mxRefObj->IsDecorative();
 152 }
 153
 154 const tools::Rectangle& SdrVirtObj::GetCurrentBoundRect() const
 155 {
 156     auto aRectangle = mxRefObj->GetCurrentBoundRect(); // TODO: Optimize this.
 157     aRectangle += m_aAnchor;
 158     setOutRectangleConst(aRectangle);
 159     return getOutRectangle();
 160 }
 161
 162 const tools::Rectangle& SdrVirtObj::GetLastBoundRect() const
 163 {
 164     auto aRectangle = mxRefObj->GetLastBoundRect(); // TODO: Optimize this.
 165     aRectangle += m_aAnchor;
 166     setOutRectangleConst(aRectangle);
 167     return getOutRectangle();
 168 }
 169
 170 void SdrVirtObj::RecalcBoundRect()
 171 {
 172     tools::Rectangle aRectangle = mxRefObj->GetCurrentBoundRect();
 173     aRectangle += m_aAnchor;
 174     setOutRectangle(aRectangle);
 175 }
 176
 177 rtl::Reference<SdrObject> SdrVirtObj::CloneSdrObject(SdrModel& rTargetModel) const
 178 {
 179     return new SdrVirtObj(rTargetModel, *this);
 180     // TTTT not sure if the above works - how could SdrObjFactory::MakeNewObject
 181     // create an object with correct rRefObj (?) OTOH VirtObj probably needs not
 182     // to be cloned ever - only used in Writer for multiple instances e.g. Header/Footer
 183     // return new SdrVirtObj(
 184     //     getSdrModelFromSdrObject(),
 185     //     rRefObj); // only a further reference
 186 }
 187
 188 OUString SdrVirtObj::TakeObjNameSingul() const
 189 {
 190     OUString sName = "[" + mxRefObj->TakeObjNameSingul() + "]";
 191
 192     OUString aName(GetName());
 193     if (!aName.isEmpty())
 194         sName += " '" + aName + "'";
 195
 196     return sName;
 197 }
 198
 199 OUString SdrVirtObj::TakeObjNamePlural() const
 200 {
 201     return "[" + mxRefObj->TakeObjNamePlural() + "]";
 202 }
 203
 204 bool SdrVirtObj::HasLimitedRotation() const
 205 {
 206     // RotGrfFlyFrame: If true, this SdrObject supports only limited rotation
 207     return mxRefObj->HasLimitedRotation();
 208 }
 209
 210 basegfx::B2DPolyPolygon SdrVirtObj::TakeXorPoly() const
 211 {
 212     basegfx::B2DPolyPolygon aPolyPolygon(mxRefObj->TakeXorPoly());
 213
 214     if(m_aAnchor.X() || m_aAnchor.Y())
 215     {
 216         aPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(m_aAnchor.X(), m_aAnchor.Y()));
 217     }
 218
 219     return aPolyPolygon;
 220 }
 221
 222
 223 sal_uInt32 SdrVirtObj::GetHdlCount() const
 224 {
 225     return mxRefObj->GetHdlCount();
 226 }
 227
 228 void SdrVirtObj::AddToHdlList(SdrHdlList& rHdlList) const
 229 {
 230     SdrHdlList tempList(nullptr);
 231     mxRefObj->AddToHdlList(tempList);
 232     for (size_t i=0; i<tempList.GetHdlCount(); ++i)
 233     {
 234         SdrHdl* pHdl = tempList.GetHdl(i);
 235         Point aP(pHdl->GetPos()+m_aAnchor);
 236         pHdl->SetPos(aP);
 237     }
 238     tempList.MoveTo(rHdlList);
 239 }
 240
 241 void SdrVirtObj::AddToPlusHdlList(SdrHdlList& rHdlList, SdrHdl& rHdl) const
 242 {
 243     SdrHdlList tempList(nullptr);
 244     mxRefObj->AddToPlusHdlList(tempList, rHdl);
 245     for (size_t i=0; i<tempList.GetHdlCount(); ++i)
 246     {
 247         SdrHdl* pHdl = tempList.GetHdl(i);
 248         Point aP(pHdl->GetPos()+m_aAnchor);
 249         pHdl->SetPos(aP);
 250     }
 251     tempList.MoveTo(rHdlList);
 252 }
 253
 254 bool SdrVirtObj::hasSpecialDrag() const
 255 {
 256     return mxRefObj->hasSpecialDrag();
 257 }
 258
 259 bool SdrVirtObj::supportsFullDrag() const
 260 {
 261     return false;
 262 }
 263
 264 rtl::Reference<SdrObject> SdrVirtObj::getFullDragClone() const
 265 {
 266     SdrObject& rReferencedObject = const_cast<SdrVirtObj*>(this)->ReferencedObj();
 267     return rtl::Reference<SdrObject>(new SdrGrafObj(
 268         getSdrModelFromSdrObject(),
 269         SdrDragView::GetObjGraphic(rReferencedObject),
 270         GetLogicRect()));
 271 }
 272
 273 bool SdrVirtObj::beginSpecialDrag(SdrDragStat& rDrag) const
 274 {
 275     return mxRefObj->beginSpecialDrag(rDrag);
 276 }
 277
 278 bool SdrVirtObj::applySpecialDrag(SdrDragStat& rDrag)
 279 {
 280     return mxRefObj->applySpecialDrag(rDrag);
 281 }
 282
 283 basegfx::B2DPolyPolygon SdrVirtObj::getSpecialDragPoly(const SdrDragStat& rDrag) const
 284 {
 285     return mxRefObj->getSpecialDragPoly(rDrag);
 286     // TODO: we don't handle offsets yet!
 287 }
 288
 289 OUString SdrVirtObj::getSpecialDragComment(const SdrDragStat& rDrag) const
 290 {
 291     return mxRefObj->getSpecialDragComment(rDrag);
 292 }
 293
 294
 295 bool SdrVirtObj::BegCreate(SdrDragStat& rStat)
 296 {
 297     return mxRefObj->BegCreate(rStat);
 298 }
 299
 300 bool SdrVirtObj::MovCreate(SdrDragStat& rStat)
 301 {
 302     return mxRefObj->MovCreate(rStat);
 303 }
 304
 305 bool SdrVirtObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 306 {
 307     return mxRefObj->EndCreate(rStat,eCmd);
 308 }
 309
 310 bool SdrVirtObj::BckCreate(SdrDragStat& rStat)
 311 {
 312     return mxRefObj->BckCreate(rStat);
 313 }
 314
 315 void SdrVirtObj::BrkCreate(SdrDragStat& rStat)
 316 {
 317     mxRefObj->BrkCreate(rStat);
 318 }
 319
 320 basegfx::B2DPolyPolygon SdrVirtObj::TakeCreatePoly(const SdrDragStat& rDrag) const
 321 {
 322     return mxRefObj->TakeCreatePoly(rDrag);
 323     // TODO: we don't handle offsets yet!
 324 }
 325
 326
 327 void SdrVirtObj::NbcMove(const Size& rSiz)
 328 {
 329     m_aAnchor.Move(rSiz);
 330     SetBoundAndSnapRectsDirty();
 331 }
 332
 333 void SdrVirtObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 334 {
 335     mxRefObj->NbcResize(rRef-m_aAnchor,xFact,yFact);
 336     SetBoundAndSnapRectsDirty();
 337 }
 338
 339 void SdrVirtObj::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs)
 340 {
 341     mxRefObj->NbcRotate(rRef-m_aAnchor,nAngle,sn,cs);
 342     SetBoundAndSnapRectsDirty();
 343 }
 344
 345 void SdrVirtObj::NbcMirror(const Point& rRef1, const Point& rRef2)
 346 {
 347     mxRefObj->NbcMirror(rRef1-m_aAnchor,rRef2-m_aAnchor);
 348     SetBoundAndSnapRectsDirty();
 349 }
 350
 351 void SdrVirtObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear)
 352 {
 353     mxRefObj->NbcShear(rRef-m_aAnchor,nAngle,tn,bVShear);
 354     SetBoundAndSnapRectsDirty();
 355 }
 356
 357
 358 void SdrVirtObj::Move(const Size& rSiz)
 359 {
 360     if (!rSiz.IsEmpty()) {
 361         tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 362         NbcMove(rSiz);
 363         SetChanged();
 364         BroadcastObjectChange();
 365         SendUserCall(SdrUserCallType::MoveOnly,aBoundRect0);
 366     }
 367 }
 368
 369 void SdrVirtObj::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative)
 370 {
 371     if (xFact.GetNumerator()!=xFact.GetDenominator() || yFact.GetNumerator()!=yFact.GetDenominator()) {
 372         tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 373         mxRefObj->Resize(rRef-m_aAnchor,xFact,yFact, bUnsetRelative);
 374         SetBoundAndSnapRectsDirty();
 375         SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 376     }
 377 }
 378
 379 void SdrVirtObj::Rotate(const Point& rRef, Degree100 nAngle, double sn, double cs)
 380 {
 381     if (nAngle) {
 382         tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 383         mxRefObj->Rotate(rRef-m_aAnchor,nAngle,sn,cs);
 384         SetBoundAndSnapRectsDirty();
 385         SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 386     }
 387 }
 388
 389 void SdrVirtObj::Mirror(const Point& rRef1, const Point& rRef2)
 390 {
 391     tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 392     mxRefObj->Mirror(rRef1-m_aAnchor,rRef2-m_aAnchor);
 393     SetBoundAndSnapRectsDirty();
 394     SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 395 }
 396
 397 void SdrVirtObj::Shear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear)
 398 {
 399     if (nAngle) {
 400         tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 401         mxRefObj->Shear(rRef-m_aAnchor,nAngle,tn,bVShear);
 402         SetBoundAndSnapRectsDirty();
 403         SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 404     }
 405 }
 406
 407
 408 void SdrVirtObj::RecalcSnapRect()
 409 {
 410     aSnapRect=mxRefObj->GetSnapRect();
 411     aSnapRect+=m_aAnchor;
 412 }
 413
 414 const tools::Rectangle& SdrVirtObj::GetSnapRect() const
 415 {
 416     const_cast<SdrVirtObj*>(this)->aSnapRect=mxRefObj->GetSnapRect();
 417     const_cast<SdrVirtObj*>(this)->aSnapRect+=m_aAnchor;
 418     return aSnapRect;
 419 }
 420
 421 void SdrVirtObj::SetSnapRect(const tools::Rectangle& rRect)
 422 {
 423     tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 424     tools::Rectangle aR(rRect);
 425     aR-=m_aAnchor;
 426     mxRefObj->SetSnapRect(aR);
 427     SetBoundAndSnapRectsDirty();
 428     SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 429 }
 430
 431 void SdrVirtObj::NbcSetSnapRect(const tools::Rectangle& rRect)
 432 {
 433     tools::Rectangle aR(rRect);
 434     aR-=m_aAnchor;
 435     SetBoundAndSnapRectsDirty();
 436     mxRefObj->NbcSetSnapRect(aR);
 437 }
 438
 439
 440 const tools::Rectangle& SdrVirtObj::GetLogicRect() const
 441 {
 442     const_cast<SdrVirtObj*>(this)->aSnapRect=mxRefObj->GetLogicRect();  // An abuse of aSnapRect!
 443     const_cast<SdrVirtObj*>(this)->aSnapRect+=m_aAnchor;                // If there's trouble, we need another Rectangle Member (or a Heap).
 444     return aSnapRect;
 445 }
 446
 447 void SdrVirtObj::SetLogicRect(const tools::Rectangle& rRect)
 448 {
 449     tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 450     tools::Rectangle aR(rRect);
 451     aR-=m_aAnchor;
 452     mxRefObj->SetLogicRect(aR);
 453     SetBoundAndSnapRectsDirty();
 454     SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 455 }
 456
 457 void SdrVirtObj::NbcSetLogicRect(const tools::Rectangle& rRect)
 458 {
 459     tools::Rectangle aR(rRect);
 460     aR-=m_aAnchor;
 461     SetBoundAndSnapRectsDirty();
 462     mxRefObj->NbcSetLogicRect(aR);
 463 }
 464
 465
 466 Degree100 SdrVirtObj::GetRotateAngle() const
 467 {
 468     return mxRefObj->GetRotateAngle();
 469 }
 470
 471 Degree100 SdrVirtObj::GetShearAngle(bool bVertical) const
 472 {
 473     return mxRefObj->GetShearAngle(bVertical);
 474 }
 475
 476
 477 sal_uInt32 SdrVirtObj::GetSnapPointCount() const
 478 {
 479     return mxRefObj->GetSnapPointCount();
 480 }
 481
 482 Point SdrVirtObj::GetSnapPoint(sal_uInt32 i) const
 483 {
 484     Point aP(mxRefObj->GetSnapPoint(i));
 485     aP+=m_aAnchor;
 486     return aP;
 487 }
 488
 489 bool SdrVirtObj::IsPolyObj() const
 490 {
 491     return mxRefObj->IsPolyObj();
 492 }
 493
 494 sal_uInt32 SdrVirtObj::GetPointCount() const
 495 {
 496     return mxRefObj->GetPointCount();
 497 }
 498
 499 Point SdrVirtObj::GetPoint(sal_uInt32 i) const
 500 {
 501     return mxRefObj->GetPoint(i) + m_aAnchor;
 502 }
 503
 504 void SdrVirtObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i)
 505 {
 506     Point aP(rPnt);
 507     aP-=m_aAnchor;
 508     mxRefObj->SetPoint(aP,i);
 509     SetBoundAndSnapRectsDirty();
 510 }
 511
 512
 513 std::unique_ptr<SdrObjGeoData> SdrVirtObj::NewGeoData() const
 514 {
 515     return mxRefObj->NewGeoData();
 516 }
 517
 518 void SdrVirtObj::SaveGeoData(SdrObjGeoData& rGeo) const
 519 {
 520     mxRefObj->SaveGeoData(rGeo);
 521 }
 522
 523 void SdrVirtObj::RestoreGeoData(const SdrObjGeoData& rGeo)
 524 {
 525     mxRefObj->RestoreGeoData(rGeo);
 526     SetBoundAndSnapRectsDirty();
 527 }
 528
 529
 530 std::unique_ptr<SdrObjGeoData> SdrVirtObj::GetGeoData() const
 531 {
 532     return mxRefObj->GetGeoData();
 533 }
 534
 535 void SdrVirtObj::SetGeoData(const SdrObjGeoData& rGeo)
 536 {
 537     tools::Rectangle aBoundRect0; if (m_pUserCall!=nullptr) aBoundRect0=GetLastBoundRect();
 538     mxRefObj->SetGeoData(rGeo);
 539     SetBoundAndSnapRectsDirty();
 540     SendUserCall(SdrUserCallType::Resize,aBoundRect0);
 541 }
 542
 543
 544 void SdrVirtObj::NbcReformatText()
 545 {
 546     mxRefObj->NbcReformatText();
 547 }
 548
 549 bool SdrVirtObj::HasMacro() const
 550 {
 551     return mxRefObj->HasMacro();
 552 }
 553
 554 SdrObject* SdrVirtObj::CheckMacroHit(const SdrObjMacroHitRec& rRec) const
 555 {
 556     return mxRefObj->CheckMacroHit(rRec); // TODO: positioning offset
 557 }
 558
 559 PointerStyle SdrVirtObj::GetMacroPointer(const SdrObjMacroHitRec& rRec) const
 560 {
 561     return mxRefObj->GetMacroPointer(rRec); // TODO: positioning offset
 562 }
 563
 564 void SdrVirtObj::PaintMacro(OutputDevice& rOut, const tools::Rectangle& rDirtyRect, const SdrObjMacroHitRec& rRec) const
 565 {
 566     mxRefObj->PaintMacro(rOut,rDirtyRect,rRec); // TODO: positioning offset
 567 }
 568
 569 bool SdrVirtObj::DoMacro(const SdrObjMacroHitRec& rRec)
 570 {
 571     return mxRefObj->DoMacro(rRec); // TODO: positioning offset
 572 }
 573
 574 Point SdrVirtObj::GetOffset() const
 575 {
 576     // #i73248# default offset of SdrVirtObj is aAnchor
 577     return m_aAnchor;
 578 }
 579
 580 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */