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: */
|
