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 : #include <com/sun/star/lang/XComponent.hpp>
21 :
22 : #define _USE_MATH_DEFINES
23 : #include <math.h>
24 : #include <vcl/metaact.hxx> // for TakeContour
25 : #include <vcl/cvtsvm.hxx>
26 : #include <tools/line.hxx>
27 : #include <tools/bigint.hxx>
28 : #include <tools/diagnose_ex.h>
29 : #include <tools/helpers.hxx>
30 : #include <vector>
31 : #include <svx/svdobj.hxx>
32 : #include <svx/xpoly.hxx>
33 : #include <svx/svdetc.hxx>
34 : #include <svx/svdtrans.hxx>
35 : #include <svx/svdhdl.hxx>
36 : #include <svx/svddrag.hxx>
37 : #include <svx/svdmodel.hxx>
38 : #include <svx/svdpage.hxx>
39 : #include <svx/svdovirt.hxx> // for Add/Del Ref
40 : #include <svx/svdview.hxx> // for Dragging (check Ortho)
41 : #include "svx/svdglob.hxx" // StringCache
42 : #include <svx/svdstr.hrc> // the object's name
43 : #include <svx/svdogrp.hxx> // Factory
44 : #include <svx/svdopath.hxx> // Factory
45 : #include <svx/svdoedge.hxx> // Factory
46 : #include <svx/svdorect.hxx> // Factory
47 : #include <svx/svdocirc.hxx> // Factory
48 : #include <svx/svdotext.hxx> // Factory
49 : #include <svx/svdomeas.hxx> // Factory
50 : #include <svx/svdograf.hxx> // Factory
51 : #include <svx/svdoole2.hxx> // Factory
52 : #include <svx/svdocapt.hxx> // Factory
53 : #include <svx/svdopage.hxx> // Factory
54 : #include <svx/svdouno.hxx> // Factory
55 : #include <svx/svdattrx.hxx> // NotPersistItems
56 : #include <svx/svdoashp.hxx>
57 : #include <svx/svdomedia.hxx>
58 : #include <svx/xlnwtit.hxx>
59 : #include <svx/xlnstwit.hxx>
60 : #include <svx/xlnedwit.hxx>
61 : #include <svx/xlnstit.hxx>
62 : #include <svx/xlnedit.hxx>
63 : #include <svx/xlnstcit.hxx>
64 : #include <svx/xlnedcit.hxx>
65 : #include <svx/xlndsit.hxx>
66 : #include <svx/xlnclit.hxx>
67 : #include <svx/xflclit.hxx>
68 : #include <svx/svditer.hxx>
69 : #include <svx/xlntrit.hxx>
70 : #include <svx/xfltrit.hxx>
71 : #include <svx/xflftrit.hxx>
72 : #include "svx/xlinjoit.hxx"
73 : #include <svx/unopage.hxx>
74 : #include <editeng/eeitem.hxx>
75 : #include <svx/xenum.hxx>
76 : #include <svx/xgrad.hxx>
77 : #include <svx/xhatch.hxx>
78 : #include <svx/xflhtit.hxx>
79 : #include <svx/xbtmpit.hxx>
80 : #include <svx/svdpool.hxx>
81 : #include <editeng/editeng.hxx>
82 : #include <svl/whiter.hxx>
83 :
84 : #include <svx/fmmodel.hxx>
85 : #include <sfx2/objsh.hxx>
86 : #include <sfx2/objface.hxx>
87 : #include <vcl/graphictools.hxx>
88 : #include <svtools/colorcfg.hxx>
89 : #include <svx/sdr/properties/emptyproperties.hxx>
90 : #include <svx/sdr/contact/viewcontactofsdrobj.hxx>
91 : #include <svx/sdr/contact/viewcontactofgraphic.hxx>
92 : #include <svx/sdr/contact/objectcontactofobjlistpainter.hxx>
93 : #include <svx/sdr/contact/displayinfo.hxx>
94 : #include <basegfx/polygon/b2dpolygon.hxx>
95 : #include <basegfx/polygon/b2dpolygontools.hxx>
96 : #include <basegfx/matrix/b2dhommatrix.hxx>
97 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
98 : #include <basegfx/range/b2drange.hxx>
99 : #include <svx/unoshape.hxx>
100 : #include <vcl/virdev.hxx>
101 : #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
102 : #include <drawinglayer/processor2d/contourextractor2d.hxx>
103 : #include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
104 : #include <svx/polysc3d.hxx>
105 : #include "svx/svdotable.hxx"
106 : #include "svx/shapepropertynotifier.hxx"
107 : #include <svx/sdrhittesthelper.hxx>
108 : #include <svx/svdundo.hxx>
109 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
110 : #include <svx/sdrobjectfilter.hxx>
111 : #include "svdconv.hxx"
112 :
113 : using namespace ::com::sun::star;
114 :
115 : ////////////////////////////////////////////////////////////////////////////////////////////////////
116 :
117 0 : TYPEINIT0(SdrObjUserCall);
118 :
119 381 : SdrObjUserCall::~SdrObjUserCall()
120 : {
121 381 : }
122 :
123 929 : void SdrObjUserCall::Changed(const SdrObject& /*rObj*/, SdrUserCallType /*eType*/, const Rectangle& /*rOldBoundRect*/)
124 : {
125 929 : }
126 :
127 0 : SdrObjMacroHitRec::SdrObjMacroHitRec() :
128 : pOut(NULL),
129 : pVisiLayer(NULL),
130 : pPageView(NULL),
131 : nTol(0),
132 0 : bDown(false) {}
133 :
134 : ////////////////////////////////////////////////////////////////////////////////////////////////////
135 :
136 0 : TYPEINIT0(SdrObjUserData);
137 :
138 565 : SdrObjUserData::SdrObjUserData(sal_uInt32 nInv, sal_uInt16 nId, sal_uInt16 nVer) :
139 : nInventor(nInv),
140 : nIdentifier(nId),
141 565 : nVersion(nVer) {}
142 :
143 1 : SdrObjUserData::SdrObjUserData(const SdrObjUserData& rData) :
144 : nInventor(rData.nInventor),
145 : nIdentifier(rData.nIdentifier),
146 1 : nVersion(rData.nVersion) {}
147 :
148 510 : SdrObjUserData::~SdrObjUserData() {}
149 :
150 4147 : sal_uInt32 SdrObjUserData::GetInventor() const
151 : {
152 4147 : return nInventor;
153 : }
154 :
155 3484 : sal_uInt16 SdrObjUserData::GetId() const
156 : {
157 3484 : return nIdentifier;
158 : }
159 :
160 0 : bool SdrObjUserData::HasMacro(const SdrObject* /*pObj*/) const
161 : {
162 0 : return false;
163 : }
164 :
165 0 : SdrObject* SdrObjUserData::CheckMacroHit(const SdrObjMacroHitRec& rRec, const SdrObject* pObj) const
166 : {
167 0 : if(pObj)
168 : {
169 0 : if(rRec.pPageView)
170 : {
171 0 : return SdrObjectPrimitiveHit(*pObj, rRec.aPos, rRec.nTol, *rRec.pPageView, rRec.pVisiLayer, false);
172 : }
173 : }
174 :
175 0 : return 0;
176 : }
177 :
178 0 : Pointer SdrObjUserData::GetMacroPointer(const SdrObjMacroHitRec& /*rRec*/, const SdrObject* /*pObj*/) const
179 : {
180 0 : return Pointer(POINTER_REFHAND);
181 : }
182 :
183 0 : void SdrObjUserData::PaintMacro(OutputDevice& rOut, const Rectangle& /*rDirtyRect*/, const SdrObjMacroHitRec& /*rRec*/, const SdrObject* pObj) const
184 : {
185 0 : if(!pObj)
186 0 : return;
187 :
188 0 : const RasterOp eRop(rOut.GetRasterOp());
189 0 : const basegfx::B2DPolyPolygon aPolyPolygon(pObj->TakeXorPoly());
190 0 : const sal_uInt32 nCount(aPolyPolygon.count());
191 :
192 0 : rOut.SetLineColor(COL_BLACK);
193 0 : rOut.SetFillColor();
194 0 : rOut.SetRasterOp(ROP_INVERT);
195 :
196 0 : for(sal_uInt32 a(0); a < nCount; a++)
197 : {
198 0 : rOut.DrawPolyLine(aPolyPolygon.getB2DPolygon(a));
199 : }
200 :
201 0 : rOut.SetRasterOp(eRop);
202 : }
203 :
204 0 : bool SdrObjUserData::DoMacro(const SdrObjMacroHitRec& /*rRec*/, SdrObject* /*pObj*/)
205 : {
206 0 : return false;
207 : }
208 :
209 0 : rtl::OUString SdrObjUserData::GetMacroPopupComment(const SdrObjMacroHitRec& /*rRec*/, const SdrObject* /*pObj*/) const
210 : {
211 0 : return rtl::OUString();
212 : }
213 :
214 560 : SdrObjUserDataList::SdrObjUserDataList() {}
215 504 : SdrObjUserDataList::~SdrObjUserDataList() {}
216 :
217 4148 : size_t SdrObjUserDataList::GetUserDataCount() const
218 : {
219 4148 : return static_cast<sal_uInt16>(maList.size());
220 : }
221 :
222 0 : const SdrObjUserData* SdrObjUserDataList::GetUserData(size_t nNum) const
223 : {
224 0 : return &maList.at(nNum);
225 : }
226 :
227 4148 : SdrObjUserData* SdrObjUserDataList::GetUserData(size_t nNum)
228 : {
229 4148 : return &maList.at(nNum);
230 : }
231 :
232 560 : void SdrObjUserDataList::AppendUserData(SdrObjUserData* pData)
233 : {
234 560 : maList.push_back(pData);
235 560 : }
236 :
237 0 : void SdrObjUserDataList::DeleteUserData(size_t nNum)
238 : {
239 0 : maList.erase(maList.begin()+nNum);
240 0 : }
241 :
242 : ////////////////////////////////////////////////////////////////////////////////////////////////////
243 :
244 : DBG_NAME(SdrObjGeoData);
245 :
246 78 : SdrObjGeoData::SdrObjGeoData():
247 : pGPL(NULL),
248 : bMovProt(false),
249 : bSizProt(false),
250 : bNoPrint(false),
251 : bClosedObj(false),
252 : mbVisible(true),
253 78 : mnLayerID(0)
254 : {
255 : DBG_CTOR(SdrObjGeoData,NULL);
256 78 : }
257 :
258 78 : SdrObjGeoData::~SdrObjGeoData()
259 : {
260 : DBG_DTOR(SdrObjGeoData,NULL);
261 78 : delete pGPL;
262 78 : }
263 :
264 : ////////////////////////////////////////////////////////////////////////////////////////////////////
265 :
266 0 : TYPEINIT0(SdrObjPlusData);
267 :
268 2380 : SdrObjPlusData::SdrObjPlusData():
269 : pBroadcast(NULL),
270 : pUserDataList(NULL),
271 2380 : pGluePoints(NULL)
272 : {
273 2380 : }
274 :
275 6594 : SdrObjPlusData::~SdrObjPlusData()
276 : {
277 2198 : if (pBroadcast !=NULL) delete pBroadcast;
278 2198 : if (pUserDataList!=NULL) delete pUserDataList;
279 2198 : if (pGluePoints !=NULL) delete pGluePoints;
280 4396 : }
281 :
282 2 : SdrObjPlusData* SdrObjPlusData::Clone(SdrObject* pObj1) const
283 : {
284 2 : SdrObjPlusData* pNeuPlusData=new SdrObjPlusData;
285 2 : if (pUserDataList!=NULL) {
286 1 : sal_uInt16 nAnz=pUserDataList->GetUserDataCount();
287 1 : if (nAnz!=0) {
288 1 : pNeuPlusData->pUserDataList=new SdrObjUserDataList;
289 2 : for (sal_uInt16 i=0; i<nAnz; i++) {
290 1 : SdrObjUserData* pNeuUserData=pUserDataList->GetUserData(i)->Clone(pObj1);
291 1 : if (pNeuUserData!=NULL) {
292 1 : pNeuPlusData->pUserDataList->AppendUserData(pNeuUserData);
293 : } else {
294 : OSL_FAIL("SdrObjPlusData::Clone(): UserData.Clone() returns NULL.");
295 : }
296 : }
297 : }
298 : }
299 2 : if (pGluePoints!=NULL) pNeuPlusData->pGluePoints=new SdrGluePointList(*pGluePoints);
300 : // MtfAnimator isn't copied either
301 :
302 : // #i68101#
303 : // copy object name, title and description
304 2 : pNeuPlusData->aObjName = aObjName;
305 2 : pNeuPlusData->aObjTitle = aObjTitle;
306 2 : pNeuPlusData->aObjDescription = aObjDescription;
307 :
308 2 : return pNeuPlusData;
309 : }
310 :
311 0 : void SdrObjPlusData::SetGluePoints(const SdrGluePointList& rPts)
312 : {
313 0 : return *pGluePoints = rPts;
314 : }
315 :
316 0 : SdrObjTransformInfoRec::SdrObjTransformInfoRec() :
317 : bSelectAllowed(true),
318 : bMoveAllowed(true),
319 : bResizeFreeAllowed(true),
320 : bResizePropAllowed(true),
321 : bRotateFreeAllowed(true),
322 : bRotate90Allowed(true),
323 : bMirrorFreeAllowed(true),
324 : bMirror45Allowed(true),
325 : bMirror90Allowed(true),
326 : bTransparenceAllowed(true),
327 : bGradientAllowed(true),
328 : bShearAllowed(true),
329 : bEdgeRadiusAllowed(true),
330 : bNoOrthoDesired(true),
331 : bNoContortion(true),
332 : bCanConvToPath(true),
333 : bCanConvToPoly(true),
334 : bCanConvToContour(false),
335 : bCanConvToPathLineToArea(true),
336 0 : bCanConvToPolyLineToArea(true) {}
337 :
338 : //////////////////////////////////////////////////////////////////////////////
339 : // BaseProperties section
340 :
341 0 : sdr::properties::BaseProperties* SdrObject::CreateObjectSpecificProperties()
342 : {
343 0 : return new sdr::properties::EmptyProperties(*this);
344 : }
345 :
346 302003 : sdr::properties::BaseProperties& SdrObject::GetProperties() const
347 : {
348 302003 : if(!mpProperties)
349 : {
350 : const_cast< SdrObject* >(this)->mpProperties =
351 5457 : const_cast< SdrObject* >(this)->CreateObjectSpecificProperties();
352 : }
353 :
354 302003 : return *mpProperties;
355 : }
356 :
357 : //////////////////////////////////////////////////////////////////////////////
358 : // ObjectUser section
359 :
360 8961 : void SdrObject::AddObjectUser(sdr::ObjectUser& rNewUser)
361 : {
362 8961 : maObjectUsers.push_back(&rNewUser);
363 8961 : }
364 :
365 15678 : void SdrObject::RemoveObjectUser(sdr::ObjectUser& rOldUser)
366 : {
367 15678 : const ::sdr::ObjectUserVector::iterator aFindResult = ::std::find(maObjectUsers.begin(), maObjectUsers.end(), &rOldUser);
368 15678 : if(aFindResult != maObjectUsers.end())
369 : {
370 8490 : maObjectUsers.erase(aFindResult);
371 : }
372 15678 : }
373 :
374 : //////////////////////////////////////////////////////////////////////////////
375 : // DrawContact section
376 :
377 0 : sdr::contact::ViewContact* SdrObject::CreateObjectSpecificViewContact()
378 : {
379 0 : return new sdr::contact::ViewContactOfSdrObj(*this);
380 : }
381 :
382 89165 : sdr::contact::ViewContact& SdrObject::GetViewContact() const
383 : {
384 89165 : if(!mpViewContact)
385 : {
386 : const_cast< SdrObject* >(this)->mpViewContact =
387 5878 : const_cast< SdrObject* >(this)->CreateObjectSpecificViewContact();
388 : }
389 :
390 89165 : return *mpViewContact;
391 : }
392 :
393 : // DrawContact support: Methods for handling Object changes
394 53152 : void SdrObject::ActionChanged() const
395 : {
396 : // Do necessary ViewContact actions
397 53152 : GetViewContact().ActionChanged();
398 53152 : }
399 :
400 : //////////////////////////////////////////////////////////////////////////////
401 :
402 49073 : void SdrObject::SetBoundRectDirty()
403 : {
404 49073 : aOutRect = Rectangle();
405 49073 : }
406 :
407 : //////////////////////////////////////////////////////////////////////////////
408 :
409 : DBG_NAME(SdrObject);
410 124241 : TYPEINIT1(SdrObject,SfxListener);
411 :
412 6022 : SdrObject::SdrObject()
413 : :mpProperties(0L)
414 : ,mpViewContact(0L)
415 : ,pObjList(NULL)
416 : ,pPage(NULL)
417 : ,pModel(NULL)
418 : ,pUserCall(NULL)
419 : ,pPlusData(NULL)
420 : ,nOrdNum(0)
421 : ,mnNavigationPosition(SAL_MAX_UINT32)
422 : ,mnLayerID(0)
423 : ,mpSvxShape( NULL )
424 6022 : ,maWeakUnoShape()
425 : {
426 : DBG_CTOR(SdrObject,NULL);
427 6022 : bVirtObj =false;
428 6022 : bSnapRectDirty =true;
429 6022 : bNetLock =false;
430 6022 : bInserted =false;
431 6022 : bGrouped =false;
432 6022 : bMovProt =false;
433 6022 : bSizProt =false;
434 6022 : bNoPrint =false;
435 6022 : bEmptyPresObj =false;
436 6022 : bNotVisibleAsMaster=false;
437 6022 : bClosedObj =false;
438 6022 : mbVisible = true;
439 :
440 : // #i25616#
441 6022 : mbLineIsOutsideGeometry = false;
442 :
443 : // #i25616#
444 6022 : mbSupportTextIndentingOnLineWidthChange = false;
445 :
446 6022 : bNotMasterCachable=false;
447 6022 : bIsEdge=false;
448 6022 : bIs3DObj=false;
449 6022 : bMarkProt=false;
450 6022 : bIsUnoObj=false;
451 6022 : }
452 :
453 11368 : SdrObject::~SdrObject()
454 : {
455 : // tell all the registered ObjectUsers that the page is in destruction
456 5684 : ::sdr::ObjectUserVector aListCopy(maObjectUsers.begin(), maObjectUsers.end());
457 6108 : for(::sdr::ObjectUserVector::iterator aIterator = aListCopy.begin(); aIterator != aListCopy.end(); ++aIterator)
458 : {
459 424 : sdr::ObjectUser* pObjectUser = *aIterator;
460 : DBG_ASSERT(pObjectUser, "SdrObject::~SdrObject: corrupt ObjectUser list (!)");
461 424 : pObjectUser->ObjectInDestruction(*this);
462 : }
463 :
464 : // Clear the vector. This means that user do not need to call RemoveObjectUser()
465 : // when they get called from ObjectInDestruction().
466 5684 : maObjectUsers.clear();
467 :
468 : try
469 : {
470 5684 : SvxShape* pSvxShape = getSvxShape();
471 5684 : if ( pSvxShape )
472 : {
473 : OSL_ENSURE(!pSvxShape->HasSdrObjectOwnership(),"Please check where this call come from and replace it with SdrObject::Free");
474 644 : pSvxShape->InvalidateSdrObject();
475 644 : uno::Reference< lang::XComponent > xShapeComp( getWeakUnoShape(), uno::UNO_QUERY_THROW );
476 644 : xShapeComp->dispose();
477 : }
478 : }
479 0 : catch( const uno::Exception& )
480 : {
481 : DBG_UNHANDLED_EXCEPTION();
482 : }
483 :
484 : DBG_DTOR(SdrObject,NULL);
485 5684 : SendUserCall(SDRUSERCALL_DELETE, GetLastBoundRect());
486 5684 : if (pPlusData!=NULL) delete pPlusData;
487 :
488 5684 : if(mpProperties)
489 : {
490 5377 : delete mpProperties;
491 5377 : mpProperties = 0L;
492 : }
493 :
494 5684 : if(mpViewContact)
495 : {
496 5613 : delete mpViewContact;
497 5613 : mpViewContact = 0L;
498 5684 : }
499 5684 : }
500 :
501 49623 : void SdrObject::Free( SdrObject*& _rpObject )
502 : {
503 49623 : SdrObject* pObject = _rpObject; _rpObject = NULL;
504 49623 : if ( pObject == NULL )
505 : // nothing to do
506 44142 : return;
507 :
508 5481 : SvxShape* pShape = pObject->getSvxShape();
509 5481 : if ( pShape && pShape->HasSdrObjectOwnership() )
510 : // only the shape is allowed to delete me, and will reset the ownership before doing so
511 0 : return;
512 :
513 5481 : delete pObject;
514 : }
515 :
516 2378 : SdrObjPlusData* SdrObject::NewPlusData() const
517 : {
518 2378 : return new SdrObjPlusData;
519 : }
520 :
521 52721 : void SdrObject::SetRectsDirty(sal_Bool bNotMyself)
522 : {
523 52721 : if (!bNotMyself) {
524 17556 : SetBoundRectDirty();
525 17556 : bSnapRectDirty=true;
526 : }
527 52721 : if (pObjList!=NULL) {
528 25593 : pObjList->SetRectsDirty();
529 : }
530 52721 : }
531 :
532 8549 : void SdrObject::SetModel(SdrModel* pNewModel)
533 : {
534 8549 : if(pNewModel && pPage)
535 : {
536 6226 : if(pPage->GetModel() != pNewModel)
537 : {
538 0 : pPage = NULL;
539 : }
540 : }
541 :
542 : // update listeners at possible API wrapper object
543 8549 : if( pModel != pNewModel )
544 : {
545 5950 : SvxShape* pShape = getSvxShape();
546 5950 : if( pShape )
547 9 : pShape->ChangeModel( pNewModel );
548 : }
549 :
550 8549 : pModel = pNewModel;
551 8549 : }
552 :
553 142074 : SdrModel* SdrObject::GetModel() const
554 : {
555 142074 : return pModel;
556 : }
557 :
558 6396 : void SdrObject::SetObjList(SdrObjList* pNewObjList)
559 : {
560 6396 : pObjList=pNewObjList;
561 6396 : }
562 :
563 57006 : SdrObjList* SdrObject::GetObjList() const
564 : {
565 57006 : return pObjList;
566 : }
567 :
568 10180 : void SdrObject::SetPage(SdrPage* pNewPage)
569 : {
570 10180 : pPage=pNewPage;
571 10180 : if (pPage!=NULL) {
572 8144 : SdrModel* pMod=pPage->GetModel();
573 8144 : if (pMod!=pModel && pMod!=NULL) {
574 4083 : SetModel(pMod);
575 : }}
576 10180 : }
577 :
578 15078 : SdrPage* SdrObject::GetPage() const
579 : {
580 15078 : return pPage;
581 : }
582 :
583 : // init global static itempool
584 : SdrItemPool* SdrObject::mpGlobalItemPool = NULL;
585 :
586 27068 : SdrItemPool& SdrObject::GetGlobalDrawObjectItemPool()
587 : {
588 27068 : if(!mpGlobalItemPool)
589 : {
590 13 : mpGlobalItemPool = new SdrItemPool();
591 13 : SfxItemPool* pGlobalOutlPool = EditEngine::CreatePool();
592 13 : mpGlobalItemPool->SetSecondaryPool(pGlobalOutlPool);
593 13 : mpGlobalItemPool->SetDefaultMetric((SfxMapUnit)SdrEngineDefaults::GetMapUnit());
594 13 : mpGlobalItemPool->FreezeIdRanges();
595 : }
596 :
597 27068 : return *mpGlobalItemPool;
598 : }
599 :
600 45486 : SdrItemPool* SdrObject::GetObjectItemPool() const
601 : {
602 45486 : if(pModel)
603 28699 : return (SdrItemPool*)(&pModel->GetItemPool());
604 :
605 : // use a static global default pool
606 16787 : return &SdrObject::GetGlobalDrawObjectItemPool();
607 : }
608 :
609 59184 : sal_uInt32 SdrObject::GetObjInventor() const
610 : {
611 59184 : return SdrInventor;
612 : }
613 :
614 0 : sal_uInt16 SdrObject::GetObjIdentifier() const
615 : {
616 0 : return sal_uInt16(OBJ_NONE);
617 : }
618 :
619 0 : void SdrObject::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
620 : {
621 0 : rInfo.bRotateFreeAllowed=false;
622 0 : rInfo.bMirrorFreeAllowed=false;
623 0 : rInfo.bTransparenceAllowed = false;
624 0 : rInfo.bGradientAllowed = false;
625 0 : rInfo.bShearAllowed =false;
626 0 : rInfo.bEdgeRadiusAllowed=false;
627 0 : rInfo.bCanConvToPath =false;
628 0 : rInfo.bCanConvToPoly =false;
629 0 : rInfo.bCanConvToContour = false;
630 0 : rInfo.bCanConvToPathLineToArea=false;
631 0 : rInfo.bCanConvToPolyLineToArea=false;
632 0 : }
633 :
634 7903 : SdrLayerID SdrObject::GetLayer() const
635 : {
636 7903 : return mnLayerID;
637 : }
638 :
639 0 : void SdrObject::getMergedHierarchyLayerSet(SetOfByte& rSet) const
640 : {
641 0 : rSet.Set(GetLayer());
642 0 : SdrObjList* pOL=GetSubList();
643 0 : if (pOL!=NULL) {
644 0 : sal_uIntPtr nObjAnz=pOL->GetObjCount();
645 0 : for (sal_uIntPtr nObjNum=0; nObjNum<nObjAnz; nObjNum++) {
646 0 : pOL->GetObj(nObjNum)->getMergedHierarchyLayerSet(rSet);
647 : }
648 : }
649 0 : }
650 :
651 1333 : void SdrObject::NbcSetLayer(SdrLayerID nLayer)
652 : {
653 1333 : if(GetLayer() != nLayer)
654 : {
655 871 : mnLayerID = nLayer;
656 : }
657 1333 : }
658 :
659 831 : void SdrObject::SetLayer(SdrLayerID nLayer)
660 : {
661 831 : NbcSetLayer(nLayer);
662 831 : SetChanged();
663 831 : BroadcastObjectChange();
664 831 : }
665 :
666 191 : void SdrObject::AddListener(SfxListener& rListener)
667 : {
668 191 : ImpForcePlusData();
669 191 : if (pPlusData->pBroadcast==NULL) pPlusData->pBroadcast=new SfxBroadcaster;
670 191 : rListener.StartListening(*pPlusData->pBroadcast);
671 191 : }
672 :
673 75 : void SdrObject::RemoveListener(SfxListener& rListener)
674 : {
675 75 : if (pPlusData!=NULL && pPlusData->pBroadcast!=NULL) {
676 75 : rListener.EndListening(*pPlusData->pBroadcast);
677 75 : if (!pPlusData->pBroadcast->HasListeners()) {
678 75 : delete pPlusData->pBroadcast;
679 75 : pPlusData->pBroadcast=NULL;
680 : }
681 : }
682 75 : }
683 :
684 0 : const SfxBroadcaster* SdrObject::GetBroadcaster() const
685 : {
686 0 : return pPlusData!=NULL ? pPlusData->pBroadcast : NULL;
687 : }
688 :
689 191 : void SdrObject::AddReference(SdrVirtObj& rVrtObj)
690 : {
691 191 : AddListener(rVrtObj);
692 191 : }
693 :
694 75 : void SdrObject::DelReference(SdrVirtObj& rVrtObj)
695 : {
696 75 : RemoveListener(rVrtObj);
697 75 : }
698 :
699 0 : bool SdrObject::HasRefPoint() const
700 : {
701 0 : return false;
702 : }
703 :
704 0 : Point SdrObject::GetRefPoint() const
705 : {
706 0 : return GetCurrentBoundRect().Center();
707 : }
708 :
709 0 : void SdrObject::SetRefPoint(const Point& /*rPnt*/)
710 : {
711 0 : }
712 :
713 5816 : bool SdrObject::IsGroupObject() const
714 : {
715 5816 : return GetSubList()!=NULL;
716 : }
717 :
718 20712 : SdrObjList* SdrObject::GetSubList() const
719 : {
720 20712 : return NULL;
721 : }
722 :
723 333 : SdrObject* SdrObject::GetUpGroup() const
724 : {
725 333 : return pObjList!=NULL ? pObjList->GetOwnerObj() : NULL;
726 : }
727 :
728 1688 : void SdrObject::SetName(const rtl::OUString& rStr)
729 : {
730 1688 : if (!rStr.isEmpty() && !pPlusData)
731 : {
732 1620 : ImpForcePlusData();
733 : }
734 :
735 1688 : if(pPlusData && !pPlusData->aObjName.equals(rStr))
736 : {
737 : // Undo/Redo for setting object's name (#i73249#)
738 1638 : bool bUndo( false );
739 1638 : if ( GetModel() && GetModel()->IsUndoEnabled() )
740 : {
741 64 : bUndo = true;
742 : SdrUndoAction* pUndoAction =
743 64 : GetModel()->GetSdrUndoFactory().CreateUndoObjectStrAttr(
744 : *this,
745 : SdrUndoObjStrAttr::OBJ_NAME,
746 : GetName(),
747 64 : rStr );
748 64 : GetModel()->BegUndo( pUndoAction->GetComment() );
749 64 : GetModel()->AddUndo( pUndoAction );
750 : }
751 1638 : pPlusData->aObjName = rStr;
752 : // Undo/Redo for setting object's name (#i73249#)
753 1638 : if ( bUndo )
754 : {
755 64 : GetModel()->EndUndo();
756 : }
757 1638 : SetChanged();
758 1638 : BroadcastObjectChange();
759 : }
760 1688 : }
761 :
762 2041 : rtl::OUString SdrObject::GetName() const
763 : {
764 2041 : if(pPlusData)
765 : {
766 1270 : return pPlusData->aObjName;
767 : }
768 :
769 771 : return rtl::OUString();
770 : }
771 :
772 1 : void SdrObject::SetTitle(const rtl::OUString& rStr)
773 : {
774 1 : if (!rStr.isEmpty() && !pPlusData)
775 : {
776 0 : ImpForcePlusData();
777 : }
778 :
779 1 : if(pPlusData && pPlusData->aObjTitle != rStr)
780 : {
781 : // Undo/Redo for setting object's title (#i73249#)
782 0 : bool bUndo( false );
783 0 : if ( GetModel() && GetModel()->IsUndoEnabled() )
784 : {
785 0 : bUndo = true;
786 : SdrUndoAction* pUndoAction =
787 0 : GetModel()->GetSdrUndoFactory().CreateUndoObjectStrAttr(
788 : *this,
789 : SdrUndoObjStrAttr::OBJ_TITLE,
790 : GetTitle(),
791 0 : rStr );
792 0 : GetModel()->BegUndo( pUndoAction->GetComment() );
793 0 : GetModel()->AddUndo( pUndoAction );
794 : }
795 0 : pPlusData->aObjTitle = rStr;
796 : // Undo/Redo for setting object's title (#i73249#)
797 0 : if ( bUndo )
798 : {
799 0 : GetModel()->EndUndo();
800 : }
801 0 : SetChanged();
802 0 : BroadcastObjectChange();
803 : }
804 1 : }
805 :
806 82 : rtl::OUString SdrObject::GetTitle() const
807 : {
808 82 : if(pPlusData)
809 : {
810 59 : return pPlusData->aObjTitle;
811 : }
812 :
813 23 : return rtl::OUString();
814 : }
815 :
816 16 : void SdrObject::SetDescription(const rtl::OUString& rStr)
817 : {
818 16 : if (!rStr.isEmpty() && !pPlusData)
819 : {
820 14 : ImpForcePlusData();
821 : }
822 :
823 16 : if(pPlusData && !pPlusData->aObjDescription.equals(rStr))
824 : {
825 : // Undo/Redo for setting object's description (#i73249#)
826 14 : bool bUndo( false );
827 14 : if ( GetModel() && GetModel()->IsUndoEnabled() )
828 : {
829 0 : bUndo = true;
830 : SdrUndoAction* pUndoAction =
831 0 : GetModel()->GetSdrUndoFactory().CreateUndoObjectStrAttr(
832 : *this,
833 : SdrUndoObjStrAttr::OBJ_DESCRIPTION,
834 : GetDescription(),
835 0 : rStr );
836 0 : GetModel()->BegUndo( pUndoAction->GetComment() );
837 0 : GetModel()->AddUndo( pUndoAction );
838 : }
839 14 : pPlusData->aObjDescription = rStr;
840 : // Undo/Redo for setting object's description (#i73249#)
841 14 : if ( bUndo )
842 : {
843 0 : GetModel()->EndUndo();
844 : }
845 14 : SetChanged();
846 14 : BroadcastObjectChange();
847 : }
848 16 : }
849 :
850 100 : rtl::OUString SdrObject::GetDescription() const
851 : {
852 100 : if(pPlusData)
853 : {
854 67 : return pPlusData->aObjDescription;
855 : }
856 :
857 33 : return rtl::OUString();
858 : }
859 :
860 1463 : sal_uInt32 SdrObject::GetOrdNum() const
861 : {
862 1463 : if (pObjList!=NULL) {
863 1463 : if (pObjList->IsObjOrdNumsDirty()) {
864 754 : pObjList->RecalcObjOrdNums();
865 : }
866 0 : } else ((SdrObject*)this)->nOrdNum=0;
867 1463 : return nOrdNum;
868 : }
869 :
870 1081 : sal_uInt32 SdrObject::GetOrdNumDirect() const
871 : {
872 1081 : return nOrdNum;
873 : }
874 :
875 8530 : void SdrObject::SetOrdNum(sal_uInt32 nNum)
876 : {
877 8530 : nOrdNum = nNum;
878 8530 : }
879 :
880 77 : sal_uInt32 SdrObject::GetNavigationPosition (void)
881 : {
882 77 : if (pObjList!=NULL && pObjList->RecalcNavigationPositions())
883 : {
884 0 : return mnNavigationPosition;
885 : }
886 : else
887 77 : return GetOrdNum();
888 : }
889 :
890 :
891 :
892 :
893 0 : void SdrObject::SetNavigationPosition (const sal_uInt32 nNewPosition)
894 : {
895 0 : mnNavigationPosition = nNewPosition;
896 0 : }
897 :
898 :
899 :
900 :
901 : // To make clearer that this method may trigger RecalcBoundRect and thus may be
902 : // expensive and sometimes problematic (inside a bigger object change you will get
903 : // non-useful BoundRects sometimes) I rename that method from GetBoundRect() to
904 : // GetCurrentBoundRect().
905 4721 : const Rectangle& SdrObject::GetCurrentBoundRect() const
906 : {
907 4721 : if(aOutRect.IsEmpty())
908 : {
909 4506 : const_cast< SdrObject* >(this)->RecalcBoundRect();
910 : }
911 :
912 4721 : return aOutRect;
913 : }
914 :
915 : // To have a possibility to get the last calculated BoundRect e.g for producing
916 : // the first rectangle for repaints (old and new need to be used) without forcing
917 : // a RecalcBoundRect (which may be problematical and expensive sometimes) I add here
918 : // a new method for accessing the last BoundRect.
919 28616 : const Rectangle& SdrObject::GetLastBoundRect() const
920 : {
921 28616 : return aOutRect;
922 : }
923 :
924 4837 : void SdrObject::RecalcBoundRect()
925 : {
926 : // #i101680# suppress BoundRect calculations on import(s)
927 4837 : if(pModel && pModel->isLocked())
928 4257 : return;
929 :
930 : // central new method which will calculate the BoundRect using primitive geometry
931 580 : if(aOutRect.IsEmpty())
932 : {
933 566 : const drawinglayer::primitive2d::Primitive2DSequence xPrimitives(GetViewContact().getViewIndependentPrimitive2DSequence());
934 :
935 566 : if(xPrimitives.hasElements())
936 : {
937 : // use neutral ViewInformation and get the range of the primitives
938 330 : const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
939 330 : const basegfx::B2DRange aRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xPrimitives, aViewInformation2D));
940 :
941 330 : if(!aRange.isEmpty())
942 : {
943 : aOutRect = Rectangle(
944 660 : (sal_Int32)floor(aRange.getMinX()), (sal_Int32)floor(aRange.getMinY()),
945 990 : (sal_Int32)ceil(aRange.getMaxX()), (sal_Int32)ceil(aRange.getMaxY()));
946 330 : aOutRect -= GetGridOffset(); // don't include grid offset
947 : return;
948 330 : }
949 566 : }
950 : }
951 : }
952 :
953 32975 : void SdrObject::BroadcastObjectChange() const
954 : {
955 32975 : if( pModel && pModel->isLocked() )
956 63445 : return;
957 :
958 2505 : sal_Bool bPlusDataBroadcast(pPlusData && pPlusData->pBroadcast);
959 2505 : sal_Bool bObjectChange(IsInserted() && pModel);
960 :
961 2505 : if(bPlusDataBroadcast || bObjectChange)
962 : {
963 1666 : SdrHint aHint(*this);
964 :
965 1666 : if(bPlusDataBroadcast)
966 : {
967 0 : pPlusData->pBroadcast->Broadcast(aHint);
968 : }
969 :
970 1666 : if(bObjectChange)
971 : {
972 1666 : pModel->Broadcast(aHint);
973 1666 : }
974 : }
975 : }
976 :
977 45712 : void SdrObject::SetChanged()
978 : {
979 : // For testing purposes, use the new ViewContact for change
980 : // notification now.
981 45712 : ActionChanged();
982 :
983 45712 : if(IsInserted() && pModel)
984 : {
985 23827 : pModel->SetChanged();
986 : }
987 45712 : }
988 :
989 : // tooling for painting a single object to an OutputDevice.
990 13 : bool SdrObject::SingleObjectPainter(OutputDevice& rOut) const
991 : {
992 13 : sdr::contact::SdrObjectVector aObjectVector;
993 13 : aObjectVector.push_back(const_cast< SdrObject* >(this));
994 :
995 13 : sdr::contact::ObjectContactOfObjListPainter aPainter(rOut, aObjectVector, GetPage());
996 13 : sdr::contact::DisplayInfo aDisplayInfo;
997 :
998 13 : aPainter.ProcessDisplay(aDisplayInfo);
999 :
1000 13 : return true;
1001 : }
1002 :
1003 0 : bool SdrObject::LineGeometryUsageIsNecessary() const
1004 : {
1005 0 : XLineStyle eXLS = (XLineStyle)((const XLineStyleItem&)GetMergedItem(XATTR_LINESTYLE)).GetValue();
1006 0 : return (eXLS != XLINE_NONE);
1007 : }
1008 :
1009 0 : SdrObject* SdrObject::Clone() const
1010 : {
1011 0 : return CloneHelper< SdrObject >();
1012 : }
1013 :
1014 4 : SdrObject& SdrObject::operator=(const SdrObject& rObj)
1015 : {
1016 4 : if( this == &rObj )
1017 0 : return *this;
1018 :
1019 4 : if(mpProperties)
1020 : {
1021 0 : delete mpProperties;
1022 0 : mpProperties = 0L;
1023 : }
1024 :
1025 4 : if(mpViewContact)
1026 : {
1027 0 : delete mpViewContact;
1028 0 : mpViewContact = 0L;
1029 : }
1030 :
1031 : // The Clone() method uses the local copy constructor from the individual
1032 : // sdr::properties::BaseProperties class. Since the target class maybe for another
1033 : // draw object, an SdrObject needs to be provided, as in the normal constructor.
1034 4 : mpProperties = &rObj.GetProperties().Clone(*this);
1035 :
1036 4 : pModel =rObj.pModel;
1037 4 : pPage = rObj.pPage;
1038 4 : aOutRect=rObj.aOutRect;
1039 4 : mnLayerID = rObj.mnLayerID;
1040 4 : aAnchor =rObj.aAnchor;
1041 4 : bVirtObj=rObj.bVirtObj;
1042 4 : bSizProt=rObj.bSizProt;
1043 4 : bMovProt=rObj.bMovProt;
1044 4 : bNoPrint=rObj.bNoPrint;
1045 4 : mbVisible=rObj.mbVisible;
1046 4 : bMarkProt=rObj.bMarkProt;
1047 4 : bEmptyPresObj =rObj.bEmptyPresObj;
1048 4 : bNotVisibleAsMaster=rObj.bNotVisibleAsMaster;
1049 4 : bSnapRectDirty=true;
1050 4 : bNotMasterCachable=rObj.bNotMasterCachable;
1051 4 : delete pPlusData;
1052 4 : pPlusData=NULL;
1053 4 : if (rObj.pPlusData!=NULL) {
1054 2 : pPlusData=rObj.pPlusData->Clone(this);
1055 : }
1056 4 : if (pPlusData!=NULL && pPlusData->pBroadcast!=NULL) {
1057 0 : delete pPlusData->pBroadcast; // broadcaster isn't copied
1058 0 : pPlusData->pBroadcast=NULL;
1059 : }
1060 4 : aGridOffset = rObj.aGridOffset;
1061 4 : return *this;
1062 : }
1063 :
1064 0 : void SdrObject::TakeObjNameSingul(XubString& rName) const
1065 : {
1066 0 : rName=ImpGetResStr(STR_ObjNameSingulNONE);
1067 :
1068 0 : String aName( GetName() );
1069 0 : if(aName.Len())
1070 : {
1071 0 : rName += sal_Unicode(' ');
1072 0 : rName += sal_Unicode('\'');
1073 0 : rName += aName;
1074 0 : rName += sal_Unicode('\'');
1075 0 : }
1076 0 : }
1077 :
1078 0 : void SdrObject::TakeObjNamePlural(XubString& rName) const
1079 : {
1080 0 : rName=ImpGetResStr(STR_ObjNamePluralNONE);
1081 0 : }
1082 :
1083 0 : void SdrObject::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, rtl::OUString& rStr, sal_uInt16 nVal) const
1084 : {
1085 0 : rStr = ImpGetResStr(nStrCacheID);
1086 0 : sal_Int32 nPos = rStr.indexOf("%1");
1087 0 : if (nPos >= 0)
1088 : {
1089 : // Replace '%1' with the object name.
1090 0 : XubString aObjName;
1091 0 : TakeObjNameSingul(aObjName);
1092 0 : rStr = rStr.replaceAt(nPos, 2, aObjName);
1093 : }
1094 :
1095 0 : nPos = rStr.indexOf("%2");
1096 0 : if (nPos >= 0)
1097 : // Replace '%2' with the passed value.
1098 : rStr = rStr.replaceAt(
1099 0 : nPos, 2, rtl::OUString::valueOf(static_cast<sal_Int32>(nVal)));
1100 0 : }
1101 :
1102 2392 : void SdrObject::ImpForcePlusData()
1103 : {
1104 2392 : if (!pPlusData)
1105 2378 : pPlusData = NewPlusData();
1106 2392 : }
1107 :
1108 0 : rtl::OUString SdrObject::GetWinkStr(long nWink, bool bNoDegChar) const
1109 : {
1110 0 : rtl::OUString aStr;
1111 0 : if (pModel!=NULL) {
1112 0 : pModel->TakeWinkStr(nWink,aStr,bNoDegChar);
1113 : }
1114 0 : return aStr;
1115 : }
1116 :
1117 0 : rtl::OUString SdrObject::GetMetrStr(long nVal, MapUnit /*eWantMap*/, bool bNoUnitChars) const
1118 : {
1119 0 : rtl::OUString aStr;
1120 0 : if (pModel!=NULL) {
1121 0 : pModel->TakeMetricStr(nVal,aStr,bNoUnitChars);
1122 : }
1123 0 : return aStr;
1124 : }
1125 :
1126 0 : basegfx::B2DPolyPolygon SdrObject::TakeXorPoly() const
1127 : {
1128 0 : basegfx::B2DPolyPolygon aRetval;
1129 0 : const Rectangle aR(GetCurrentBoundRect());
1130 0 : const basegfx::B2DRange aRange(aR.Left(), aR.Top(), aR.Right(), aR.Bottom());
1131 0 : aRetval.append(basegfx::tools::createPolygonFromRect(aRange));
1132 :
1133 0 : return aRetval;
1134 : }
1135 :
1136 0 : basegfx::B2DPolyPolygon SdrObject::TakeContour() const
1137 : {
1138 0 : basegfx::B2DPolyPolygon aRetval;
1139 :
1140 : // create cloned object without text, but with XLINE_SOLID,
1141 : // COL_BLACK as line color and XFILL_NONE
1142 0 : SdrObject* pClone = Clone();
1143 :
1144 0 : if(pClone)
1145 : {
1146 0 : const SdrTextObj* pTextObj = dynamic_cast< const SdrTextObj* >(this);
1147 :
1148 0 : if(pTextObj)
1149 : {
1150 : // no text and no text animation
1151 0 : pClone->SetMergedItem(SdrTextAniKindItem(SDRTEXTANI_NONE));
1152 0 : pClone->SetOutlinerParaObject(0);
1153 : }
1154 :
1155 0 : const SdrEdgeObj* pEdgeObj = dynamic_cast< const SdrEdgeObj* >(this);
1156 :
1157 0 : if(pEdgeObj)
1158 : {
1159 : // create connections if connector, will be cleaned up when
1160 : // deleting the connector again
1161 0 : SdrObject* pLeft = pEdgeObj->GetConnectedNode(true);
1162 0 : SdrObject* pRight = pEdgeObj->GetConnectedNode(false);
1163 :
1164 0 : if(pLeft)
1165 : {
1166 0 : pClone->ConnectToNode(true, pLeft);
1167 : }
1168 :
1169 0 : if(pRight)
1170 : {
1171 0 : pClone->ConnectToNode(false, pRight);
1172 : }
1173 : }
1174 :
1175 0 : SfxItemSet aNewSet(*GetObjectItemPool());
1176 :
1177 : // #i101980# ignore LineWidth; that's what the old implementation
1178 : // did. With line width, the result may be huge due to fat/thick
1179 : // line decompositions
1180 0 : aNewSet.Put(XLineWidthItem(0));
1181 :
1182 : // solid black lines and no fill
1183 0 : aNewSet.Put(XLineStyleItem(XLINE_SOLID));
1184 0 : aNewSet.Put(XLineColorItem(String(), Color(COL_BLACK)));
1185 0 : aNewSet.Put(XFillStyleItem(XFILL_NONE));
1186 0 : pClone->SetMergedItemSet(aNewSet);
1187 :
1188 : // get sequence from clone
1189 0 : const sdr::contact::ViewContact& rVC(pClone->GetViewContact());
1190 0 : const drawinglayer::primitive2d::Primitive2DSequence xSequence(rVC.getViewIndependentPrimitive2DSequence());
1191 :
1192 0 : if(xSequence.hasElements())
1193 : {
1194 : // use neutral ViewInformation
1195 0 : const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
1196 :
1197 : // create extractor, process and get result (with hairlines as opened polygons)
1198 0 : drawinglayer::processor2d::ContourExtractor2D aExtractor(aViewInformation2D, false);
1199 0 : aExtractor.process(xSequence);
1200 0 : const basegfx::B2DPolyPolygonVector& rResult(aExtractor.getExtractedContour());
1201 0 : const sal_uInt32 nSize(rResult.size());
1202 :
1203 : // when count is one, it is implied that the object has only its normal
1204 : // contour anyways and TakeCountour() is to return an empty PolyPolygon
1205 : // (see old implementation for historical reasons)
1206 0 : if(nSize > 1)
1207 : {
1208 : // the topology for contour is correctly a vector of PolyPolygons; for
1209 : // historical reasons cut it back to a single PolyPolygon here
1210 0 : for(sal_uInt32 a(0); a < nSize; a++)
1211 : {
1212 0 : aRetval.append(rResult[a]);
1213 : }
1214 0 : }
1215 : }
1216 :
1217 0 : delete pClone;
1218 : }
1219 :
1220 0 : return aRetval;
1221 : }
1222 :
1223 0 : sal_uInt32 SdrObject::GetHdlCount() const
1224 : {
1225 0 : return 8L;
1226 : }
1227 :
1228 0 : SdrHdl* SdrObject::GetHdl(sal_uInt32 nHdlNum) const
1229 : {
1230 0 : SdrHdl* pH=NULL;
1231 0 : const Rectangle& rR=GetSnapRect();
1232 0 : switch (nHdlNum) {
1233 0 : case 0: pH=new SdrHdl(rR.TopLeft(), HDL_UPLFT); break;
1234 0 : case 1: pH=new SdrHdl(rR.TopCenter(), HDL_UPPER); break;
1235 0 : case 2: pH=new SdrHdl(rR.TopRight(), HDL_UPRGT); break;
1236 0 : case 3: pH=new SdrHdl(rR.LeftCenter(), HDL_LEFT ); break;
1237 0 : case 4: pH=new SdrHdl(rR.RightCenter(), HDL_RIGHT); break;
1238 0 : case 5: pH=new SdrHdl(rR.BottomLeft(), HDL_LWLFT); break;
1239 0 : case 6: pH=new SdrHdl(rR.BottomCenter(),HDL_LOWER); break;
1240 0 : case 7: pH=new SdrHdl(rR.BottomRight(), HDL_LWRGT); break;
1241 : }
1242 0 : return pH;
1243 : }
1244 :
1245 0 : sal_uInt32 SdrObject::GetPlusHdlCount(const SdrHdl& /*rHdl*/) const
1246 : {
1247 0 : return 0L;
1248 : }
1249 :
1250 0 : SdrHdl* SdrObject::GetPlusHdl(const SdrHdl& /*rHdl*/, sal_uInt32 /*nPlNum*/) const
1251 : {
1252 0 : return 0L;
1253 : }
1254 :
1255 0 : void SdrObject::AddToHdlList(SdrHdlList& rHdlList) const
1256 : {
1257 0 : sal_uInt32 nAnz=GetHdlCount();
1258 0 : for (sal_uInt32 i=0L; i<nAnz; i++) {
1259 0 : SdrHdl* pHdl=GetHdl(i);
1260 0 : if (pHdl!=NULL) {
1261 0 : rHdlList.AddHdl(pHdl);
1262 : }
1263 : }
1264 0 : }
1265 :
1266 0 : Rectangle SdrObject::ImpDragCalcRect(const SdrDragStat& rDrag) const
1267 : {
1268 0 : Rectangle aTmpRect(GetSnapRect());
1269 0 : Rectangle aRect(aTmpRect);
1270 0 : const SdrHdl* pHdl=rDrag.GetHdl();
1271 0 : SdrHdlKind eHdl=pHdl==NULL ? HDL_MOVE : pHdl->GetKind();
1272 0 : bool bEcke=(eHdl==HDL_UPLFT || eHdl==HDL_UPRGT || eHdl==HDL_LWLFT || eHdl==HDL_LWRGT);
1273 0 : bool bOrtho=rDrag.GetView()!=NULL && rDrag.GetView()->IsOrtho();
1274 0 : bool bBigOrtho=bEcke && bOrtho && rDrag.GetView()->IsBigOrtho();
1275 0 : Point aPos(rDrag.GetNow());
1276 0 : bool bLft=(eHdl==HDL_UPLFT || eHdl==HDL_LEFT || eHdl==HDL_LWLFT);
1277 0 : bool bRgt=(eHdl==HDL_UPRGT || eHdl==HDL_RIGHT || eHdl==HDL_LWRGT);
1278 0 : bool bTop=(eHdl==HDL_UPRGT || eHdl==HDL_UPPER || eHdl==HDL_UPLFT);
1279 0 : bool bBtm=(eHdl==HDL_LWRGT || eHdl==HDL_LOWER || eHdl==HDL_LWLFT);
1280 0 : if (bLft) aTmpRect.Left() =aPos.X();
1281 0 : if (bRgt) aTmpRect.Right() =aPos.X();
1282 0 : if (bTop) aTmpRect.Top() =aPos.Y();
1283 0 : if (bBtm) aTmpRect.Bottom()=aPos.Y();
1284 0 : if (bOrtho) { // Ortho
1285 0 : long nWdt0=aRect.Right() -aRect.Left();
1286 0 : long nHgt0=aRect.Bottom()-aRect.Top();
1287 0 : long nXMul=aTmpRect.Right() -aTmpRect.Left();
1288 0 : long nYMul=aTmpRect.Bottom()-aTmpRect.Top();
1289 0 : long nXDiv=nWdt0;
1290 0 : long nYDiv=nHgt0;
1291 0 : bool bXNeg=(nXMul<0)!=(nXDiv<0);
1292 0 : bool bYNeg=(nYMul<0)!=(nYDiv<0);
1293 0 : nXMul=Abs(nXMul);
1294 0 : nYMul=Abs(nYMul);
1295 0 : nXDiv=Abs(nXDiv);
1296 0 : nYDiv=Abs(nYDiv);
1297 0 : Fraction aXFact(nXMul,nXDiv); // fractions for canceling
1298 0 : Fraction aYFact(nYMul,nYDiv); // and for comparing
1299 0 : nXMul=aXFact.GetNumerator();
1300 0 : nYMul=aYFact.GetNumerator();
1301 0 : nXDiv=aXFact.GetDenominator();
1302 0 : nYDiv=aYFact.GetDenominator();
1303 0 : if (bEcke) { // corner point handles
1304 0 : bool bUseX=(aXFact<aYFact) != bBigOrtho;
1305 0 : if (bUseX) {
1306 0 : long nNeed=long(BigInt(nHgt0)*BigInt(nXMul)/BigInt(nXDiv));
1307 0 : if (bYNeg) nNeed=-nNeed;
1308 0 : if (bTop) aTmpRect.Top()=aTmpRect.Bottom()-nNeed;
1309 0 : if (bBtm) aTmpRect.Bottom()=aTmpRect.Top()+nNeed;
1310 : } else {
1311 0 : long nNeed=long(BigInt(nWdt0)*BigInt(nYMul)/BigInt(nYDiv));
1312 0 : if (bXNeg) nNeed=-nNeed;
1313 0 : if (bLft) aTmpRect.Left()=aTmpRect.Right()-nNeed;
1314 0 : if (bRgt) aTmpRect.Right()=aTmpRect.Left()+nNeed;
1315 : }
1316 : } else { // apex handles
1317 0 : if ((bLft || bRgt) && nXDiv!=0) {
1318 0 : long nHgt0b=aRect.Bottom()-aRect.Top();
1319 0 : long nNeed=long(BigInt(nHgt0b)*BigInt(nXMul)/BigInt(nXDiv));
1320 0 : aTmpRect.Top()-=(nNeed-nHgt0b)/2;
1321 0 : aTmpRect.Bottom()=aTmpRect.Top()+nNeed;
1322 : }
1323 0 : if ((bTop || bBtm) && nYDiv!=0) {
1324 0 : long nWdt0b=aRect.Right()-aRect.Left();
1325 0 : long nNeed=long(BigInt(nWdt0b)*BigInt(nYMul)/BigInt(nYDiv));
1326 0 : aTmpRect.Left()-=(nNeed-nWdt0b)/2;
1327 0 : aTmpRect.Right()=aTmpRect.Left()+nNeed;
1328 : }
1329 : }
1330 : }
1331 0 : aTmpRect.Justify();
1332 0 : return aTmpRect;
1333 : }
1334 :
1335 : ////////////////////////////////////////////////////////////////////////////////////////////////////
1336 :
1337 3 : bool SdrObject::hasSpecialDrag() const
1338 : {
1339 3 : return false;
1340 : }
1341 :
1342 0 : bool SdrObject::supportsFullDrag() const
1343 : {
1344 0 : return true;
1345 : }
1346 :
1347 0 : SdrObject* SdrObject::getFullDragClone() const
1348 : {
1349 : // default uses simple clone
1350 0 : return Clone();
1351 : }
1352 :
1353 0 : bool SdrObject::beginSpecialDrag(SdrDragStat& rDrag) const
1354 : {
1355 0 : const SdrHdl* pHdl = rDrag.GetHdl();
1356 :
1357 0 : SdrHdlKind eHdl = (pHdl == NULL) ? HDL_MOVE : pHdl->GetKind();
1358 :
1359 0 : if(eHdl==HDL_UPLFT || eHdl==HDL_UPPER || eHdl==HDL_UPRGT ||
1360 : eHdl==HDL_LEFT || eHdl==HDL_RIGHT || eHdl==HDL_LWLFT ||
1361 : eHdl==HDL_LOWER || eHdl==HDL_LWRGT)
1362 : {
1363 0 : return true;
1364 : }
1365 :
1366 0 : return false;
1367 : }
1368 :
1369 0 : bool SdrObject::applySpecialDrag(SdrDragStat& rDrag)
1370 : {
1371 0 : Rectangle aNewRect(ImpDragCalcRect(rDrag));
1372 :
1373 0 : if(aNewRect != GetSnapRect())
1374 : {
1375 0 : NbcSetSnapRect(aNewRect);
1376 : }
1377 :
1378 0 : return true;
1379 : }
1380 :
1381 0 : String SdrObject::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const
1382 : {
1383 0 : return String();
1384 : }
1385 :
1386 0 : basegfx::B2DPolyPolygon SdrObject::getSpecialDragPoly(const SdrDragStat& /*rDrag*/) const
1387 : {
1388 : // default has nothing to add
1389 0 : return basegfx::B2DPolyPolygon();
1390 : }
1391 :
1392 : ////////////////////////////////////////////////////////////////////////////////////////////////////
1393 : // Create
1394 0 : bool SdrObject::BegCreate(SdrDragStat& rStat)
1395 : {
1396 0 : rStat.SetOrtho4Possible();
1397 0 : Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
1398 0 : aRect1.Justify();
1399 0 : rStat.SetActionRect(aRect1);
1400 0 : aOutRect = aRect1;
1401 0 : return true;
1402 : }
1403 :
1404 0 : bool SdrObject::MovCreate(SdrDragStat& rStat)
1405 : {
1406 0 : rStat.TakeCreateRect(aOutRect);
1407 0 : rStat.SetActionRect(aOutRect);
1408 0 : aOutRect.Justify();
1409 :
1410 0 : return true;
1411 : }
1412 :
1413 0 : bool SdrObject::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1414 : {
1415 0 : rStat.TakeCreateRect(aOutRect);
1416 0 : aOutRect.Justify();
1417 :
1418 0 : return (eCmd==SDRCREATE_FORCEEND || rStat.GetPointAnz()>=2);
1419 : }
1420 :
1421 0 : void SdrObject::BrkCreate(SdrDragStat& /*rStat*/)
1422 : {
1423 0 : }
1424 :
1425 0 : bool SdrObject::BckCreate(SdrDragStat& /*rStat*/)
1426 : {
1427 0 : return false;
1428 : }
1429 :
1430 0 : basegfx::B2DPolyPolygon SdrObject::TakeCreatePoly(const SdrDragStat& rDrag) const
1431 : {
1432 0 : Rectangle aRect1;
1433 0 : rDrag.TakeCreateRect(aRect1);
1434 0 : aRect1.Justify();
1435 :
1436 0 : basegfx::B2DPolyPolygon aRetval;
1437 0 : const basegfx::B2DRange aRange(aRect1.Left(), aRect1.Top(), aRect1.Right(), aRect1.Bottom());
1438 0 : aRetval.append(basegfx::tools::createPolygonFromRect(aRange));
1439 0 : return aRetval;
1440 : }
1441 :
1442 0 : Pointer SdrObject::GetCreatePointer() const
1443 : {
1444 0 : return Pointer(POINTER_CROSS);
1445 : }
1446 :
1447 : // transformations
1448 0 : void SdrObject::NbcMove(const Size& rSiz)
1449 : {
1450 0 : MoveRect(aOutRect,rSiz);
1451 0 : SetRectsDirty();
1452 0 : }
1453 :
1454 0 : void SdrObject::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
1455 : {
1456 0 : bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0);
1457 0 : bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0);
1458 0 : if (bXMirr || bYMirr) {
1459 0 : Point aRef1(GetSnapRect().Center());
1460 0 : if (bXMirr) {
1461 0 : Point aRef2(aRef1);
1462 0 : aRef2.Y()++;
1463 0 : NbcMirrorGluePoints(aRef1,aRef2);
1464 : }
1465 0 : if (bYMirr) {
1466 0 : Point aRef2(aRef1);
1467 0 : aRef2.X()++;
1468 0 : NbcMirrorGluePoints(aRef1,aRef2);
1469 : }
1470 : }
1471 0 : ResizeRect(aOutRect,rRef,xFact,yFact);
1472 0 : SetRectsDirty();
1473 0 : }
1474 :
1475 0 : void SdrObject::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
1476 : {
1477 0 : SetGlueReallyAbsolute(true);
1478 0 : aOutRect.Move(-rRef.X(),-rRef.Y());
1479 0 : Rectangle R(aOutRect);
1480 0 : if (sn==1.0 && cs==0.0) { // 90deg
1481 0 : aOutRect.Left() =-R.Bottom();
1482 0 : aOutRect.Right() =-R.Top();
1483 0 : aOutRect.Top() =R.Left();
1484 0 : aOutRect.Bottom()=R.Right();
1485 0 : } else if (sn==0.0 && cs==-1.0) { // 180deg
1486 0 : aOutRect.Left() =-R.Right();
1487 0 : aOutRect.Right() =-R.Left();
1488 0 : aOutRect.Top() =-R.Bottom();
1489 0 : aOutRect.Bottom()=-R.Top();
1490 0 : } else if (sn==-1.0 && cs==0.0) { // 270deg
1491 0 : aOutRect.Left() =R.Top();
1492 0 : aOutRect.Right() =R.Bottom();
1493 0 : aOutRect.Top() =-R.Right();
1494 0 : aOutRect.Bottom()=-R.Left();
1495 : }
1496 0 : aOutRect.Move(rRef.X(),rRef.Y());
1497 0 : aOutRect.Justify(); // just in case
1498 0 : SetRectsDirty();
1499 0 : NbcRotateGluePoints(rRef,nWink,sn,cs);
1500 0 : SetGlueReallyAbsolute(false);
1501 0 : }
1502 :
1503 0 : void SdrObject::NbcMirror(const Point& rRef1, const Point& rRef2)
1504 : {
1505 0 : SetGlueReallyAbsolute(true);
1506 0 : aOutRect.Move(-rRef1.X(),-rRef1.Y());
1507 0 : Rectangle R(aOutRect);
1508 0 : long dx=rRef2.X()-rRef1.X();
1509 0 : long dy=rRef2.Y()-rRef1.Y();
1510 0 : if (dx==0) { // vertical axis
1511 0 : aOutRect.Left() =-R.Right();
1512 0 : aOutRect.Right()=-R.Left();
1513 0 : } else if (dy==0) { // horizontal axis
1514 0 : aOutRect.Top() =-R.Bottom();
1515 0 : aOutRect.Bottom()=-R.Top();
1516 0 : } else if (dx==dy) { // 45deg axis
1517 0 : aOutRect.Left() =R.Top();
1518 0 : aOutRect.Right() =R.Bottom();
1519 0 : aOutRect.Top() =R.Left();
1520 0 : aOutRect.Bottom()=R.Right();
1521 0 : } else if (dx==-dy) { // 45deg axis
1522 0 : aOutRect.Left() =-R.Bottom();
1523 0 : aOutRect.Right() =-R.Top();
1524 0 : aOutRect.Top() =-R.Right();
1525 0 : aOutRect.Bottom()=-R.Left();
1526 : }
1527 0 : aOutRect.Move(rRef1.X(),rRef1.Y());
1528 0 : aOutRect.Justify(); // just in case
1529 0 : SetRectsDirty();
1530 0 : NbcMirrorGluePoints(rRef1,rRef2);
1531 0 : SetGlueReallyAbsolute(false);
1532 0 : }
1533 :
1534 0 : void SdrObject::NbcShear(const Point& rRef, long nWink, double tn, bool bVShear)
1535 : {
1536 0 : SetGlueReallyAbsolute(true);
1537 0 : NbcShearGluePoints(rRef,nWink,tn,bVShear);
1538 0 : SetGlueReallyAbsolute(false);
1539 0 : }
1540 :
1541 6121 : void SdrObject::Move(const Size& rSiz)
1542 : {
1543 6121 : if (rSiz.Width()!=0 || rSiz.Height()!=0) {
1544 2426 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1545 2426 : NbcMove(rSiz);
1546 2426 : SetChanged();
1547 2426 : BroadcastObjectChange();
1548 2426 : SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
1549 : }
1550 6121 : }
1551 :
1552 5 : void SdrObject::Resize(const Point& rRef, const Fraction& xFact, const Fraction& yFact, bool bUnsetRelative)
1553 : {
1554 5 : if (xFact.GetNumerator()!=xFact.GetDenominator() || yFact.GetNumerator()!=yFact.GetDenominator()) {
1555 5 : if (bUnsetRelative)
1556 : {
1557 4 : mnRelativeWidth.reset( );
1558 4 : mnRelativeHeight.reset( );
1559 : }
1560 5 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1561 5 : NbcResize(rRef,xFact,yFact);
1562 5 : SetChanged();
1563 5 : BroadcastObjectChange();
1564 5 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1565 : }
1566 5 : }
1567 :
1568 6 : void SdrObject::Rotate(const Point& rRef, long nWink, double sn, double cs)
1569 : {
1570 6 : if (nWink!=0) {
1571 6 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1572 6 : NbcRotate(rRef,nWink,sn,cs);
1573 6 : SetChanged();
1574 6 : BroadcastObjectChange();
1575 6 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1576 : }
1577 6 : }
1578 :
1579 0 : void SdrObject::Mirror(const Point& rRef1, const Point& rRef2)
1580 : {
1581 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1582 0 : NbcMirror(rRef1,rRef2);
1583 0 : SetChanged();
1584 0 : BroadcastObjectChange();
1585 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1586 0 : }
1587 :
1588 0 : void SdrObject::Shear(const Point& rRef, long nWink, double tn, bool bVShear)
1589 : {
1590 0 : if (nWink!=0) {
1591 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1592 0 : NbcShear(rRef,nWink,tn,bVShear);
1593 0 : SetChanged();
1594 0 : BroadcastObjectChange();
1595 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1596 : }
1597 0 : }
1598 :
1599 0 : void SdrObject::NbcSetRelativePos(const Point& rPnt)
1600 : {
1601 0 : Point aRelPos0(GetSnapRect().TopLeft()-aAnchor);
1602 0 : Size aSiz(rPnt.X()-aRelPos0.X(),rPnt.Y()-aRelPos0.Y());
1603 0 : NbcMove(aSiz); // This also calls SetRectsDirty()
1604 0 : }
1605 :
1606 0 : void SdrObject::SetRelativePos(const Point& rPnt)
1607 : {
1608 0 : if (rPnt!=GetRelativePos()) {
1609 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1610 0 : NbcSetRelativePos(rPnt);
1611 0 : SetChanged();
1612 0 : BroadcastObjectChange();
1613 0 : SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
1614 : }
1615 0 : }
1616 :
1617 0 : Point SdrObject::GetRelativePos() const
1618 : {
1619 0 : return GetSnapRect().TopLeft()-aAnchor;
1620 : }
1621 :
1622 0 : void SdrObject::ImpSetAnchorPos(const Point& rPnt)
1623 : {
1624 0 : aAnchor = rPnt;
1625 0 : }
1626 :
1627 49 : void SdrObject::NbcSetAnchorPos(const Point& rPnt)
1628 : {
1629 49 : Size aSiz(rPnt.X()-aAnchor.X(),rPnt.Y()-aAnchor.Y());
1630 49 : aAnchor=rPnt;
1631 49 : NbcMove(aSiz); // This also calls SetRectsDirty()
1632 49 : }
1633 :
1634 60 : void SdrObject::SetAnchorPos(const Point& rPnt)
1635 : {
1636 60 : if (rPnt!=aAnchor) {
1637 49 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1638 49 : NbcSetAnchorPos(rPnt);
1639 49 : SetChanged();
1640 49 : BroadcastObjectChange();
1641 49 : SendUserCall(SDRUSERCALL_MOVEONLY,aBoundRect0);
1642 : }
1643 60 : }
1644 :
1645 3764 : const Point& SdrObject::GetAnchorPos() const
1646 : {
1647 3764 : return aAnchor;
1648 : }
1649 :
1650 0 : void SdrObject::RecalcSnapRect()
1651 : {
1652 0 : }
1653 :
1654 198 : const Rectangle& SdrObject::GetSnapRect() const
1655 : {
1656 198 : return aOutRect;
1657 : }
1658 :
1659 167 : void SdrObject::NbcSetSnapRect(const Rectangle& rRect)
1660 : {
1661 167 : aOutRect=rRect;
1662 167 : }
1663 :
1664 30 : const Rectangle& SdrObject::GetLogicRect() const
1665 : {
1666 30 : return GetSnapRect();
1667 : }
1668 :
1669 152 : void SdrObject::NbcSetLogicRect(const Rectangle& rRect)
1670 : {
1671 152 : NbcSetSnapRect(rRect);
1672 152 : }
1673 :
1674 86 : void SdrObject::AdjustToMaxRect( const Rectangle& rMaxRect, bool /* bShrinkOnly = false */ )
1675 : {
1676 86 : SetLogicRect( rMaxRect );
1677 86 : }
1678 :
1679 4416 : void SdrObject::SetSnapRect(const Rectangle& rRect)
1680 : {
1681 4416 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1682 4416 : NbcSetSnapRect(rRect);
1683 4416 : SetChanged();
1684 4416 : BroadcastObjectChange();
1685 4416 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1686 4416 : }
1687 :
1688 2829 : void SdrObject::SetLogicRect(const Rectangle& rRect)
1689 : {
1690 2829 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1691 2829 : NbcSetLogicRect(rRect);
1692 2829 : SetChanged();
1693 2829 : BroadcastObjectChange();
1694 2829 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1695 2829 : }
1696 :
1697 0 : long SdrObject::GetRotateAngle() const
1698 : {
1699 0 : return 0;
1700 : }
1701 :
1702 0 : long SdrObject::GetShearAngle(bool /*bVertical*/) const
1703 : {
1704 0 : return 0;
1705 : }
1706 :
1707 0 : sal_uInt32 SdrObject::GetSnapPointCount() const
1708 : {
1709 0 : return GetPointCount();
1710 : }
1711 :
1712 0 : Point SdrObject::GetSnapPoint(sal_uInt32 i) const
1713 : {
1714 0 : return GetPoint(i);
1715 : }
1716 :
1717 12 : sal_Bool SdrObject::IsPolyObj() const
1718 : {
1719 12 : return false;
1720 : }
1721 :
1722 0 : sal_uInt32 SdrObject::GetPointCount() const
1723 : {
1724 0 : return 0L;
1725 : }
1726 :
1727 0 : Point SdrObject::GetPoint(sal_uInt32 /*i*/) const
1728 : {
1729 0 : return Point();
1730 : }
1731 :
1732 0 : void SdrObject::SetPoint(const Point& rPnt, sal_uInt32 i)
1733 : {
1734 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1735 0 : NbcSetPoint(rPnt, i);
1736 0 : SetChanged();
1737 0 : BroadcastObjectChange();
1738 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1739 0 : }
1740 :
1741 0 : void SdrObject::NbcSetPoint(const Point& /*rPnt*/, sal_uInt32 /*i*/)
1742 : {
1743 0 : }
1744 :
1745 0 : bool SdrObject::HasTextEdit() const
1746 : {
1747 0 : return false;
1748 : }
1749 :
1750 0 : sal_Bool SdrObject::BegTextEdit(SdrOutliner& /*rOutl*/)
1751 : {
1752 0 : return false;
1753 : }
1754 :
1755 0 : void SdrObject::EndTextEdit(SdrOutliner& /*rOutl*/)
1756 : {
1757 0 : }
1758 :
1759 825 : void SdrObject::SetOutlinerParaObject(OutlinerParaObject* pTextObject)
1760 : {
1761 825 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1762 825 : NbcSetOutlinerParaObject(pTextObject);
1763 825 : SetChanged();
1764 825 : BroadcastObjectChange();
1765 825 : if (GetCurrentBoundRect()!=aBoundRect0) {
1766 37 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1767 : }
1768 825 : }
1769 :
1770 0 : void SdrObject::NbcSetOutlinerParaObject(OutlinerParaObject* /*pTextObject*/)
1771 : {
1772 0 : }
1773 :
1774 0 : OutlinerParaObject* SdrObject::GetOutlinerParaObject() const
1775 : {
1776 0 : return NULL;
1777 : }
1778 :
1779 7 : void SdrObject::NbcReformatText()
1780 : {
1781 7 : }
1782 :
1783 0 : void SdrObject::ReformatText()
1784 : {
1785 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1786 0 : NbcReformatText();
1787 0 : SetChanged();
1788 0 : BroadcastObjectChange();
1789 0 : if (GetCurrentBoundRect()!=aBoundRect0) {
1790 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1791 : }
1792 0 : }
1793 :
1794 0 : void SdrObject::BurnInStyleSheetAttributes()
1795 : {
1796 0 : GetProperties().ForceStyleToHardAttributes();
1797 0 : }
1798 :
1799 0 : SdrObjUserData* SdrObject::ImpGetMacroUserData() const
1800 : {
1801 0 : SdrObjUserData* pData=NULL;
1802 0 : sal_uInt16 nAnz=GetUserDataCount();
1803 0 : for (sal_uInt16 nNum=nAnz; nNum>0 && pData==NULL;) {
1804 0 : nNum--;
1805 0 : pData=GetUserData(nNum);
1806 0 : if (!pData->HasMacro(this)) pData=NULL;
1807 : }
1808 0 : return pData;
1809 : }
1810 :
1811 0 : bool SdrObject::HasMacro() const
1812 : {
1813 0 : SdrObjUserData* pData=ImpGetMacroUserData();
1814 0 : return pData!=NULL ? pData->HasMacro(this) : false;
1815 : }
1816 :
1817 0 : SdrObject* SdrObject::CheckMacroHit(const SdrObjMacroHitRec& rRec) const
1818 : {
1819 0 : SdrObjUserData* pData = ImpGetMacroUserData();
1820 :
1821 0 : if(pData)
1822 : {
1823 0 : return pData->CheckMacroHit(rRec, this);
1824 : }
1825 :
1826 0 : if(rRec.pPageView)
1827 : {
1828 0 : return SdrObjectPrimitiveHit(*this, rRec.aPos, rRec.nTol, *rRec.pPageView, rRec.pVisiLayer, false);
1829 : }
1830 :
1831 0 : return 0;
1832 : }
1833 :
1834 0 : Pointer SdrObject::GetMacroPointer(const SdrObjMacroHitRec& rRec) const
1835 : {
1836 0 : SdrObjUserData* pData=ImpGetMacroUserData();
1837 0 : if (pData!=NULL) {
1838 0 : return pData->GetMacroPointer(rRec,this);
1839 : }
1840 0 : return Pointer(POINTER_REFHAND);
1841 : }
1842 :
1843 0 : void SdrObject::PaintMacro(OutputDevice& rOut, const Rectangle& rDirtyRect, const SdrObjMacroHitRec& rRec) const
1844 : {
1845 0 : SdrObjUserData* pData=ImpGetMacroUserData();
1846 :
1847 0 : if(pData)
1848 : {
1849 0 : pData->PaintMacro(rOut,rDirtyRect,rRec,this);
1850 : }
1851 : else
1852 : {
1853 0 : const RasterOp eRop(rOut.GetRasterOp());
1854 0 : const basegfx::B2DPolyPolygon aPolyPolygon(TakeXorPoly());
1855 0 : const sal_uInt32 nCount(aPolyPolygon.count());
1856 :
1857 0 : rOut.SetLineColor(COL_BLACK);
1858 0 : rOut.SetFillColor();
1859 0 : rOut.SetRasterOp(ROP_INVERT);
1860 :
1861 0 : for(sal_uInt32 a(0); a < nCount; a++)
1862 : {
1863 0 : rOut.DrawPolyLine(aPolyPolygon.getB2DPolygon(a));
1864 : }
1865 :
1866 0 : rOut.SetRasterOp(eRop);
1867 : }
1868 0 : }
1869 :
1870 0 : bool SdrObject::DoMacro(const SdrObjMacroHitRec& rRec)
1871 : {
1872 0 : SdrObjUserData* pData=ImpGetMacroUserData();
1873 0 : if (pData!=NULL) {
1874 0 : return pData->DoMacro(rRec,this);
1875 : }
1876 0 : return false;
1877 : }
1878 :
1879 0 : rtl::OUString SdrObject::GetMacroPopupComment(const SdrObjMacroHitRec& rRec) const
1880 : {
1881 0 : SdrObjUserData* pData=ImpGetMacroUserData();
1882 0 : if (pData!=NULL) {
1883 0 : return pData->GetMacroPopupComment(rRec,this);
1884 : }
1885 0 : return rtl::OUString();
1886 : }
1887 :
1888 0 : bool SdrObject::IsMacroHit(const SdrObjMacroHitRec& rRec) const
1889 : {
1890 0 : return CheckMacroHit(rRec) != NULL;
1891 : }
1892 :
1893 : ////////////////////////////////////////////////////////////////////////////////////////////////////
1894 :
1895 0 : SdrObjGeoData* SdrObject::NewGeoData() const
1896 : {
1897 0 : return new SdrObjGeoData;
1898 : }
1899 :
1900 78 : void SdrObject::SaveGeoData(SdrObjGeoData& rGeo) const
1901 : {
1902 78 : rGeo.aBoundRect =GetCurrentBoundRect();
1903 78 : rGeo.aAnchor =aAnchor ;
1904 78 : rGeo.bMovProt =bMovProt ;
1905 78 : rGeo.bSizProt =bSizProt ;
1906 78 : rGeo.bNoPrint =bNoPrint ;
1907 78 : rGeo.mbVisible =mbVisible ;
1908 78 : rGeo.bClosedObj =bClosedObj ;
1909 78 : rGeo.mnLayerID = mnLayerID;
1910 :
1911 : // user-defined glue points
1912 78 : if (pPlusData!=NULL && pPlusData->pGluePoints!=NULL) {
1913 0 : if (rGeo.pGPL!=NULL) {
1914 0 : *rGeo.pGPL=*pPlusData->pGluePoints;
1915 : } else {
1916 0 : rGeo.pGPL=new SdrGluePointList(*pPlusData->pGluePoints);
1917 : }
1918 : } else {
1919 78 : if (rGeo.pGPL!=NULL) {
1920 0 : delete rGeo.pGPL;
1921 0 : rGeo.pGPL=NULL;
1922 : }
1923 : }
1924 78 : }
1925 :
1926 0 : void SdrObject::RestGeoData(const SdrObjGeoData& rGeo)
1927 : {
1928 0 : SetRectsDirty();
1929 0 : aOutRect =rGeo.aBoundRect ;
1930 0 : aAnchor =rGeo.aAnchor ;
1931 0 : bMovProt =rGeo.bMovProt ;
1932 0 : bSizProt =rGeo.bSizProt ;
1933 0 : bNoPrint =rGeo.bNoPrint ;
1934 0 : mbVisible =rGeo.mbVisible ;
1935 0 : bClosedObj =rGeo.bClosedObj ;
1936 0 : mnLayerID = rGeo.mnLayerID;
1937 :
1938 : // user-defined glue points
1939 0 : if (rGeo.pGPL!=NULL) {
1940 0 : ImpForcePlusData();
1941 0 : if (pPlusData->pGluePoints!=NULL) {
1942 0 : *pPlusData->pGluePoints=*rGeo.pGPL;
1943 : } else {
1944 0 : pPlusData->pGluePoints=new SdrGluePointList(*rGeo.pGPL);
1945 : }
1946 : } else {
1947 0 : if (pPlusData!=NULL && pPlusData->pGluePoints!=NULL) {
1948 0 : delete pPlusData->pGluePoints;
1949 0 : pPlusData->pGluePoints=NULL;
1950 : }
1951 : }
1952 0 : }
1953 :
1954 0 : SdrObjGeoData* SdrObject::GetGeoData() const
1955 : {
1956 0 : SdrObjGeoData* pGeo=NewGeoData();
1957 0 : SaveGeoData(*pGeo);
1958 0 : return pGeo;
1959 : }
1960 :
1961 0 : void SdrObject::SetGeoData(const SdrObjGeoData& rGeo)
1962 : {
1963 0 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
1964 0 : RestGeoData(rGeo);
1965 0 : SetChanged();
1966 0 : BroadcastObjectChange();
1967 0 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
1968 0 : }
1969 :
1970 : ////////////////////////////////////////////////////////////////////////////////////////////////////
1971 : // ItemSet access
1972 :
1973 194965 : const SfxItemSet& SdrObject::GetObjectItemSet() const
1974 : {
1975 194965 : return GetProperties().GetObjectItemSet();
1976 : }
1977 :
1978 70762 : const SfxItemSet& SdrObject::GetMergedItemSet() const
1979 : {
1980 70762 : return GetProperties().GetMergedItemSet();
1981 : }
1982 :
1983 225 : void SdrObject::SetObjectItem(const SfxPoolItem& rItem)
1984 : {
1985 225 : GetProperties().SetObjectItem(rItem);
1986 225 : }
1987 :
1988 10122 : void SdrObject::SetMergedItem(const SfxPoolItem& rItem)
1989 : {
1990 10122 : GetProperties().SetMergedItem(rItem);
1991 10122 : }
1992 :
1993 108 : void SdrObject::ClearMergedItem(const sal_uInt16 nWhich)
1994 : {
1995 108 : GetProperties().ClearMergedItem(nWhich);
1996 108 : }
1997 :
1998 0 : void SdrObject::SetObjectItemSet(const SfxItemSet& rSet)
1999 : {
2000 0 : GetProperties().SetObjectItemSet(rSet);
2001 0 : }
2002 :
2003 1998 : void SdrObject::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems)
2004 : {
2005 1998 : GetProperties().SetMergedItemSet(rSet, bClearAllItems);
2006 1998 : }
2007 :
2008 14686 : const SfxPoolItem& SdrObject::GetObjectItem(const sal_uInt16 nWhich) const
2009 : {
2010 14686 : return GetObjectItemSet().Get(nWhich);
2011 : }
2012 :
2013 66202 : const SfxPoolItem& SdrObject::GetMergedItem(const sal_uInt16 nWhich) const
2014 : {
2015 66202 : return GetMergedItemSet().Get(nWhich);
2016 : }
2017 :
2018 3552 : void SdrObject::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, bool bClearAllItems)
2019 : {
2020 3552 : GetProperties().SetMergedItemSetAndBroadcast(rSet, bClearAllItems);
2021 3552 : }
2022 :
2023 13 : void SdrObject::ApplyNotPersistAttr(const SfxItemSet& rAttr)
2024 : {
2025 13 : Rectangle aBoundRect0; if (pUserCall!=NULL) aBoundRect0=GetLastBoundRect();
2026 13 : NbcApplyNotPersistAttr(rAttr);
2027 13 : SetChanged();
2028 13 : BroadcastObjectChange();
2029 13 : SendUserCall(SDRUSERCALL_RESIZE,aBoundRect0);
2030 13 : }
2031 :
2032 13 : void SdrObject::NbcApplyNotPersistAttr(const SfxItemSet& rAttr)
2033 : {
2034 13 : const Rectangle& rSnap=GetSnapRect();
2035 13 : const Rectangle& rLogic=GetLogicRect();
2036 13 : Point aRef1(rSnap.Center());
2037 13 : Point aRef2(aRef1); aRef2.Y()++;
2038 13 : const SfxPoolItem *pPoolItem=NULL;
2039 13 : if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1X,true,&pPoolItem)==SFX_ITEM_SET) {
2040 0 : aRef1.X()=((const SdrTransformRef1XItem*)pPoolItem)->GetValue();
2041 : }
2042 13 : if (rAttr.GetItemState(SDRATTR_TRANSFORMREF1Y,true,&pPoolItem)==SFX_ITEM_SET) {
2043 0 : aRef1.Y()=((const SdrTransformRef1YItem*)pPoolItem)->GetValue();
2044 : }
2045 13 : if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2X,true,&pPoolItem)==SFX_ITEM_SET) {
2046 0 : aRef2.X()=((const SdrTransformRef2XItem*)pPoolItem)->GetValue();
2047 : }
2048 13 : if (rAttr.GetItemState(SDRATTR_TRANSFORMREF2Y,true,&pPoolItem)==SFX_ITEM_SET) {
2049 0 : aRef2.Y()=((const SdrTransformRef2YItem*)pPoolItem)->GetValue();
2050 : }
2051 :
2052 13 : Rectangle aNewSnap(rSnap);
2053 13 : if (rAttr.GetItemState(SDRATTR_MOVEX,true,&pPoolItem)==SFX_ITEM_SET) {
2054 0 : long n=((const SdrMoveXItem*)pPoolItem)->GetValue();
2055 0 : aNewSnap.Move(n,0);
2056 : }
2057 13 : if (rAttr.GetItemState(SDRATTR_MOVEY,true,&pPoolItem)==SFX_ITEM_SET) {
2058 0 : long n=((const SdrMoveYItem*)pPoolItem)->GetValue();
2059 0 : aNewSnap.Move(0,n);
2060 : }
2061 13 : if (rAttr.GetItemState(SDRATTR_ONEPOSITIONX,true,&pPoolItem)==SFX_ITEM_SET) {
2062 0 : long n=((const SdrOnePositionXItem*)pPoolItem)->GetValue();
2063 0 : aNewSnap.Move(n-aNewSnap.Left(),0);
2064 : }
2065 13 : if (rAttr.GetItemState(SDRATTR_ONEPOSITIONY,true,&pPoolItem)==SFX_ITEM_SET) {
2066 0 : long n=((const SdrOnePositionYItem*)pPoolItem)->GetValue();
2067 0 : aNewSnap.Move(0,n-aNewSnap.Top());
2068 : }
2069 13 : if (rAttr.GetItemState(SDRATTR_ONESIZEWIDTH,true,&pPoolItem)==SFX_ITEM_SET) {
2070 0 : long n=((const SdrOneSizeWidthItem*)pPoolItem)->GetValue();
2071 0 : aNewSnap.Right()=aNewSnap.Left()+n;
2072 : }
2073 13 : if (rAttr.GetItemState(SDRATTR_ONESIZEHEIGHT,true,&pPoolItem)==SFX_ITEM_SET) {
2074 0 : long n=((const SdrOneSizeHeightItem*)pPoolItem)->GetValue();
2075 0 : aNewSnap.Bottom()=aNewSnap.Top()+n;
2076 : }
2077 13 : if (aNewSnap!=rSnap) {
2078 0 : if (aNewSnap.GetSize()==rSnap.GetSize()) {
2079 0 : NbcMove(Size(aNewSnap.Left()-rSnap.Left(),aNewSnap.Top()-rSnap.Top()));
2080 : } else {
2081 0 : NbcSetSnapRect(aNewSnap);
2082 : }
2083 : }
2084 :
2085 13 : if (rAttr.GetItemState(SDRATTR_SHEARANGLE,true,&pPoolItem)==SFX_ITEM_SET) {
2086 0 : long n=((const SdrShearAngleItem*)pPoolItem)->GetValue();
2087 0 : n-=GetShearAngle();
2088 0 : if (n!=0) {
2089 0 : double nTan=tan(n*nPi180);
2090 0 : NbcShear(aRef1,n,nTan,false);
2091 : }
2092 : }
2093 13 : if (rAttr.GetItemState(SDRATTR_ROTATEANGLE,true,&pPoolItem)==SFX_ITEM_SET) {
2094 0 : long n=((const SdrRotateAngleItem*)pPoolItem)->GetValue();
2095 0 : n-=GetRotateAngle();
2096 0 : if (n!=0) {
2097 0 : double nSin=sin(n*nPi180);
2098 0 : double nCos=cos(n*nPi180);
2099 0 : NbcRotate(aRef1,n,nSin,nCos);
2100 : }
2101 : }
2102 13 : if (rAttr.GetItemState(SDRATTR_ROTATEONE,true,&pPoolItem)==SFX_ITEM_SET) {
2103 0 : long n=((const SdrRotateOneItem*)pPoolItem)->GetValue();
2104 0 : double nSin=sin(n*nPi180);
2105 0 : double nCos=cos(n*nPi180);
2106 0 : NbcRotate(aRef1,n,nSin,nCos);
2107 : }
2108 13 : if (rAttr.GetItemState(SDRATTR_HORZSHEARONE,true,&pPoolItem)==SFX_ITEM_SET) {
2109 0 : long n=((const SdrHorzShearOneItem*)pPoolItem)->GetValue();
2110 0 : double nTan=tan(n*nPi180);
2111 0 : NbcShear(aRef1,n,nTan,false);
2112 : }
2113 13 : if (rAttr.GetItemState(SDRATTR_VERTSHEARONE,true,&pPoolItem)==SFX_ITEM_SET) {
2114 0 : long n=((const SdrVertShearOneItem*)pPoolItem)->GetValue();
2115 0 : double nTan=tan(n*nPi180);
2116 0 : NbcShear(aRef1,n,nTan,true);
2117 : }
2118 :
2119 13 : if (rAttr.GetItemState(SDRATTR_OBJMOVEPROTECT,true,&pPoolItem)==SFX_ITEM_SET) {
2120 0 : bool b=((const SdrObjMoveProtectItem*)pPoolItem)->GetValue();
2121 0 : SetMoveProtect(b);
2122 : }
2123 13 : if (rAttr.GetItemState(SDRATTR_OBJSIZEPROTECT,true,&pPoolItem)==SFX_ITEM_SET) {
2124 0 : bool b=((const SdrObjSizeProtectItem*)pPoolItem)->GetValue();
2125 0 : SetResizeProtect(b);
2126 : }
2127 :
2128 : /* move protect always sets size protect */
2129 13 : if( IsMoveProtect() )
2130 0 : SetResizeProtect( true );
2131 :
2132 13 : if (rAttr.GetItemState(SDRATTR_OBJPRINTABLE,true,&pPoolItem)==SFX_ITEM_SET) {
2133 0 : bool b=((const SdrObjPrintableItem*)pPoolItem)->GetValue();
2134 0 : SetPrintable(b);
2135 : }
2136 :
2137 13 : if (rAttr.GetItemState(SDRATTR_OBJVISIBLE,true,&pPoolItem)==SFX_ITEM_SET) {
2138 0 : bool b=((const SdrObjVisibleItem*)pPoolItem)->GetValue();
2139 0 : SetVisible(b);
2140 : }
2141 :
2142 13 : SdrLayerID nLayer=SDRLAYER_NOTFOUND;
2143 13 : if (rAttr.GetItemState(SDRATTR_LAYERID,true,&pPoolItem)==SFX_ITEM_SET) {
2144 0 : nLayer=((const SdrLayerIdItem*)pPoolItem)->GetValue();
2145 : }
2146 13 : if (rAttr.GetItemState(SDRATTR_LAYERNAME,true,&pPoolItem)==SFX_ITEM_SET && pModel!=NULL) {
2147 0 : XubString aLayerName=((const SdrLayerNameItem*)pPoolItem)->GetValue();
2148 0 : const SdrLayerAdmin* pLayAd=pPage!=NULL ? &pPage->GetLayerAdmin() : pModel!=NULL ? &pModel->GetLayerAdmin() : NULL;
2149 0 : if (pLayAd!=NULL) {
2150 0 : const SdrLayer* pLayer=pLayAd->GetLayer(aLayerName, true);
2151 0 : if (pLayer!=NULL) {
2152 0 : nLayer=pLayer->GetID();
2153 : }
2154 0 : }
2155 :
2156 : }
2157 13 : if (nLayer!=SDRLAYER_NOTFOUND) {
2158 0 : NbcSetLayer(nLayer);
2159 : }
2160 :
2161 13 : if (rAttr.GetItemState(SDRATTR_OBJECTNAME,true,&pPoolItem)==SFX_ITEM_SET) {
2162 1 : XubString aName=((const SdrObjectNameItem*)pPoolItem)->GetValue();
2163 1 : SetName(aName);
2164 : }
2165 13 : Rectangle aNewLogic(rLogic);
2166 13 : if (rAttr.GetItemState(SDRATTR_LOGICSIZEWIDTH,true,&pPoolItem)==SFX_ITEM_SET) {
2167 0 : long n=((const SdrLogicSizeWidthItem*)pPoolItem)->GetValue();
2168 0 : aNewLogic.Right()=aNewLogic.Left()+n;
2169 : }
2170 13 : if (rAttr.GetItemState(SDRATTR_LOGICSIZEHEIGHT,true,&pPoolItem)==SFX_ITEM_SET) {
2171 0 : long n=((const SdrLogicSizeHeightItem*)pPoolItem)->GetValue();
2172 0 : aNewLogic.Bottom()=aNewLogic.Top()+n;
2173 : }
2174 13 : if (aNewLogic!=rLogic) {
2175 0 : NbcSetLogicRect(aNewLogic);
2176 : }
2177 13 : Fraction aResizeX(1,1);
2178 13 : Fraction aResizeY(1,1);
2179 13 : if (rAttr.GetItemState(SDRATTR_RESIZEXONE,true,&pPoolItem)==SFX_ITEM_SET) {
2180 0 : aResizeX*=((const SdrResizeXOneItem*)pPoolItem)->GetValue();
2181 : }
2182 13 : if (rAttr.GetItemState(SDRATTR_RESIZEYONE,true,&pPoolItem)==SFX_ITEM_SET) {
2183 0 : aResizeY*=((const SdrResizeYOneItem*)pPoolItem)->GetValue();
2184 : }
2185 13 : if (aResizeX!=Fraction(1,1) || aResizeY!=Fraction(1,1)) {
2186 0 : NbcResize(aRef1,aResizeX,aResizeY);
2187 : }
2188 13 : }
2189 :
2190 0 : static void lcl_SetItem(SfxItemSet& rAttr, bool bMerge, const SfxPoolItem& rItem)
2191 : {
2192 0 : if (bMerge) rAttr.MergeValue(rItem,true);
2193 0 : else rAttr.Put(rItem);
2194 0 : }
2195 :
2196 0 : void SdrObject::TakeNotPersistAttr(SfxItemSet& rAttr, bool bMerge) const
2197 : {
2198 0 : const Rectangle& rSnap=GetSnapRect();
2199 0 : const Rectangle& rLogic=GetLogicRect();
2200 0 : lcl_SetItem(rAttr,bMerge,SdrObjMoveProtectItem(IsMoveProtect()));
2201 0 : lcl_SetItem(rAttr,bMerge,SdrObjSizeProtectItem(IsResizeProtect()));
2202 0 : lcl_SetItem(rAttr,bMerge,SdrObjPrintableItem(IsPrintable()));
2203 0 : lcl_SetItem(rAttr,bMerge,SdrObjVisibleItem(IsVisible()));
2204 0 : lcl_SetItem(rAttr,bMerge,SdrRotateAngleItem(GetRotateAngle()));
2205 0 : lcl_SetItem(rAttr,bMerge,SdrShearAngleItem(GetShearAngle()));
2206 0 : lcl_SetItem(rAttr,bMerge,SdrOneSizeWidthItem(rSnap.GetWidth()-1));
2207 0 : lcl_SetItem(rAttr,bMerge,SdrOneSizeHeightItem(rSnap.GetHeight()-1));
2208 0 : lcl_SetItem(rAttr,bMerge,SdrOnePositionXItem(rSnap.Left()));
2209 0 : lcl_SetItem(rAttr,bMerge,SdrOnePositionYItem(rSnap.Top()));
2210 0 : if (rLogic.GetWidth()!=rSnap.GetWidth()) {
2211 0 : lcl_SetItem(rAttr,bMerge,SdrLogicSizeWidthItem(rLogic.GetWidth()-1));
2212 : }
2213 0 : if (rLogic.GetHeight()!=rSnap.GetHeight()) {
2214 0 : lcl_SetItem(rAttr,bMerge,SdrLogicSizeHeightItem(rLogic.GetHeight()-1));
2215 : }
2216 0 : XubString aName(GetName());
2217 :
2218 0 : if(aName.Len())
2219 : {
2220 0 : lcl_SetItem(rAttr, bMerge, SdrObjectNameItem(aName));
2221 : }
2222 :
2223 0 : lcl_SetItem(rAttr,bMerge,SdrLayerIdItem(GetLayer()));
2224 0 : const SdrLayerAdmin* pLayAd=pPage!=NULL ? &pPage->GetLayerAdmin() : pModel!=NULL ? &pModel->GetLayerAdmin() : NULL;
2225 0 : if (pLayAd!=NULL) {
2226 0 : const SdrLayer* pLayer=pLayAd->GetLayerPerID(GetLayer());
2227 0 : if (pLayer!=NULL) {
2228 0 : lcl_SetItem(rAttr,bMerge,SdrLayerNameItem(pLayer->GetName()));
2229 : }
2230 : }
2231 0 : Point aRef1(rSnap.Center());
2232 0 : Point aRef2(aRef1); aRef2.Y()++;
2233 0 : lcl_SetItem(rAttr,bMerge,SdrTransformRef1XItem(aRef1.X()));
2234 0 : lcl_SetItem(rAttr,bMerge,SdrTransformRef1YItem(aRef1.Y()));
2235 0 : lcl_SetItem(rAttr,bMerge,SdrTransformRef2XItem(aRef2.X()));
2236 0 : lcl_SetItem(rAttr,bMerge,SdrTransformRef2YItem(aRef2.Y()));
2237 0 : }
2238 :
2239 3037 : SfxStyleSheet* SdrObject::GetStyleSheet() const
2240 : {
2241 3037 : return GetProperties().GetStyleSheet();
2242 : }
2243 :
2244 177 : void SdrObject::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr)
2245 : {
2246 177 : Rectangle aBoundRect0;
2247 :
2248 177 : if(pUserCall)
2249 0 : aBoundRect0 = GetLastBoundRect();
2250 :
2251 177 : NbcSetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
2252 177 : SetChanged();
2253 177 : BroadcastObjectChange();
2254 177 : SendUserCall(SDRUSERCALL_CHGATTR, aBoundRect0);
2255 177 : }
2256 :
2257 394 : void SdrObject::NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
2258 : {
2259 : // only allow graphic and presentation styles for shapes
2260 394 : if( pNewStyleSheet && (pNewStyleSheet->GetFamily() == SFX_STYLE_FAMILY_PARA) && (pNewStyleSheet->GetFamily() == SFX_STYLE_FAMILY_PAGE) )
2261 394 : return;
2262 :
2263 394 : GetProperties().SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
2264 : }
2265 :
2266 : // Broadcasting while setting attributes is managed by the AttrObj.
2267 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2268 :
2269 0 : bool SdrObject::IsNode() const
2270 : {
2271 0 : return true;
2272 : }
2273 :
2274 0 : SdrGluePoint SdrObject::GetVertexGluePoint(sal_uInt16 nPosNum) const
2275 : {
2276 : // #i41936# Use SnapRect for default GluePoints
2277 0 : const Rectangle aR(GetSnapRect());
2278 0 : Point aPt;
2279 :
2280 0 : switch(nPosNum)
2281 : {
2282 0 : case 0 : aPt = aR.TopCenter(); break;
2283 0 : case 1 : aPt = aR.RightCenter(); break;
2284 0 : case 2 : aPt = aR.BottomCenter(); break;
2285 0 : case 3 : aPt = aR.LeftCenter(); break;
2286 : }
2287 :
2288 0 : aPt -= aR.Center();
2289 0 : SdrGluePoint aGP(aPt);
2290 0 : aGP.SetPercent(false);
2291 :
2292 0 : return aGP;
2293 : }
2294 :
2295 0 : SdrGluePoint SdrObject::GetCornerGluePoint(sal_uInt16 nPosNum) const
2296 : {
2297 0 : Rectangle aR(GetCurrentBoundRect());
2298 0 : Point aPt;
2299 0 : switch (nPosNum) {
2300 0 : case 0 : aPt=aR.TopLeft(); break;
2301 0 : case 1 : aPt=aR.TopRight(); break;
2302 0 : case 2 : aPt=aR.BottomRight(); break;
2303 0 : case 3 : aPt=aR.BottomLeft(); break;
2304 : }
2305 0 : aPt-=GetSnapRect().Center();
2306 0 : SdrGluePoint aGP(aPt);
2307 0 : aGP.SetPercent(false);
2308 0 : return aGP;
2309 : }
2310 :
2311 7789 : const SdrGluePointList* SdrObject::GetGluePointList() const
2312 : {
2313 7789 : if (pPlusData!=NULL) return pPlusData->pGluePoints;
2314 6696 : return NULL;
2315 : }
2316 :
2317 :
2318 8 : SdrGluePointList* SdrObject::ForceGluePointList()
2319 : {
2320 8 : ImpForcePlusData();
2321 8 : if (pPlusData->pGluePoints==NULL) {
2322 2 : pPlusData->pGluePoints=new SdrGluePointList;
2323 : }
2324 8 : return pPlusData->pGluePoints;
2325 : }
2326 :
2327 110 : void SdrObject::SetGlueReallyAbsolute(bool bOn)
2328 : {
2329 : // First a const call to see whether there are any glue points.
2330 : // Force const call!
2331 110 : if (GetGluePointList()!=NULL) {
2332 0 : SdrGluePointList* pGPL=ForceGluePointList();
2333 0 : pGPL->SetReallyAbsolute(bOn,*this);
2334 : }
2335 110 : }
2336 :
2337 37 : void SdrObject::NbcRotateGluePoints(const Point& rRef, long nWink, double sn, double cs)
2338 : {
2339 : // First a const call to see whether there are any glue points.
2340 : // Force const call!
2341 37 : if (GetGluePointList()!=NULL) {
2342 0 : SdrGluePointList* pGPL=ForceGluePointList();
2343 0 : pGPL->Rotate(rRef,nWink,sn,cs,this);
2344 : }
2345 37 : }
2346 :
2347 7654 : void SdrObject::NbcMirrorGluePoints(const Point& rRef1, const Point& rRef2)
2348 : {
2349 : // First a const call to see whether there are any glue points.
2350 : // Force const call!
2351 7654 : if (GetGluePointList()!=NULL) {
2352 0 : SdrGluePointList* pGPL=ForceGluePointList();
2353 0 : pGPL->Mirror(rRef1,rRef2,this);
2354 : }
2355 7654 : }
2356 :
2357 0 : void SdrObject::NbcShearGluePoints(const Point& rRef, long nWink, double tn, bool bVShear)
2358 : {
2359 : // First a const call to see whether there are any glue points.
2360 : // Force const call!
2361 0 : if (GetGluePointList()!=NULL) {
2362 0 : SdrGluePointList* pGPL=ForceGluePointList();
2363 0 : pGPL->Shear(rRef,nWink,tn,bVShear,this);
2364 : }
2365 0 : }
2366 :
2367 0 : bool SdrObject::IsEdge() const
2368 : {
2369 0 : return false;
2370 : }
2371 :
2372 0 : void SdrObject::ConnectToNode(bool /*bTail1*/, SdrObject* /*pObj*/)
2373 : {
2374 0 : }
2375 :
2376 0 : void SdrObject::DisconnectFromNode(bool /*bTail1*/)
2377 : {
2378 0 : }
2379 :
2380 0 : SdrObject* SdrObject::GetConnectedNode(bool /*bTail1*/) const
2381 : {
2382 0 : return NULL;
2383 : }
2384 :
2385 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2386 :
2387 0 : SdrObject* SdrObject::ImpConvertToContourObj(SdrObject* pRet, bool bForceLineDash) const
2388 : {
2389 0 : bool bNoChange(true);
2390 :
2391 0 : if(pRet->LineGeometryUsageIsNecessary())
2392 : {
2393 0 : basegfx::B2DPolyPolygon aMergedLineFillPolyPolygon;
2394 0 : basegfx::B2DPolyPolygon aMergedHairlinePolyPolygon;
2395 0 : const drawinglayer::primitive2d::Primitive2DSequence xSequence(pRet->GetViewContact().getViewIndependentPrimitive2DSequence());
2396 :
2397 0 : if(xSequence.hasElements())
2398 : {
2399 : // use neutral ViewInformation
2400 0 : const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
2401 :
2402 : // create extractor, process and get result
2403 0 : drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
2404 0 : aExtractor.process(xSequence);
2405 :
2406 : // #i102241# check for line results
2407 0 : const basegfx::B2DPolygonVector& rHairlineVector = aExtractor.getExtractedHairlines();
2408 :
2409 0 : if(!rHairlineVector.empty())
2410 : {
2411 : // for SdrObject creation, just copy all to a single Hairline-PolyPolygon
2412 0 : for(sal_uInt32 a(0); a < rHairlineVector.size(); a++)
2413 : {
2414 0 : aMergedHairlinePolyPolygon.append(rHairlineVector[a]);
2415 : }
2416 : }
2417 :
2418 : // #i102241# check for fill rsults
2419 0 : const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
2420 :
2421 0 : if(!rLineFillVector.empty())
2422 : {
2423 : // merge to a single PolyPolygon (OR)
2424 0 : aMergedLineFillPolyPolygon = basegfx::tools::mergeToSinglePolyPolygon(rLineFillVector);
2425 0 : }
2426 : }
2427 :
2428 : // || aMergedHairlinePolyPolygon.Count() removed; the conversion is ONLY
2429 : // useful when new closed filled polygons are created
2430 0 : if(aMergedLineFillPolyPolygon.count() || (bForceLineDash && aMergedHairlinePolyPolygon.count()))
2431 : {
2432 0 : SfxItemSet aSet(pRet->GetMergedItemSet());
2433 0 : XFillStyle eOldFillStyle = ((const XFillStyleItem&)(aSet.Get(XATTR_FILLSTYLE))).GetValue();
2434 0 : SdrPathObj* aLinePolygonPart = NULL;
2435 0 : SdrPathObj* aLineHairlinePart = NULL;
2436 0 : bool bBuildGroup(false);
2437 :
2438 0 : if(aMergedLineFillPolyPolygon.count())
2439 : {
2440 : // create SdrObject for filled line geometry
2441 0 : aLinePolygonPart = new SdrPathObj(OBJ_PATHFILL, aMergedLineFillPolyPolygon);
2442 0 : aLinePolygonPart->SetModel(pRet->GetModel());
2443 :
2444 : // correct item properties
2445 0 : aSet.Put(XLineWidthItem(0L));
2446 0 : aSet.Put(XLineStyleItem(XLINE_NONE));
2447 0 : Color aColorLine = ((const XLineColorItem&)(aSet.Get(XATTR_LINECOLOR))).GetColorValue();
2448 0 : sal_uInt16 nTransLine = ((const XLineTransparenceItem&)(aSet.Get(XATTR_LINETRANSPARENCE))).GetValue();
2449 0 : aSet.Put(XFillColorItem(XubString(), aColorLine));
2450 0 : aSet.Put(XFillStyleItem(XFILL_SOLID));
2451 0 : aSet.Put(XFillTransparenceItem(nTransLine));
2452 :
2453 0 : aLinePolygonPart->SetMergedItemSet(aSet);
2454 : }
2455 :
2456 0 : if(aMergedHairlinePolyPolygon.count())
2457 : {
2458 : // create SdrObject for hairline geometry
2459 : // OBJ_PATHLINE is necessary here, not OBJ_PATHFILL. This is intended
2460 : // to get a non-filled object. If the poly is closed, the PathObj takes care for
2461 : // the correct closed state.
2462 0 : aLineHairlinePart = new SdrPathObj(OBJ_PATHLINE, aMergedHairlinePolyPolygon);
2463 0 : aLineHairlinePart->SetModel(pRet->GetModel());
2464 :
2465 0 : aSet.Put(XLineWidthItem(0L));
2466 0 : aSet.Put(XFillStyleItem(XFILL_NONE));
2467 0 : aSet.Put(XLineStyleItem(XLINE_SOLID));
2468 :
2469 : // it is also necessary to switch off line start and ends here
2470 0 : aSet.Put(XLineStartWidthItem(0));
2471 0 : aSet.Put(XLineEndWidthItem(0));
2472 :
2473 0 : aLineHairlinePart->SetMergedItemSet(aSet);
2474 :
2475 0 : if(aLinePolygonPart)
2476 : {
2477 0 : bBuildGroup = true;
2478 : }
2479 : }
2480 :
2481 : // check if original geometry should be added (e.g. filled and closed)
2482 0 : bool bAddOriginalGeometry(false);
2483 0 : SdrPathObj* pPath = PTR_CAST(SdrPathObj, pRet);
2484 :
2485 0 : if(pPath && pPath->IsClosed())
2486 : {
2487 0 : if(eOldFillStyle != XFILL_NONE)
2488 : {
2489 0 : bAddOriginalGeometry = true;
2490 : }
2491 : }
2492 :
2493 : // do we need a group?
2494 0 : if(bBuildGroup || bAddOriginalGeometry)
2495 : {
2496 0 : SdrObject* pGroup = new SdrObjGroup;
2497 0 : pGroup->SetModel(pRet->GetModel());
2498 :
2499 0 : if(bAddOriginalGeometry)
2500 : {
2501 : // Add a clone of the original geometry.
2502 0 : aSet.ClearItem();
2503 0 : aSet.Put(pRet->GetMergedItemSet());
2504 0 : aSet.Put(XLineStyleItem(XLINE_NONE));
2505 0 : aSet.Put(XLineWidthItem(0L));
2506 :
2507 0 : SdrObject* pClone = pRet->Clone();
2508 :
2509 0 : pClone->SetModel(pRet->GetModel());
2510 0 : pClone->SetMergedItemSet(aSet);
2511 :
2512 0 : pGroup->GetSubList()->NbcInsertObject(pClone);
2513 : }
2514 :
2515 0 : if(aLinePolygonPart)
2516 : {
2517 0 : pGroup->GetSubList()->NbcInsertObject(aLinePolygonPart);
2518 : }
2519 :
2520 0 : if(aLineHairlinePart)
2521 : {
2522 0 : pGroup->GetSubList()->NbcInsertObject(aLineHairlinePart);
2523 : }
2524 :
2525 0 : pRet = pGroup;
2526 :
2527 : // be more careful with the state describing bool
2528 0 : bNoChange = false;
2529 : }
2530 : else
2531 : {
2532 0 : if(aLinePolygonPart)
2533 : {
2534 0 : pRet = aLinePolygonPart;
2535 : // be more careful with the state describing bool
2536 0 : bNoChange = false;
2537 : }
2538 0 : else if(aLineHairlinePart)
2539 : {
2540 0 : pRet = aLineHairlinePart;
2541 : // be more careful with the state describing bool
2542 0 : bNoChange = false;
2543 : }
2544 0 : }
2545 0 : }
2546 : }
2547 :
2548 0 : if(bNoChange)
2549 : {
2550 : // due to current method usage, create and return a clone when nothing has changed
2551 0 : SdrObject* pClone = pRet->Clone();
2552 0 : pClone->SetModel(pRet->GetModel());
2553 0 : pRet = pClone;
2554 : }
2555 :
2556 0 : return pRet;
2557 : }
2558 :
2559 511 : bool SdrObject::IsVirtualObj() const
2560 : {
2561 511 : return bVirtObj;
2562 : }
2563 :
2564 226 : bool SdrObject::IsClosedObj() const
2565 : {
2566 226 : return bClosedObj;
2567 : }
2568 :
2569 2098 : bool SdrObject::IsEdgeObj() const
2570 : {
2571 2098 : return bIsEdge;
2572 : }
2573 :
2574 19 : bool SdrObject::Is3DObj() const
2575 : {
2576 19 : return bIs3DObj;
2577 : }
2578 :
2579 18 : bool SdrObject::IsUnoObj() const
2580 : {
2581 18 : return bIsUnoObj;
2582 : }
2583 :
2584 9 : void SdrObject::SetMarkProtect(bool bProt)
2585 : {
2586 9 : bMarkProt = bProt;
2587 9 : }
2588 :
2589 62 : bool SdrObject::IsMarkProtect() const
2590 : {
2591 62 : return bMarkProt;
2592 : }
2593 :
2594 60721 : bool SdrObject::IsInserted() const
2595 : {
2596 60721 : return bInserted;
2597 : }
2598 :
2599 108 : bool SdrObject::IsMoveProtect() const
2600 : {
2601 108 : return bMovProt;
2602 : }
2603 :
2604 170 : bool SdrObject::IsResizeProtect() const
2605 : {
2606 170 : return bSizProt;
2607 : }
2608 :
2609 78 : bool SdrObject::IsPrintable() const
2610 : {
2611 78 : return !bNoPrint;
2612 : }
2613 :
2614 519 : bool SdrObject::IsVisible() const
2615 : {
2616 519 : return mbVisible;
2617 : }
2618 :
2619 357 : void SdrObject::SetEmptyPresObj(bool bEpt)
2620 : {
2621 357 : bEmptyPresObj = bEpt;
2622 357 : }
2623 :
2624 1544 : bool SdrObject::IsEmptyPresObj() const
2625 : {
2626 1544 : return bEmptyPresObj;
2627 : }
2628 :
2629 56 : void SdrObject::SetNotVisibleAsMaster(bool bFlg)
2630 : {
2631 56 : bNotVisibleAsMaster=bFlg;
2632 56 : }
2633 :
2634 0 : bool SdrObject::IsNotVisibleAsMaster() const
2635 : {
2636 0 : return bNotVisibleAsMaster;
2637 : }
2638 :
2639 0 : bool SdrObject::LineIsOutsideGeometry() const
2640 : {
2641 0 : return mbLineIsOutsideGeometry;
2642 : }
2643 :
2644 3512 : bool SdrObject::DoesSupportTextIndentingOnLineWidthChange() const
2645 : {
2646 3512 : return mbSupportTextIndentingOnLineWidthChange;
2647 : }
2648 :
2649 : // convert this path object to contour object, even when it is a group
2650 0 : SdrObject* SdrObject::ConvertToContourObj(SdrObject* pRet, bool bForceLineDash) const
2651 : {
2652 0 : if(pRet->ISA(SdrObjGroup))
2653 : {
2654 0 : SdrObjList* pObjList2 = pRet->GetSubList();
2655 0 : SdrObject* pGroup = new SdrObjGroup;
2656 0 : pGroup->SetModel(pRet->GetModel());
2657 :
2658 0 : for(sal_uInt32 a=0;a<pObjList2->GetObjCount();a++)
2659 : {
2660 0 : SdrObject* pIterObj = pObjList2->GetObj(a);
2661 0 : pGroup->GetSubList()->NbcInsertObject(ConvertToContourObj(pIterObj, bForceLineDash));
2662 : }
2663 :
2664 0 : pRet = pGroup;
2665 : }
2666 : else
2667 : {
2668 0 : if(pRet && pRet->ISA(SdrPathObj))
2669 : {
2670 0 : SdrPathObj* pPathObj = (SdrPathObj*)pRet;
2671 :
2672 : // bezier geometry got created, even for straight edges since the given
2673 : // object is a result of DoConvertToPolyObj. For conversion to contour
2674 : // this is not really needed and can be reduced again AFAP
2675 0 : pPathObj->SetPathPoly(basegfx::tools::simplifyCurveSegments(pPathObj->GetPathPoly()));
2676 : }
2677 :
2678 0 : pRet = ImpConvertToContourObj(pRet, bForceLineDash);
2679 : }
2680 :
2681 : // #i73441# preserve LayerID
2682 0 : if(pRet && pRet->GetLayer() != GetLayer())
2683 : {
2684 0 : pRet->SetLayer(GetLayer());
2685 : }
2686 :
2687 0 : return pRet;
2688 : }
2689 :
2690 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2691 :
2692 0 : SdrObject* SdrObject::ConvertToPolyObj(bool bBezier, bool bLineToArea) const
2693 : {
2694 0 : SdrObject* pRet = DoConvertToPolyObj(bBezier, true);
2695 :
2696 0 : if(pRet && bLineToArea)
2697 : {
2698 0 : SdrObject* pNewRet = ConvertToContourObj(pRet);
2699 0 : delete pRet;
2700 0 : pRet = pNewRet;
2701 : }
2702 :
2703 : // #i73441# preserve LayerID
2704 0 : if(pRet && pRet->GetLayer() != GetLayer())
2705 : {
2706 0 : pRet->SetLayer(GetLayer());
2707 : }
2708 :
2709 0 : return pRet;
2710 : }
2711 :
2712 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2713 :
2714 0 : SdrObject* SdrObject::DoConvertToPolyObj(sal_Bool /*bBezier*/, bool /*bAddText*/) const
2715 : {
2716 0 : return NULL;
2717 : }
2718 :
2719 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2720 :
2721 6396 : void SdrObject::SetInserted(bool bIns)
2722 : {
2723 6396 : if (bIns!=IsInserted()) {
2724 6396 : bInserted=bIns;
2725 6396 : Rectangle aBoundRect0(GetLastBoundRect());
2726 6396 : if (bIns) SendUserCall(SDRUSERCALL_INSERTED,aBoundRect0);
2727 861 : else SendUserCall(SDRUSERCALL_REMOVED,aBoundRect0);
2728 :
2729 6396 : if (pPlusData!=NULL && pPlusData->pBroadcast!=NULL) {
2730 35 : SdrHint aHint(*this);
2731 35 : aHint.SetKind(bIns?HINT_OBJINSERTED:HINT_OBJREMOVED);
2732 35 : pPlusData->pBroadcast->Broadcast(aHint);
2733 : }
2734 : }
2735 6396 : }
2736 :
2737 18 : void SdrObject::SetMoveProtect(bool bProt)
2738 : {
2739 18 : if(IsMoveProtect() != bProt)
2740 : {
2741 : // #i77187# secured and simplified
2742 9 : bMovProt = bProt;
2743 9 : SetChanged();
2744 9 : BroadcastObjectChange();
2745 : }
2746 18 : }
2747 :
2748 51 : void SdrObject::SetResizeProtect(bool bProt)
2749 : {
2750 51 : if(IsResizeProtect() != bProt)
2751 : {
2752 : // #i77187# secured and simplified
2753 43 : bSizProt = bProt;
2754 43 : SetChanged();
2755 43 : BroadcastObjectChange();
2756 : }
2757 51 : }
2758 :
2759 1494 : void SdrObject::SetPrintable(bool bPrn)
2760 : {
2761 1494 : if( bPrn == bNoPrint )
2762 : {
2763 0 : bNoPrint=!bPrn;
2764 0 : SetChanged();
2765 0 : if (IsInserted() && pModel!=NULL)
2766 : {
2767 0 : SdrHint aHint(*this);
2768 0 : pModel->Broadcast(aHint);
2769 : }
2770 : }
2771 1494 : }
2772 :
2773 1494 : void SdrObject::SetVisible(bool bVisible)
2774 : {
2775 1494 : if( bVisible != mbVisible )
2776 : {
2777 0 : mbVisible = bVisible;
2778 0 : SetChanged();
2779 0 : if (IsInserted() && pModel!=NULL)
2780 : {
2781 0 : SdrHint aHint(*this);
2782 0 : pModel->Broadcast(aHint);
2783 : }
2784 : }
2785 1494 : }
2786 :
2787 : ////////////////////////////////////////////////////////////////////////////////////////////////////
2788 :
2789 8597 : sal_uInt16 SdrObject::GetUserDataCount() const
2790 : {
2791 8597 : if (pPlusData==NULL || pPlusData->pUserDataList==NULL) return 0;
2792 4147 : return pPlusData->pUserDataList->GetUserDataCount();
2793 : }
2794 :
2795 4147 : SdrObjUserData* SdrObject::GetUserData(sal_uInt16 nNum) const
2796 : {
2797 4147 : if (pPlusData==NULL || pPlusData->pUserDataList==NULL) return NULL;
2798 4147 : return pPlusData->pUserDataList->GetUserData(nNum);
2799 : }
2800 :
2801 559 : void SdrObject::AppendUserData(SdrObjUserData* pData)
2802 : {
2803 559 : if (!pData)
2804 : {
2805 : OSL_FAIL("SdrObject::AppendUserData(): pData is NULL pointer.");
2806 559 : return;
2807 : }
2808 :
2809 559 : ImpForcePlusData();
2810 559 : if (!pPlusData->pUserDataList)
2811 559 : pPlusData->pUserDataList = new SdrObjUserDataList;
2812 :
2813 559 : pPlusData->pUserDataList->AppendUserData(pData);
2814 : }
2815 :
2816 0 : void SdrObject::DeleteUserData(sal_uInt16 nNum)
2817 : {
2818 0 : sal_uInt16 nAnz=GetUserDataCount();
2819 0 : if (nNum<nAnz) {
2820 0 : pPlusData->pUserDataList->DeleteUserData(nNum);
2821 0 : if (nAnz==1) {
2822 0 : delete pPlusData->pUserDataList;
2823 0 : pPlusData->pUserDataList=NULL;
2824 : }
2825 : } else {
2826 : OSL_FAIL("SdrObject::DeleteUserData(): Invalid Index.");
2827 : }
2828 0 : }
2829 :
2830 8443 : void SdrObject::SetUserCall(SdrObjUserCall* pUser)
2831 : {
2832 8443 : pUserCall = pUser;
2833 8443 : }
2834 :
2835 36540 : SdrObjUserCall* SdrObject::GetUserCall() const
2836 : {
2837 36540 : return pUserCall;
2838 : }
2839 :
2840 41123 : void SdrObject::SendUserCall(SdrUserCallType eUserCall, const Rectangle& rBoundRect) const
2841 : {
2842 41123 : SdrObjGroup* pGroup = NULL;
2843 :
2844 41123 : if( pObjList && pObjList->GetListKind() == SDROBJLIST_GROUPOBJ )
2845 22696 : pGroup = (SdrObjGroup*) pObjList->GetOwnerObj();
2846 :
2847 41123 : if ( pUserCall )
2848 : {
2849 4213 : pUserCall->Changed( *this, eUserCall, rBoundRect );
2850 : }
2851 :
2852 104942 : while( pGroup )
2853 : {
2854 : // broadcast to group
2855 22696 : if( pGroup->GetUserCall() )
2856 : {
2857 134 : SdrUserCallType eChildUserType = SDRUSERCALL_CHILD_CHGATTR;
2858 :
2859 134 : switch( eUserCall )
2860 : {
2861 : case SDRUSERCALL_MOVEONLY:
2862 25 : eChildUserType = SDRUSERCALL_CHILD_MOVEONLY;
2863 25 : break;
2864 :
2865 : case SDRUSERCALL_RESIZE:
2866 28 : eChildUserType = SDRUSERCALL_CHILD_RESIZE;
2867 28 : break;
2868 :
2869 : case SDRUSERCALL_CHGATTR:
2870 71 : eChildUserType = SDRUSERCALL_CHILD_CHGATTR;
2871 71 : break;
2872 :
2873 : case SDRUSERCALL_DELETE:
2874 0 : eChildUserType = SDRUSERCALL_CHILD_DELETE;
2875 0 : break;
2876 :
2877 : case SDRUSERCALL_COPY:
2878 0 : eChildUserType = SDRUSERCALL_CHILD_COPY;
2879 0 : break;
2880 :
2881 : case SDRUSERCALL_INSERTED:
2882 10 : eChildUserType = SDRUSERCALL_CHILD_INSERTED;
2883 10 : break;
2884 :
2885 : case SDRUSERCALL_REMOVED:
2886 0 : eChildUserType = SDRUSERCALL_CHILD_REMOVED;
2887 0 : break;
2888 :
2889 0 : default: break;
2890 : }
2891 :
2892 134 : pGroup->GetUserCall()->Changed( *this, eChildUserType, rBoundRect );
2893 : }
2894 :
2895 63191 : if( pGroup->GetObjList() &&
2896 20640 : pGroup->GetObjList()->GetListKind() == SDROBJLIST_GROUPOBJ &&
2897 19855 : pGroup != (SdrObjGroup*) pObjList->GetOwnerObj() )
2898 0 : pGroup = (SdrObjGroup*) pObjList->GetOwnerObj();
2899 : else
2900 22696 : pGroup = NULL;
2901 : }
2902 :
2903 : // notify our UNO shape listeners
2904 41123 : switch ( eUserCall )
2905 : {
2906 : case SDRUSERCALL_RESIZE:
2907 14984 : notifyShapePropertyChange( ::svx::eShapeSize );
2908 : // fall through - RESIZE might also imply a change of the position
2909 : case SDRUSERCALL_MOVEONLY:
2910 18130 : notifyShapePropertyChange( ::svx::eShapePosition );
2911 18130 : break;
2912 : default:
2913 : // not interested in
2914 22993 : break;
2915 : }
2916 41123 : }
2917 :
2918 : // change ItemPool for this object
2919 5407 : void SdrObject::MigrateItemPool(SfxItemPool* pSrcPool, SfxItemPool* pDestPool, SdrModel* pNewModel)
2920 : {
2921 5407 : if(pSrcPool && pDestPool && (pSrcPool != pDestPool))
2922 : {
2923 5407 : GetProperties().MoveToItemPool(pSrcPool, pDestPool, pNewModel);
2924 : }
2925 5407 : }
2926 :
2927 23244 : void SdrObject::impl_setUnoShape( const uno::Reference< uno::XInterface >& _rxUnoShape )
2928 : {
2929 23244 : maWeakUnoShape = _rxUnoShape;
2930 23244 : mpSvxShape = SvxShape::getImplementation( _rxUnoShape );
2931 23244 : }
2932 :
2933 : /** only for internal use! */
2934 50688 : SvxShape* SdrObject::getSvxShape() const
2935 : {
2936 : DBG_TESTSOLARMUTEX();
2937 : // retrieving the impl pointer and subsequently using it is not thread-safe, of course, so it needs to be
2938 : // guarded by the SolarMutex
2939 :
2940 : #if OSL_DEBUG_LEVEL > 0
2941 : uno::Reference< uno::XInterface > xShape( maWeakUnoShape );
2942 : OSL_ENSURE( !( !xShape.is() && mpSvxShape ),
2943 : "SdrObject::getSvxShape: still having IMPL-Pointer to dead object!" );
2944 : #endif
2945 :
2946 50688 : return mpSvxShape;
2947 : }
2948 :
2949 8199 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SdrObject::getUnoShape()
2950 : {
2951 : // try weak reference first
2952 8199 : uno::Reference< uno::XInterface > xShape( getWeakUnoShape() );
2953 8199 : if( !xShape.is() )
2954 : {
2955 : OSL_ENSURE( mpSvxShape == NULL, "SdrObject::getUnoShape: XShape already dead, but still an IMPL pointer!" );
2956 6760 : if ( pPage )
2957 : {
2958 3383 : uno::Reference< uno::XInterface > xPage( pPage->getUnoPage() );
2959 3383 : if( xPage.is() )
2960 : {
2961 3383 : SvxDrawPage* pDrawPage = SvxDrawPage::getImplementation(xPage);
2962 3383 : if( pDrawPage )
2963 : {
2964 : // create one
2965 3383 : xShape = pDrawPage->_CreateShape( this );
2966 3383 : impl_setUnoShape( xShape );
2967 : }
2968 3383 : }
2969 : }
2970 : else
2971 : {
2972 3377 : mpSvxShape = SvxDrawPage::CreateShapeByTypeAndInventor( GetObjIdentifier(), GetObjInventor(), this, NULL );
2973 3377 : maWeakUnoShape = xShape = static_cast< ::cppu::OWeakObject* >( mpSvxShape );
2974 : }
2975 : }
2976 :
2977 8199 : return xShape;
2978 : }
2979 :
2980 19861 : void SdrObject::setUnoShape(const uno::Reference<uno::XInterface >& _rxUnoShape)
2981 : {
2982 19861 : impl_setUnoShape( _rxUnoShape );
2983 19861 : }
2984 :
2985 413 : ::svx::PropertyChangeNotifier& SdrObject::getShapePropertyChangeNotifier()
2986 : {
2987 : DBG_TESTSOLARMUTEX();
2988 :
2989 413 : SvxShape* pSvxShape = getSvxShape();
2990 413 : ENSURE_OR_THROW( pSvxShape, "no SvxShape, yet!" );
2991 413 : return pSvxShape->getShapePropertyChangeNotifier();
2992 : }
2993 :
2994 33160 : void SdrObject::notifyShapePropertyChange( const ::svx::ShapeProperty _eProperty ) const
2995 : {
2996 : DBG_TESTSOLARMUTEX();
2997 :
2998 33160 : SvxShape* pSvxShape = const_cast< SdrObject* >( this )->getSvxShape();
2999 33160 : if ( pSvxShape )
3000 19177 : return pSvxShape->getShapePropertyChangeNotifier().notifyPropertyChange( _eProperty );
3001 : }
3002 :
3003 : ////////////////////////////////////////////////////////////////////////////////////////////////////
3004 : //
3005 : // transformation interface for StarOfficeAPI. This implements support for
3006 : // homogeneous 3x3 matrices containing the transformation of the SdrObject. At the
3007 : // moment it contains a shearX, rotation and translation, but for setting all linear
3008 : // transforms like Scale, ShearX, ShearY, Rotate and Translate are supported.
3009 : //
3010 : ////////////////////////////////////////////////////////////////////////////////////////////////////
3011 : // gets base transformation and rectangle of object. If it's an SdrPathObj it fills the PolyPolygon
3012 : // with the base geometry and returns TRUE. Otherwise it returns FALSE.
3013 15 : sal_Bool SdrObject::TRGetBaseGeometry(basegfx::B2DHomMatrix& rMatrix, basegfx::B2DPolyPolygon& /*rPolyPolygon*/) const
3014 : {
3015 : // any kind of SdrObject, just use SnapRect
3016 15 : Rectangle aRectangle(GetSnapRect());
3017 :
3018 : // convert to transformation values
3019 15 : basegfx::B2DTuple aScale(aRectangle.GetWidth(), aRectangle.GetHeight());
3020 15 : basegfx::B2DTuple aTranslate(aRectangle.Left(), aRectangle.Top());
3021 :
3022 : // position maybe relative to anchorpos, convert
3023 15 : if( pModel && pModel->IsWriter() )
3024 : {
3025 0 : if(GetAnchorPos().X() || GetAnchorPos().Y())
3026 : {
3027 0 : aTranslate -= basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
3028 : }
3029 : }
3030 :
3031 : // force MapUnit to 100th mm
3032 15 : SfxMapUnit eMapUnit = GetObjectItemSet().GetPool()->GetMetric(0);
3033 15 : if(eMapUnit != SFX_MAPUNIT_100TH_MM)
3034 : {
3035 0 : switch(eMapUnit)
3036 : {
3037 : case SFX_MAPUNIT_TWIP :
3038 : {
3039 : // position
3040 0 : aTranslate.setX(ImplTwipsToMM(aTranslate.getX()));
3041 0 : aTranslate.setY(ImplTwipsToMM(aTranslate.getY()));
3042 :
3043 : // size
3044 0 : aScale.setX(ImplTwipsToMM(aScale.getX()));
3045 0 : aScale.setY(ImplTwipsToMM(aScale.getY()));
3046 :
3047 0 : break;
3048 : }
3049 : default:
3050 : {
3051 : OSL_FAIL("TRGetBaseGeometry: Missing unit translation to 100th mm!");
3052 : }
3053 : }
3054 : }
3055 :
3056 : // build matrix
3057 15 : rMatrix = basegfx::tools::createScaleTranslateB2DHomMatrix(aScale, aTranslate);
3058 :
3059 15 : return false;
3060 : }
3061 :
3062 : // sets the base geometry of the object using infos contained in the homogeneous 3x3 matrix.
3063 : // If it's an SdrPathObj it will use the provided geometry information. The Polygon has
3064 : // to use (0,0) as upper left and will be scaled to the given size in the matrix.
3065 15 : void SdrObject::TRSetBaseGeometry(const basegfx::B2DHomMatrix& rMatrix, const basegfx::B2DPolyPolygon& /*rPolyPolygon*/)
3066 : {
3067 : // break up matrix
3068 15 : basegfx::B2DTuple aScale;
3069 15 : basegfx::B2DTuple aTranslate;
3070 : double fRotate, fShearX;
3071 15 : rMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
3072 :
3073 : // #i75086# Old DrawingLayer (GeoStat and geometry) does not support holding negative scalings
3074 : // in X and Y which equal a 180 degree rotation. Recognize it and react accordingly
3075 15 : if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
3076 : {
3077 0 : aScale.setX(fabs(aScale.getX()));
3078 0 : aScale.setY(fabs(aScale.getY()));
3079 0 : fRotate = fmod(fRotate + F_PI, F_2PI);
3080 : }
3081 :
3082 : // force metric to pool metric
3083 15 : SfxMapUnit eMapUnit = GetObjectItemSet().GetPool()->GetMetric(0);
3084 15 : if(eMapUnit != SFX_MAPUNIT_100TH_MM)
3085 : {
3086 0 : switch(eMapUnit)
3087 : {
3088 : case SFX_MAPUNIT_TWIP :
3089 : {
3090 : // position
3091 0 : aTranslate.setX(ImplMMToTwips(aTranslate.getX()));
3092 0 : aTranslate.setY(ImplMMToTwips(aTranslate.getY()));
3093 :
3094 : // size
3095 0 : aScale.setX(ImplMMToTwips(aScale.getX()));
3096 0 : aScale.setY(ImplMMToTwips(aScale.getY()));
3097 :
3098 0 : break;
3099 : }
3100 : default:
3101 : {
3102 : OSL_FAIL("TRSetBaseGeometry: Missing unit translation to PoolMetric!");
3103 : }
3104 : }
3105 : }
3106 :
3107 : // if anchor is used, make position relative to it
3108 15 : if( pModel && pModel->IsWriter() )
3109 : {
3110 0 : if(GetAnchorPos().X() || GetAnchorPos().Y())
3111 : {
3112 0 : aTranslate += basegfx::B2DTuple(GetAnchorPos().X(), GetAnchorPos().Y());
3113 : }
3114 : }
3115 :
3116 : // build BaseRect
3117 15 : Point aPoint(FRound(aTranslate.getX()), FRound(aTranslate.getY()));
3118 15 : Rectangle aBaseRect(aPoint, Size(FRound(aScale.getX()), FRound(aScale.getY())));
3119 :
3120 : // set BaseRect
3121 15 : SetSnapRect(aBaseRect);
3122 15 : }
3123 :
3124 : // Give info if object is in destruction
3125 0 : bool SdrObject::IsInDestruction() const
3126 : {
3127 0 : if(pModel)
3128 0 : return pModel->IsInDestruction();
3129 0 : return false;
3130 : }
3131 :
3132 : // return if fill is != XFILL_NONE
3133 0 : bool SdrObject::HasFillStyle() const
3134 : {
3135 0 : return (((const XFillStyleItem&)GetObjectItem(XATTR_FILLSTYLE)).GetValue() != XFILL_NONE);
3136 : }
3137 :
3138 0 : bool SdrObject::HasLineStyle() const
3139 : {
3140 0 : return (((const XLineStyleItem&)GetObjectItem(XATTR_LINESTYLE)).GetValue() != XLINE_NONE);
3141 : }
3142 :
3143 :
3144 : // #i52224#
3145 : // on import of OLE object from MS documents the BLIP size might be retrieved,
3146 : // the following four methods are used to control it;
3147 : // usually this data makes no sence after the import is finished, since the object
3148 : // might be resized
3149 :
3150 4 : Rectangle SdrObject::GetBLIPSizeRectangle() const
3151 : {
3152 4 : return maBLIPSizeRectangle;
3153 : }
3154 :
3155 6 : void SdrObject::SetBLIPSizeRectangle( const Rectangle& aRect )
3156 : {
3157 6 : maBLIPSizeRectangle = aRect;
3158 6 : }
3159 :
3160 52 : void SdrObject::SetContextWritingMode( const sal_Int16 /*_nContextWritingMode*/ )
3161 : {
3162 : // this base class does not support different writing modes, so ignore the call
3163 52 : }
3164 :
3165 :
3166 0 : SdrObjFactory::SdrObjFactory(sal_uInt32 nInvent, sal_uInt16 nIdent, SdrPage* pNewPage, SdrModel* pNewModel)
3167 : {
3168 0 : nInventor=nInvent;
3169 0 : nIdentifier=nIdent;
3170 0 : pNewObj=NULL;
3171 0 : pPage=pNewPage;
3172 0 : pModel=pNewModel;
3173 0 : pObj=NULL;
3174 0 : pNewData=NULL;
3175 0 : }
3176 :
3177 3493 : SdrObject* SdrObjFactory::MakeNewObject(sal_uInt32 nInvent, sal_uInt16 nIdent, SdrPage* pPage, SdrModel* pModel)
3178 : {
3179 3493 : if(pModel == NULL && pPage != NULL)
3180 3489 : pModel = pPage->GetModel();
3181 3493 : SdrObject* pObj = NULL;
3182 :
3183 3493 : if(nInvent == SdrInventor)
3184 : {
3185 3493 : switch (nIdent)
3186 : {
3187 0 : case sal_uInt16(OBJ_NONE ): pObj=new SdrObject; break;
3188 1241 : case sal_uInt16(OBJ_GRUP ): pObj=new SdrObjGroup; break;
3189 0 : case sal_uInt16(OBJ_LINE ): pObj=new SdrPathObj(OBJ_LINE ); break;
3190 496 : case sal_uInt16(OBJ_POLY ): pObj=new SdrPathObj(OBJ_POLY ); break;
3191 254 : case sal_uInt16(OBJ_PLIN ): pObj=new SdrPathObj(OBJ_PLIN ); break;
3192 3 : case sal_uInt16(OBJ_PATHLINE ): pObj=new SdrPathObj(OBJ_PATHLINE ); break;
3193 2 : case sal_uInt16(OBJ_PATHFILL ): pObj=new SdrPathObj(OBJ_PATHFILL ); break;
3194 0 : case sal_uInt16(OBJ_FREELINE ): pObj=new SdrPathObj(OBJ_FREELINE ); break;
3195 0 : case sal_uInt16(OBJ_FREEFILL ): pObj=new SdrPathObj(OBJ_FREEFILL ); break;
3196 0 : case sal_uInt16(OBJ_PATHPOLY ): pObj=new SdrPathObj(OBJ_POLY ); break;
3197 0 : case sal_uInt16(OBJ_PATHPLIN ): pObj=new SdrPathObj(OBJ_PLIN ); break;
3198 0 : case sal_uInt16(OBJ_EDGE ): pObj=new SdrEdgeObj; break;
3199 461 : case sal_uInt16(OBJ_RECT ): pObj=new SdrRectObj; break;
3200 3 : case sal_uInt16(OBJ_CIRC ): pObj=new SdrCircObj(OBJ_CIRC ); break;
3201 0 : case sal_uInt16(OBJ_SECT ): pObj=new SdrCircObj(OBJ_SECT ); break;
3202 0 : case sal_uInt16(OBJ_CARC ): pObj=new SdrCircObj(OBJ_CARC ); break;
3203 0 : case sal_uInt16(OBJ_CCUT ): pObj=new SdrCircObj(OBJ_CCUT ); break;
3204 907 : case sal_uInt16(OBJ_TEXT ): pObj=new SdrRectObj(OBJ_TEXT ); break;
3205 0 : case sal_uInt16(OBJ_TEXTEXT ): pObj=new SdrRectObj(OBJ_TEXTEXT ); break;
3206 0 : case sal_uInt16(OBJ_TITLETEXT ): pObj=new SdrRectObj(OBJ_TITLETEXT ); break;
3207 0 : case sal_uInt16(OBJ_OUTLINETEXT): pObj=new SdrRectObj(OBJ_OUTLINETEXT); break;
3208 0 : case sal_uInt16(OBJ_MEASURE ): pObj=new SdrMeasureObj; break;
3209 35 : case sal_uInt16(OBJ_GRAF ): pObj=new SdrGrafObj; break;
3210 4 : case sal_uInt16(OBJ_OLE2 ): pObj=new SdrOle2Obj; break;
3211 0 : case sal_uInt16(OBJ_FRAME ): pObj=new SdrOle2Obj(true); break;
3212 1 : case sal_uInt16(OBJ_CAPTION ): pObj=new SdrCaptionObj; break;
3213 0 : case sal_uInt16(OBJ_PAGE ): pObj=new SdrPageObj; break;
3214 0 : case sal_uInt16(OBJ_UNO ): pObj=new SdrUnoObj(String()); break;
3215 84 : case sal_uInt16(OBJ_CUSTOMSHAPE ): pObj=new SdrObjCustomShape(); break;
3216 0 : case sal_uInt16(OBJ_MEDIA ): pObj=new SdrMediaObj(); break;
3217 2 : case sal_uInt16(OBJ_TABLE ): pObj=new ::sdr::table::SdrTableObj(pModel); break;
3218 : }
3219 : }
3220 :
3221 3493 : if(pObj == NULL)
3222 : {
3223 0 : SdrObjFactory* pFact=new SdrObjFactory(nInvent,nIdent,pPage,pModel);
3224 0 : SdrLinkList& rLL=ImpGetUserMakeObjHdl();
3225 0 : unsigned nAnz=rLL.GetLinkCount();
3226 0 : unsigned i=0;
3227 0 : while (i<nAnz && pObj==NULL) {
3228 0 : rLL.GetLink(i).Call((void*)pFact);
3229 0 : pObj=pFact->pNewObj;
3230 0 : i++;
3231 : }
3232 0 : delete pFact;
3233 : }
3234 :
3235 : if(pObj == NULL)
3236 : {
3237 : // Well, if no one wants it...
3238 : }
3239 :
3240 3493 : if(pObj != NULL)
3241 : {
3242 3493 : if(pPage != NULL)
3243 3489 : pObj->SetPage(pPage);
3244 4 : else if(pModel != NULL)
3245 0 : pObj->SetModel(pModel);
3246 : }
3247 :
3248 3493 : return pObj;
3249 : }
3250 :
3251 46 : void SdrObjFactory::InsertMakeObjectHdl(const Link& rLink)
3252 : {
3253 46 : SdrLinkList& rLL=ImpGetUserMakeObjHdl();
3254 46 : rLL.InsertLink(rLink);
3255 46 : }
3256 :
3257 10 : void SdrObjFactory::RemoveMakeObjectHdl(const Link& rLink)
3258 : {
3259 10 : SdrLinkList& rLL=ImpGetUserMakeObjHdl();
3260 10 : rLL.RemoveLink(rLink);
3261 10 : }
3262 :
3263 32 : void SdrObjFactory::InsertMakeUserDataHdl(const Link& rLink)
3264 : {
3265 32 : SdrLinkList& rLL=ImpGetUserMakeObjUserDataHdl();
3266 32 : rLL.InsertLink(rLink);
3267 32 : }
3268 :
3269 26 : void SdrObjFactory::RemoveMakeUserDataHdl(const Link& rLink)
3270 : {
3271 26 : SdrLinkList& rLL=ImpGetUserMakeObjUserDataHdl();
3272 26 : rLL.RemoveLink(rLink);
3273 26 : }
3274 :
3275 : namespace svx
3276 : {
3277 0 : ISdrObjectFilter::~ISdrObjectFilter()
3278 : {
3279 0 : }
3280 : }
3281 :
3282 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
