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