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