svx/source/svdraw/svdobj.cxx

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