svx/source/svdraw/svdovirt.cxx

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