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