LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdobj.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1770 0.0 %
Date: 2014-04-14 Functions: 0 291 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10