LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdovirt.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 36 297 12.1 %
Date: 2014-11-03 Functions: 15 87 17.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10