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/xpool.hxx>
  23 #include <svx/svdtrans.hxx>
  24 #include <svx/svdetc.hxx>
  25 #include <svx/svdhdl.hxx>
  26 #include <svx/sdr/contact/viewcontactofvirtobj.hxx>
  27 #include <basegfx/matrix/b2dhommatrix.hxx>
  28 #include <svx/svdograf.hxx>
  29 #include <svx/svddrgv.hxx>
  30 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  31
  32 ////////////////////////////////////////////////////////////////////////////////////////////////////
  33
  34 sdr::properties::BaseProperties& SdrVirtObj::GetProperties() const
  35 {
  36     return rRefObj.GetProperties();
  37 }
  38
  39 ////////////////////////////////////////////////////////////////////////////////////////////////////
  40 // #i27224#
  41 sdr::contact::ViewContact* SdrVirtObj::CreateObjectSpecificViewContact()
  42 {
  43     return new sdr::contact::ViewContactOfVirtObj(*this);
  44 }
  45
  46 ////////////////////////////////////////////////////////////////////////////////////////////////////
  47
  48 TYPEINIT1(SdrVirtObj,SdrObject);
  49
  50 SdrVirtObj::SdrVirtObj(SdrObject& rNewObj):
  51     rRefObj(rNewObj)
  52 {
  53     bVirtObj=sal_True; // this is only a virtual object
  54     rRefObj.AddReference(*this);
  55     bClosedObj=rRefObj.IsClosedObj();
  56 }
  57
  58 SdrVirtObj::~SdrVirtObj()
  59 {
  60     rRefObj.DelReference(*this);
  61 }
  62
  63 ////////////////////////////////////////////////////////////////////////////////////////////////////
  64
  65 const SdrObject& SdrVirtObj::GetReferencedObj() const
  66 {
  67     return rRefObj;
  68 }
  69
  70 SdrObject& SdrVirtObj::ReferencedObj()
  71 {
  72     return rRefObj;
  73 }
  74
  75 void SdrVirtObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/)
  76 {
  77     bClosedObj=rRefObj.IsClosedObj();
  78     SetRectsDirty(); // TODO: Optimize this.
  79
  80     // Only a repaint here, rRefObj may have changed and broadcasts
  81     ActionChanged();
  82 }
  83
  84 void SdrVirtObj::NbcSetAnchorPos(const Point& rAnchorPos)
  85 {
  86     aAnchor=rAnchorPos;
  87 }
  88
  89 ////////////////////////////////////////////////////////////////////////////////////////////////////
  90
  91 void SdrVirtObj::SetModel(SdrModel* pNewModel)
  92 {
  93     SdrObject::SetModel(pNewModel);
  94     rRefObj.SetModel(pNewModel);
  95 }
  96
  97 void SdrVirtObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
  98 {
  99     rRefObj.TakeObjInfo(rInfo);
 100 }
 101
 102 sal_uInt32 SdrVirtObj::GetObjInventor() const
 103 {
 104     return rRefObj.GetObjInventor();
 105 }
 106
 107 sal_uInt16 SdrVirtObj::GetObjIdentifier() const
 108 {
 109     return rRefObj.GetObjIdentifier();
 110 }
 111
 112 SdrObjList* SdrVirtObj::GetSubList() const
 113 {
 114     return rRefObj.GetSubList();
 115 }
 116
 117 const Rectangle& SdrVirtObj::GetCurrentBoundRect() const
 118 {
 119     ((SdrVirtObj*)this)->aOutRect=rRefObj.GetCurrentBoundRect(); // TODO: Optimize this.
 120     ((SdrVirtObj*)this)->aOutRect+=aAnchor;
 121     return aOutRect;
 122 }
 123
 124 const Rectangle& SdrVirtObj::GetLastBoundRect() const
 125 {
 126     ((SdrVirtObj*)this)->aOutRect=rRefObj.GetLastBoundRect(); // TODO: Optimize this.
 127     ((SdrVirtObj*)this)->aOutRect+=aAnchor;
 128     return aOutRect;
 129 }
 130
 131 void SdrVirtObj::RecalcBoundRect()
 132 {
 133     aOutRect=rRefObj.GetCurrentBoundRect();
 134     aOutRect+=aAnchor;
 135 }
 136
 137 void SdrVirtObj::SetChanged()
 138 {
 139     SdrObject::SetChanged();
 140 }
 141
 142 SdrVirtObj* SdrVirtObj::Clone() const
 143 {
 144     return new SdrVirtObj(this->rRefObj); // only a further reference
 145 }
 146
 147 SdrVirtObj& SdrVirtObj::operator=(const SdrVirtObj& rObj)
 148 {   // reference different object??
 149     SdrObject::operator=(rObj);
 150     aAnchor=rObj.aAnchor;
 151     return *this;
 152 }
 153
 154 void SdrVirtObj::TakeObjNameSingul(XubString& rName) const
 155 {
 156     rRefObj.TakeObjNameSingul(rName);
 157     rName.Insert(sal_Unicode('['), 0);
 158     rName += sal_Unicode(']');
 159
 160     String aName( GetName() );
 161     if(aName.Len())
 162     {
 163         rName += sal_Unicode(' ');
 164         rName += sal_Unicode('\'');
 165         rName += aName;
 166         rName += sal_Unicode('\'');
 167     }
 168 }
 169
 170 void SdrVirtObj::TakeObjNamePlural(XubString& rName) const
 171 {
 172     rRefObj.TakeObjNamePlural(rName);
 173     rName.Insert(sal_Unicode('['), 0);
 174     rName += sal_Unicode(']');
 175 }
 176
 177 void operator +=(PolyPolygon& rPoly, const Point& rOfs)
 178 {
 179     if (rOfs.X()!=0 || rOfs.Y()!=0) {
 180         sal_uInt16 i,j;
 181         for (j=0; j<rPoly.Count(); j++) {
 182             Polygon aP1(rPoly.GetObject(j));
 183             for (i=0; i<aP1.GetSize(); i++) {
 184                  aP1[i]+=rOfs;
 185             }
 186             rPoly.Replace(aP1,j);
 187         }
 188     }
 189 }
 190
 191 basegfx::B2DPolyPolygon SdrVirtObj::TakeXorPoly() const
 192 {
 193     basegfx::B2DPolyPolygon aPolyPolygon(rRefObj.TakeXorPoly());
 194
 195     if(aAnchor.X() || aAnchor.Y())
 196     {
 197         aPolyPolygon.transform(basegfx::tools::createTranslateB2DHomMatrix(aAnchor.X(), aAnchor.Y()));
 198     }
 199
 200     return aPolyPolygon;
 201 }
 202
 203 ////////////////////////////////////////////////////////////////////////////////////////////////////
 204
 205 sal_uInt32 SdrVirtObj::GetHdlCount() const
 206 {
 207     return rRefObj.GetHdlCount();
 208 }
 209
 210 SdrHdl* SdrVirtObj::GetHdl(sal_uInt32 nHdlNum) const
 211 {
 212     SdrHdl* pHdl=rRefObj.GetHdl(nHdlNum);
 213
 214     // #i73248#
 215     // GetHdl() at SdrObject is not guaranteed to return an object
 216     if(pHdl)
 217     {
 218         Point aP(pHdl->GetPos()+aAnchor);
 219         pHdl->SetPos(aP);
 220     }
 221
 222     return pHdl;
 223 }
 224
 225 sal_uInt32 SdrVirtObj::GetPlusHdlCount(const SdrHdl& rHdl) const
 226 {
 227     return rRefObj.GetPlusHdlCount(rHdl);
 228 }
 229
 230 SdrHdl* SdrVirtObj::GetPlusHdl(const SdrHdl& rHdl, sal_uInt32 nPlNum) const
 231 {
 232     SdrHdl* pHdl=rRefObj.GetPlusHdl(rHdl,nPlNum);
 233     pHdl->SetPos(pHdl->GetPos() + aAnchor);
 234     return pHdl;
 235 }
 236
 237 void SdrVirtObj::AddToHdlList(SdrHdlList& rHdlList) const
 238 {
 239     // #i73248#
 240     // SdrObject::AddToHdlList(rHdlList) is not a good thing to call
 241     // since at SdrPathObj, only AddToHdlList may be used and the call
 242     // will instead use the standard implementation which uses GetHdlCount()
 243     // and GetHdl instead. This is not wrong, but may be much less effective
 244     // and may not be prepared to GetHdl returning NULL
 245
 246     // get handles using AddToHdlList from ref object
 247     SdrHdlList aLocalList(0);
 248     rRefObj.AddToHdlList(aLocalList);
 249     const sal_uInt32 nHdlCount(aLocalList.GetHdlCount());
 250
 251     if(nHdlCount)
 252     {
 253         // translate handles and add them to dest list. They are temporarily part of
 254         // two lists then
 255         const Point aOffset(GetOffset());
 256
 257         for(sal_uInt32 a(0L); a < nHdlCount; a++)
 258         {
 259             SdrHdl* pCandidate = aLocalList.GetHdl(a);
 260             pCandidate->SetPos(pCandidate->GetPos() + aOffset);
 261             rHdlList.AddHdl(pCandidate);
 262         }
 263
 264         // remove them from source list, else they will be deleted when
 265         // source list is deleted
 266         while(aLocalList.GetHdlCount())
 267         {
 268             aLocalList.RemoveHdl(aLocalList.GetHdlCount() - 1L);
 269         }
 270     }
 271 }
 272
 273 ////////////////////////////////////////////////////////////////////////////////////////////////////
 274
 275 bool SdrVirtObj::hasSpecialDrag() const
 276 {
 277     return rRefObj.hasSpecialDrag();
 278 }
 279
 280 bool SdrVirtObj::supportsFullDrag() const
 281 {
 282     return false;
 283 }
 284
 285 SdrObject* SdrVirtObj::getFullDragClone() const
 286 {
 287     static bool bSpecialHandling(false);
 288     SdrObject* pRetval = 0;
 289
 290     if(bSpecialHandling)
 291     {
 292         // special handling for VirtObj. Do not create another
 293         // reference to rRefObj, this would allow to change that
 294         // one on drag. Instead, create a SdrGrafObj for drag containing
 295         // the graphical representation
 296         pRetval = new SdrGrafObj(SdrDragView::GetObjGraphic(GetModel(), this), GetLogicRect());
 297     }
 298     else
 299     {
 300         SdrObject& rReferencedObject = ((SdrVirtObj*)this)->ReferencedObj();
 301         pRetval = new SdrGrafObj(SdrDragView::GetObjGraphic(GetModel(), &rReferencedObject), GetLogicRect());
 302     }
 303
 304     return pRetval;
 305 }
 306
 307 bool SdrVirtObj::beginSpecialDrag(SdrDragStat& rDrag) const
 308 {
 309     return rRefObj.beginSpecialDrag(rDrag);
 310 }
 311
 312 bool SdrVirtObj::applySpecialDrag(SdrDragStat& rDrag)
 313 {
 314     return rRefObj.applySpecialDrag(rDrag);
 315 }
 316
 317 basegfx::B2DPolyPolygon SdrVirtObj::getSpecialDragPoly(const SdrDragStat& rDrag) const
 318 {
 319     return rRefObj.getSpecialDragPoly(rDrag);
 320     // TODO: we don't handle offsets yet!
 321 }
 322
 323 String SdrVirtObj::getSpecialDragComment(const SdrDragStat& rDrag) const
 324 {
 325     return rRefObj.getSpecialDragComment(rDrag);
 326 }
 327
 328 ////////////////////////////////////////////////////////////////////////////////////////////////////
 329
 330 bool SdrVirtObj::BegCreate(SdrDragStat& rStat)
 331 {
 332     return rRefObj.BegCreate(rStat);
 333 }
 334
 335 bool SdrVirtObj::MovCreate(SdrDragStat& rStat)
 336 {
 337     return rRefObj.MovCreate(rStat);
 338 }
 339
 340 bool SdrVirtObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 341 {
 342     return rRefObj.EndCreate(rStat,eCmd);
 343 }
 344
 345 bool SdrVirtObj::BckCreate(SdrDragStat& rStat)
 346 {
 347     return rRefObj.BckCreate(rStat);
 348 }
 349
 350 void SdrVirtObj::BrkCreate(SdrDragStat& rStat)
 351 {
 352     rRefObj.BrkCreate(rStat);
 353 }
 354
 355 basegfx::B2DPolyPolygon SdrVirtObj::TakeCreatePoly(const SdrDragStat& rDrag) const
 356 {
 357     return rRefObj.TakeCreatePoly(rDrag);
 358     // TODO: we don't handle offsets yet!
 359 }
 360
 361 ////////////////////////////////////////////////////////////////////////////////////////////////////
 362
 363 void SdrVirtObj::NbcMove(const Size& rSiz)
 364 {
 365     MovePoint(aAnchor,rSiz);
 366     SetRectsDirty();
 367 }
 368
 369 void SdrVirtObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 370 {
 371     rRefObj.NbcResize(rRef-aAnchor,xFact,yFact);
 372     SetRectsDirty();
 373 }
 374
 375 void SdrVirtObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
 376 {
 377     rRefObj.NbcRotate(rRef-aAnchor,nWink,sn,cs);
 378     SetRectsDirty();
 379 }
 380
 381 void SdrVirtObj::NbcMirror(const Point& rRef1, const Point& rRef2)
 382 {
 383     rRefObj.NbcMirror(rRef1-aAnchor,rRef2-aAnchor);
 384     SetRectsDirty();
 385 }
 386
 387 void SdrVirtObj::NbcShear(const Point& rRef, long nWink, double tn, bool bVShear)
 388 {
 389     rRefObj.NbcShear(rRef-aAnchor,nWink,tn,bVShear);
 390     SetRectsDirty();
 391 }
 392
 393 ////////////////////////////////////////////////////////////////////////////////////////////////////
 394
 395 void SdrVirtObj::Move(const Size& rSiz)
 396 {
 397     if (rSiz.Width()!=0 || rSiz.Height()!=0) {
 398         Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 399         NbcMove(rSiz);
 400         SetChanged();
 401         BroadcastObjectChange();
 402         SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
 403     }
 404 }
 405
 406 void SdrVirtObj::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative)
 407 {
 408     if (xFact.GetNumerator()!=xFact.GetDenominator() || yFact.GetNumerator()!=yFact.GetDenominator()) {
 409         Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 410         rRefObj.Resize(rRef-aAnchor,xFact,yFact, bUnsetRelative);
 411         SetRectsDirty();
 412         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 413     }
 414 }
 415
 416 void SdrVirtObj::Rotate(const Point& rRef, long nWink, double sn, double cs)
 417 {
 418     if (nWink!=0) {
 419         Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 420         rRefObj.Rotate(rRef-aAnchor,nWink,sn,cs);
 421         SetRectsDirty();
 422         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 423     }
 424 }
 425
 426 void SdrVirtObj::Mirror(const Point& rRef1, const Point& rRef2)
 427 {
 428     Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 429     rRefObj.Mirror(rRef1-aAnchor,rRef2-aAnchor);
 430     SetRectsDirty();
 431     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 432 }
 433
 434 void SdrVirtObj::Shear(const Point& rRef, long nWink, double tn, bool bVShear)
 435 {
 436     if (nWink!=0) {
 437         Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 438         rRefObj.Shear(rRef-aAnchor,nWink,tn,bVShear);
 439         SetRectsDirty();
 440         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 441     }
 442 }
 443
 444 ////////////////////////////////////////////////////////////////////////////////////////////////////
 445
 446 void SdrVirtObj::RecalcSnapRect()
 447 {
 448     aSnapRect=rRefObj.GetSnapRect();
 449     aSnapRect+=aAnchor;
 450 }
 451
 452 const Rectangle& SdrVirtObj::GetSnapRect() const
 453 {
 454     ((SdrVirtObj*)this)->aSnapRect=rRefObj.GetSnapRect();
 455     ((SdrVirtObj*)this)->aSnapRect+=aAnchor;
 456     return aSnapRect;
 457 }
 458
 459 void SdrVirtObj::SetSnapRect(const Rectangle& rRect)
 460 {
 461     {
 462         Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 463         Rectangle aR(rRect);
 464         aR-=aAnchor;
 465         rRefObj.SetSnapRect(aR);
 466         SetRectsDirty();
 467         SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 468     }
 469 }
 470
 471 void SdrVirtObj::NbcSetSnapRect(const Rectangle& rRect)
 472 {
 473     Rectangle aR(rRect);
 474     aR-=aAnchor;
 475     SetRectsDirty();
 476     rRefObj.NbcSetSnapRect(aR);
 477 }
 478
 479 ////////////////////////////////////////////////////////////////////////////////////////////////////
 480
 481 const Rectangle& SdrVirtObj::GetLogicRect() const
 482 {
 483     ((SdrVirtObj*)this)->aSnapRect=rRefObj.GetLogicRect();  // An abuse of aSnapRect!
 484     ((SdrVirtObj*)this)->aSnapRect+=aAnchor;                // If there's trouble, we need another Rectangle Member (or a Heap).
 485     return aSnapRect;
 486 }
 487
 488 void SdrVirtObj::SetLogicRect(const Rectangle& rRect)
 489 {
 490     Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 491     Rectangle aR(rRect);
 492     aR-=aAnchor;
 493     rRefObj.SetLogicRect(aR);
 494     SetRectsDirty();
 495     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 496 }
 497
 498 void SdrVirtObj::NbcSetLogicRect(const Rectangle& rRect)
 499 {
 500     Rectangle aR(rRect);
 501     aR-=aAnchor;
 502     SetRectsDirty();
 503     rRefObj.NbcSetLogicRect(aR);
 504 }
 505
 506 ////////////////////////////////////////////////////////////////////////////////////////////////////
 507
 508 long SdrVirtObj::GetRotateAngle() const
 509 {
 510     return rRefObj.GetRotateAngle();
 511 }
 512
 513 long SdrVirtObj::GetShearAngle(bool bVertical) const
 514 {
 515     return rRefObj.GetShearAngle(bVertical);
 516 }
 517
 518 ////////////////////////////////////////////////////////////////////////////////////////////////////
 519
 520 sal_uInt32 SdrVirtObj::GetSnapPointCount() const
 521 {
 522     return rRefObj.GetSnapPointCount();
 523 }
 524
 525 Point SdrVirtObj::GetSnapPoint(sal_uInt32 i) const
 526 {
 527     Point aP(rRefObj.GetSnapPoint(i));
 528     aP+=aAnchor;
 529     return aP;
 530 }
 531
 532 sal_Bool SdrVirtObj::IsPolyObj() const
 533 {
 534     return rRefObj.IsPolyObj();
 535 }
 536
 537 sal_uInt32 SdrVirtObj::GetPointCount() const
 538 {
 539     return rRefObj.GetPointCount();
 540 }
 541
 542 Point SdrVirtObj::GetPoint(sal_uInt32 i) const
 543 {
 544     return Point(rRefObj.GetPoint(i) + aAnchor);
 545 }
 546
 547 void SdrVirtObj::NbcSetPoint(const Point& rPnt, sal_uInt32 i)
 548 {
 549     Point aP(rPnt);
 550     aP-=aAnchor;
 551     rRefObj.SetPoint(aP,i);
 552     SetRectsDirty();
 553 }
 554
 555 ////////////////////////////////////////////////////////////////////////////////////////////////////
 556
 557 SdrObjGeoData* SdrVirtObj::NewGeoData() const
 558 {
 559     return rRefObj.NewGeoData();
 560 }
 561
 562 void SdrVirtObj::SaveGeoData(SdrObjGeoData& rGeo) const
 563 {
 564     rRefObj.SaveGeoData(rGeo);
 565 }
 566
 567 void SdrVirtObj::RestGeoData(const SdrObjGeoData& rGeo)
 568 {
 569     rRefObj.RestGeoData(rGeo);
 570     SetRectsDirty();
 571 }
 572
 573 ////////////////////////////////////////////////////////////////////////////////////////////////////
 574
 575 SdrObjGeoData* SdrVirtObj::GetGeoData() const
 576 {
 577     return rRefObj.GetGeoData();
 578 }
 579
 580 void SdrVirtObj::SetGeoData(const SdrObjGeoData& rGeo)
 581 {
 582     Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
 583     rRefObj.SetGeoData(rGeo);
 584     SetRectsDirty();
 585     SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
 586 }
 587
 588 ////////////////////////////////////////////////////////////////////////////////////////////////////
 589
 590 void SdrVirtObj::NbcReformatText()
 591 {
 592     rRefObj.NbcReformatText();
 593 }
 594
 595 void SdrVirtObj::ReformatText()
 596 {
 597     rRefObj.ReformatText();
 598 }
 599
 600 ////////////////////////////////////////////////////////////////////////////////////////////////////
 601
 602 bool SdrVirtObj::HasMacro() const
 603 {
 604     return rRefObj.HasMacro();
 605 }
 606
 607 SdrObject* SdrVirtObj::CheckMacroHit(const SdrObjMacroHitRec& rRec) const
 608 {
 609     return rRefObj.CheckMacroHit(rRec); // TODO: positioning offset
 610 }
 611
 612 Pointer SdrVirtObj::GetMacroPointer(const SdrObjMacroHitRec& rRec) const
 613 {
 614     return rRefObj.GetMacroPointer(rRec); // TODO: positioning offset
 615 }
 616
 617 void SdrVirtObj::PaintMacro(OutputDevice& rOut, const Rectangle& rDirtyRect, const SdrObjMacroHitRec& rRec) const
 618 {
 619     rRefObj.PaintMacro(rOut,rDirtyRect,rRec); // TODO: positioning offset
 620 }
 621
 622 bool SdrVirtObj::DoMacro(const SdrObjMacroHitRec& rRec)
 623 {
 624     return rRefObj.DoMacro(rRec); // TODO: positioning offset
 625 }
 626
 627 OUString SdrVirtObj::GetMacroPopupComment(const SdrObjMacroHitRec& rRec) const
 628 {
 629     return rRefObj.GetMacroPopupComment(rRec); // TODO: positioning offset
 630 }
 631
 632 const Point SdrVirtObj::GetOffset() const
 633 {
 634     // #i73248# default offset of SdrVirtObj is aAnchor
 635     return aAnchor;
 636 }
 637
 638 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */