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