svx/source/svdraw/svdovirt.cxx

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