diff options
Diffstat (limited to 'svx/source/unodraw/unoshape.cxx')
| -rw-r--r-- | svx/source/unodraw/unoshape.cxx | 4011 |
1 files changed, 4011 insertions, 0 deletions
diff --git a/svx/source/unodraw/unoshape.cxx b/svx/source/unodraw/unoshape.cxx new file mode 100644 index 000000000..f5be3192d --- /dev/null +++ b/svx/source/unodraw/unoshape.cxx @@ -0,0 +1,4011 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <cppuhelper/supportsservice.hxx> +#include <com/sun/star/awt/XBitmap.hpp> +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/drawing/CircleKind.hpp> +#include <com/sun/star/lang/NoSupportException.hpp> +#include <vcl/svapp.hxx> +#include <svl/itemprop.hxx> +#include <o3tl/any.hxx> +#include <osl/mutex.hxx> +#include <editeng/unotext.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdoole2.hxx> +#include <svx/shapepropertynotifier.hxx> +#include <comphelper/scopeguard.hxx> +#include <comphelper/servicehelper.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <vcl/gfxlink.hxx> +#include <vcl/virdev.hxx> +#include <svx/sdangitm.hxx> +#include <svx/svdlayer.hxx> +#include <svx/svdopage.hxx> +#include <svx/xflbstit.hxx> +#include <svx/xflbmtit.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnedit.hxx> +#include <svx/svdmodel.hxx> +#include <svx/globl3d.hxx> +#include <svx/unopage.hxx> +#include <svx/unoshape.hxx> +#include <svx/unoshtxt.hxx> +#include <svx/svdpage.hxx> +#include <svx/unoshprp.hxx> +#include <svx/svdograf.hxx> +#include <svx/unoapi.hxx> +#include <svx/svdomeas.hxx> +#include <svx/svdpool.hxx> +#include <tools/stream.hxx> +#include <tools/gen.hxx> +#include <svx/svdoedge.hxx> +#include <svx/svdocapt.hxx> +#include <svx/obj3d.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xtable.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlndsit.hxx> +#include <svx/unomaster.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include "gluepts.hxx" +#include "shapeimpl.hxx" +#include <sal/log.hxx> + +#include <svx/lathe3d.hxx> +#include <extrud3d.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <drawinglayer/primitive2d/transformprimitive2d.hxx> + +#include <vcl/gdimtf.hxx> +#include <vcl/wmf.hxx> +#include <svx/sdtfsitm.hxx> +#include <svx/svdoutl.hxx> + +#include <memory> +#include <vector> +#include <iostream> + +#include <bitmaps.hlst> + +using namespace ::osl; +using namespace ::cppu; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::container; +using svx::PropertyValueProvider; + +class GDIMetaFile; + +struct SvxShapeImpl +{ + SvxShape& mrAntiImpl; + std::unique_ptr<SfxItemSet> mpItemSet; + sal_uInt32 mnObjId; + SvxShapeMaster* mpMaster; + bool mbHasSdrObjectOwnership; + bool mbDisposing; + + /** CL, OD 2005-07-19 #i52126# - this is initially 0 and set when + * a SvxShape::Create() call is executed. It is then set to the created + * SdrObject so a multiple call to SvxShape::Create() with same SdrObject + * is prohibited. + */ + ::tools::WeakReference< SdrObject > mpCreatedObj; + + // for xComponent + ::comphelper::OInterfaceContainerHelper2 maDisposeListeners; + svx::PropertyChangeNotifier maPropertyNotifier; + + SvxShapeImpl( SvxShape& _rAntiImpl, ::osl::Mutex& _rMutex ) + :mrAntiImpl( _rAntiImpl ) + ,mnObjId( 0 ) + ,mpMaster( nullptr ) + ,mbHasSdrObjectOwnership( false ) + ,mbDisposing( false ) + ,mpCreatedObj() + ,maDisposeListeners( _rMutex ) + ,maPropertyNotifier( _rAntiImpl, _rMutex ) + { + } +}; + +namespace { + +class ShapePositionProvider : public PropertyValueProvider +{ +public: + explicit ShapePositionProvider( const SvxShapeImpl& _shapeImpl ) + :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Position" ) + { + } + +protected: + virtual void getCurrentValue( Any& _out_rCurrentValue ) const override + { + _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getPosition(); + } +}; + + +class ShapeSizeProvider : public PropertyValueProvider +{ +public: + explicit ShapeSizeProvider( const SvxShapeImpl& _shapeImpl ) + :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Size" ) + { + } + +protected: + virtual void getCurrentValue( Any& _out_rCurrentValue ) const override + { + _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getSize(); + } +}; + +/// Calculates what scaling factor will be used for autofit text scaling of this shape. +sal_Int16 GetTextFitToSizeScale(SdrObject* pObject) +{ + SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(pObject); + if (!pTextObj) + { + return 0; + } + + const SfxItemSet& rTextObjSet = pTextObj->GetMergedItemSet(); + if (rTextObjSet.GetItem<SdrTextFitToSizeTypeItem>(SDRATTR_TEXT_FITTOSIZE)->GetValue() + != drawing::TextFitToSizeType_AUTOFIT) + { + return 0; + } + + std::unique_ptr<SdrOutliner> pOutliner + = pTextObj->getSdrModelFromSdrObject().createOutliner(OutlinerMode::TextObject); + tools::Rectangle aBoundRect(pTextObj->GetCurrentBoundRect()); + pTextObj->SetupOutlinerFormatting(*pOutliner, aBoundRect); + sal_uInt16 nX = 0; + sal_uInt16 nY = 0; + pOutliner->GetGlobalCharStretching(nX, nY); + return nY; +} +} + +SvxShape::SvxShape( SdrObject* pObject ) +: maSize(100,100) +, mpImpl( new SvxShapeImpl( *this, maMutex ) ) +, mbIsMultiPropertyCall(false) +, mpPropSet(getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool())) +, maPropMapEntries(getSvxMapProvider().GetMap(SVXMAP_SHAPE)) +, mpSdrObjectWeakReference(pObject) +, mnLockCount(0) +{ + impl_construct(); +} + + +SvxShape::SvxShape( SdrObject* pObject, const SfxItemPropertyMapEntry* pEntries, const SvxItemPropertySet* pPropertySet ) +: maSize(100,100) +, mpImpl( new SvxShapeImpl( *this, maMutex ) ) +, mbIsMultiPropertyCall(false) +, mpPropSet(pPropertySet) +, maPropMapEntries(pEntries) +, mpSdrObjectWeakReference(pObject) +, mnLockCount(0) +{ + impl_construct(); +} + + +SvxShape::~SvxShape() throw() +{ + ::SolarMutexGuard aGuard; + + DBG_ASSERT( mnLockCount == 0, "Locked shape was disposed!" ); + + if ( mpImpl->mpMaster ) + mpImpl->mpMaster->dispose(); + + if ( HasSdrObject() ) + { + EndListening(GetSdrObject()->getSdrModelFromSdrObject()); + GetSdrObject()->setUnoShape(nullptr); + } + + if( HasSdrObjectOwnership() && HasSdrObject() ) + { + mpImpl->mbHasSdrObjectOwnership = false; + SdrObject* pObject = GetSdrObject(); + SdrObject::Free( pObject ); + } + + EndListeningAll(); // call explicitly within SolarMutexGuard +} + + +void SvxShape::TakeSdrObjectOwnership() +{ + mpImpl->mbHasSdrObjectOwnership = true; +} + + +void SvxShape::InvalidateSdrObject() +{ + if(HasSdrObject()) + { + EndListening(GetSdrObject()->getSdrModelFromSdrObject()); + } + + if (HasSdrObjectOwnership()) + return; + + mpSdrObjectWeakReference.reset(nullptr); +}; + +bool SvxShape::HasSdrObjectOwnership() const +{ + if ( !mpImpl->mbHasSdrObjectOwnership ) + return false; + + OSL_ENSURE( HasSdrObject(), "SvxShape::HasSdrObjectOwnership: have the ownership of an object which I don't know!" ); + return HasSdrObject(); +} + + +void SvxShape::setShapeKind( sal_uInt32 nKind ) +{ + mpImpl->mnObjId = nKind; +} + + +sal_uInt32 SvxShape::getShapeKind() const +{ + return mpImpl->mnObjId; +} + + +void SvxShape::setMaster( SvxShapeMaster* pMaster ) +{ + mpImpl->mpMaster = pMaster; +} + + +uno::Any SAL_CALL SvxShape::queryAggregation( const uno::Type& rType ) +{ + if( mpImpl->mpMaster ) + { + uno::Any aAny; + if( mpImpl->mpMaster->queryAggregation( rType, aAny ) ) + return aAny; + } + + return SvxShape_UnoImplHelper::queryAggregation(rType); +} + +namespace +{ + class theSvxShapeUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvxShapeUnoTunnelId > {}; +} + +const css::uno::Sequence< sal_Int8 > & SvxShape::getUnoTunnelId() throw() +{ + return theSvxShapeUnoTunnelId::get().getSeq(); +} + +sal_Int64 SAL_CALL SvxShape::getSomething( const css::uno::Sequence< sal_Int8 >& rId ) +{ + if( isUnoTunnelId<SvxShape>(rId) ) + { + return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this)); + } + else + { + return 0; + } +} + + +svx::PropertyChangeNotifier& SvxShape::getShapePropertyChangeNotifier() +{ + return mpImpl->maPropertyNotifier; +} + + +void SvxShape::impl_construct() +{ + mpImpl->maPropertyNotifier.registerProvider( svx::ShapeProperty::Position, + std::make_shared<ShapePositionProvider>( *mpImpl ) ); + mpImpl->maPropertyNotifier.registerProvider( svx::ShapeProperty::Size, + std::make_shared<ShapeSizeProvider>( *mpImpl ) ); + + if ( HasSdrObject() ) + { + StartListening(GetSdrObject()->getSdrModelFromSdrObject()); + impl_initFromSdrObject(); + } +} + + +void SvxShape::impl_initFromSdrObject() +{ + DBG_TESTSOLARMUTEX(); + OSL_PRECOND( HasSdrObject(), "SvxShape::impl_initFromSdrObject: not to be called without SdrObject!" ); + if ( !HasSdrObject() ) + return; + + osl_atomic_increment( &m_refCount ); + { + GetSdrObject()->setUnoShape(*this); + } + osl_atomic_decrement( &m_refCount ); + + // #i40944# + // Do not simply return when no model but do the type corrections + // following below. + const SdrInventor nInventor = GetSdrObject()->GetObjInventor(); + + // is it one of ours (svx) ? + if( nInventor == SdrInventor::Default || nInventor == SdrInventor::E3d || nInventor == SdrInventor::FmForm ) + { + if(nInventor == SdrInventor::FmForm) + { + mpImpl->mnObjId = OBJ_UNO; + } + else + { + mpImpl->mnObjId = GetSdrObject()->GetObjIdentifier(); + if( nInventor == SdrInventor::E3d ) + mpImpl->mnObjId |= E3D_INVENTOR_FLAG; + } + + switch(mpImpl->mnObjId) + { + case OBJ_CCUT: // segment of circle + case OBJ_CARC: // arc of circle + case OBJ_SECT: // sector + mpImpl->mnObjId = OBJ_CIRC; + break; + } + } +} + + +void SvxShape::Create( SdrObject* pNewObj, SvxDrawPage* /*pNewPage*/ ) +{ + DBG_TESTSOLARMUTEX(); + + OSL_PRECOND( pNewObj, "SvxShape::Create: invalid new object!" ); + if ( !pNewObj ) + return; + + SdrObject* pCreatedObj = mpImpl->mpCreatedObj.get(); + OSL_ENSURE( ( pCreatedObj == nullptr ) || ( pCreatedObj == pNewObj ), + "SvxShape::Create: the same shape used for two different objects?! Strange ..." ); + + // Correct condition (#i52126#) + if ( pCreatedObj == pNewObj ) + return; + + // Correct condition (#i52126#) + mpImpl->mpCreatedObj = pNewObj; + + if( HasSdrObject() ) + { + EndListening( GetSdrObject()->getSdrModelFromSdrObject() ); + } + + mpSdrObjectWeakReference.reset( pNewObj ); + + if( HasSdrObject() ) + { + StartListening( GetSdrObject()->getSdrModelFromSdrObject() ); + } + + OSL_ENSURE( !mbIsMultiPropertyCall, "SvxShape::Create: hmm?" ); + // this was previously set in impl_initFromSdrObject, but I think it was superfluous + // (it definitely was in the other context where it was called, but I strongly suppose + // it was also superfluous when called from here) + impl_initFromSdrObject(); + + ObtainSettingsFromPropertySet( *mpPropSet ); + + // save user call + SdrObjUserCall* pUser = GetSdrObject()->GetUserCall(); + GetSdrObject()->SetUserCall(nullptr); + + setPosition( maPosition ); + setSize( maSize ); + + // restore user call after we set the initial size + GetSdrObject()->SetUserCall( pUser ); + + // if this shape was already named, use this name + if( !maShapeName.isEmpty() ) + { + GetSdrObject()->SetName( maShapeName ); + maShapeName.clear(); + } +} + +void SvxShape::ForceMetricToItemPoolMetric(Pair& rPoint) const throw() +{ + DBG_TESTSOLARMUTEX(); + if(HasSdrObject()) + { + MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0)); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + rPoint.A() = MM_TO_TWIPS(rPoint.A()); + rPoint.B() = MM_TO_TWIPS(rPoint.B()); + break; + } + default: + { + OSL_FAIL("AW: Missing unit translation to PoolMetric!"); + } + } + } + } +} + +void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon& rPolyPolygon) const throw() +{ + DBG_TESTSOLARMUTEX(); + if(HasSdrObject()) + { + MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0)); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + basegfx::B2DHomMatrix aTransform; + const double fMMToTWIPS(72.0 / 127.0); + + aTransform.scale(fMMToTWIPS, fMMToTWIPS); + rPolyPolygon.transform(aTransform); + break; + } + default: + { + OSL_FAIL("Missing unit translation to PoolMetric!"); + } + } + } + } +} + +void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DHomMatrix& rB2DHomMatrix) const throw() +{ + DBG_TESTSOLARMUTEX(); + if(HasSdrObject()) + { + MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0)); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + const double fMMToTWIPS(72.0 / 127.0); + const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix); + rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aDecomposedTransform.getScale() * fMMToTWIPS, + aDecomposedTransform.getShearX(), + aDecomposedTransform.getRotate(), + aDecomposedTransform.getTranslate() * fMMToTWIPS); + break; + } + default: + { + OSL_FAIL("Missing unit translation to PoolMetric!"); + } + } + } + } +} + +void SvxShape::ForceMetricTo100th_mm(Pair& rPoint) const throw() +{ + DBG_TESTSOLARMUTEX(); + MapUnit eMapUnit = MapUnit::Map100thMM; + if(HasSdrObject()) + { + eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + rPoint.A() = TWIPS_TO_MM(rPoint.A()); + rPoint.B() = TWIPS_TO_MM(rPoint.B()); + break; + } + default: + { + OSL_FAIL("AW: Missing unit translation to 100th mm!"); + } + } + } + } +} + +void SvxShape::ForceMetricTo100th_mm(basegfx::B2DPolyPolygon& rPolyPolygon) const throw() +{ + DBG_TESTSOLARMUTEX(); + MapUnit eMapUnit = MapUnit::Map100thMM; + if(HasSdrObject()) + { + eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + basegfx::B2DHomMatrix aTransform; + const double fTWIPSToMM(127.0 / 72.0); + aTransform.scale(fTWIPSToMM, fTWIPSToMM); + rPolyPolygon.transform(aTransform); + break; + } + default: + { + OSL_FAIL("Missing unit translation to 100th mm!"); + } + } + } + } +} + +void SvxShape::ForceMetricTo100th_mm(basegfx::B2DHomMatrix& rB2DHomMatrix) const throw() +{ + DBG_TESTSOLARMUTEX(); + MapUnit eMapUnit = MapUnit::Map100thMM; + if(HasSdrObject()) + { + eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0); + if(eMapUnit != MapUnit::Map100thMM) + { + switch(eMapUnit) + { + case MapUnit::MapTwip : + { + const double fTWIPSToMM(127.0 / 72.0); + const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix); + rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aDecomposedTransform.getScale() * fTWIPSToMM, + aDecomposedTransform.getShearX(), + aDecomposedTransform.getRotate(), + aDecomposedTransform.getTranslate() * fTWIPSToMM); + break; + } + default: + { + OSL_FAIL("Missing unit translation to 100th mm!"); + } + } + } + } +} + +static void SvxItemPropertySet_ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet, + SfxItemSet& rSet, const uno::Reference< beans::XPropertySet >& xSet, const SfxItemPropertyMap* pMap ) +{ + if(rPropSet.AreThereOwnUsrAnys()) + { + const SfxItemPropertyMap& rSrc = rPropSet.getPropertyMap(); + PropertyEntryVector_t aSrcPropVector = rSrc.getPropertyEntries(); + + for(const auto& rSrcProp : aSrcPropVector) + { + const sal_uInt16 nWID = rSrcProp.nWID; + if(SfxItemPool::IsWhich(nWID) + && (nWID < OWN_ATTR_VALUE_START || nWID > OWN_ATTR_VALUE_END) + && rPropSet.GetUsrAnyForID(rSrcProp)) + rSet.Put(rSet.GetPool()->GetDefaultItem(nWID)); + } + + for(const auto& rSrcProp : aSrcPropVector) + { + if(rSrcProp.nWID) + { + uno::Any* pUsrAny = rPropSet.GetUsrAnyForID(rSrcProp); + if(pUsrAny) + { + // search for equivalent entry in pDst + const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( rSrcProp.sName ); + if(pEntry) + { + // entry found + if(pEntry->nWID >= OWN_ATTR_VALUE_START && pEntry->nWID <= OWN_ATTR_VALUE_END) + { + // special ID in PropertySet, can only be set + // directly at the object + xSet->setPropertyValue( rSrcProp.sName, *pUsrAny); + } + else + { + SvxItemPropertySet_setPropertyValue(pEntry, *pUsrAny, rSet); + } + } + } + } + } + const_cast< SvxItemPropertySet& >(rPropSet).ClearAllUsrAny(); + } +} + + +void SvxShape::ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet) +{ + DBG_TESTSOLARMUTEX(); + if(HasSdrObject() && rPropSet.AreThereOwnUsrAnys()) + { + SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), svl::Items<SDRATTR_START, SDRATTR_END>{}); + Reference< beans::XPropertySet > xShape( static_cast<OWeakObject*>(this), UNO_QUERY ); + SvxItemPropertySet_ObtainSettingsFromPropertySet(rPropSet, aSet, xShape, &mpPropSet->getPropertyMap() ); + + GetSdrObject()->SetMergedItemSetAndBroadcast(aSet); + + GetSdrObject()->ApplyNotPersistAttr( aSet ); + } +} + +uno::Any SvxShape::GetBitmap( bool bMetaFile /* = false */ ) const +{ + DBG_TESTSOLARMUTEX(); + uno::Any aAny; + + if(!HasSdrObject() || nullptr == GetSdrObject()->getSdrPageFromSdrObject()) + { + return aAny; + } + + // tdf#118662 Emulate old behaviour of XclObjComment (see there) + const SdrCaptionObj* pSdrCaptionObj(dynamic_cast<SdrCaptionObj*>(GetSdrObject())); + if(nullptr != pSdrCaptionObj && pSdrCaptionObj->isSuppressGetBitmap()) + { + return aAny; + } + + // tdf#119180 If we do not ask for Metafile and we access a SdrGrafObj, + // and content exists and is a Bitmap, take the shortcut. + // Do *not* do this for Metafile - as can be seen, requested in that case + // is a byte-sequence of a saved WMF format file (see below) + if(!bMetaFile) + { + const SdrGrafObj* pSdrGrafObj(dynamic_cast<SdrGrafObj*>(GetSdrObject())); + + if(nullptr != pSdrGrafObj) + { + const Graphic& rGraphic(pSdrGrafObj->GetGraphic()); + + if(GraphicType::Bitmap == rGraphic.GetType()) + { + Reference< awt::XBitmap > xBmp( rGraphic.GetXGraphic(), UNO_QUERY ); + aAny <<= xBmp; + + return aAny; + } + } + } + + // tdf#118662 instead of creating an E3dView instance every time to paint + // a single SdrObject, use the existing SdrObject::SingleObjectPainter to + // use less resources and runtime + if(bMetaFile) + { + ScopedVclPtrInstance< VirtualDevice > pVDev; + const tools::Rectangle aBoundRect(GetSdrObject()->GetCurrentBoundRect()); + GDIMetaFile aMtf; + + pVDev->SetMapMode(MapMode(MapUnit::Map100thMM)); + pVDev->EnableOutput(false); + aMtf.Record(pVDev); + GetSdrObject()->SingleObjectPainter(*pVDev); + aMtf.Stop(); + aMtf.WindStart(); + aMtf.Move(-aBoundRect.Left(), -aBoundRect.Top()); + aMtf.SetPrefMapMode(MapMode(MapUnit::Map100thMM)); + aMtf.SetPrefSize(aBoundRect.GetSize()); + + SvMemoryStream aDestStrm(65535, 65535); + + ConvertGDIMetaFileToWMF( + aMtf, + aDestStrm, + nullptr, + false); + + const uno::Sequence<sal_Int8> aSeq( + static_cast< const sal_Int8* >(aDestStrm.GetData()), + aDestStrm.GetEndOfData()); + + aAny <<= aSeq; + } + else + { + drawinglayer::primitive2d::Primitive2DContainer xPrimitives( + GetSdrObject()->GetViewContact().getViewIndependentPrimitive2DContainer()); + + if(!xPrimitives.empty()) + { + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + basegfx::B2DRange aRange( + xPrimitives.getB2DRange(aViewInformation2D)); + + if(!aRange.isEmpty()) + { + const MapUnit aSourceMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetScaleUnit()); + + if(MapUnit::Map100thMM != aSourceMapUnit) + { + // tdf#119180 This is UNO API and thus works in 100th_mm, + // so if the MapMode from the used SdrModel is *not* equal + // to Map100thMM we need to embed the primitives to an adapting + // homogen transformation for correct values + const basegfx::B2DHomMatrix aMapTransform( + OutputDevice::LogicToLogic( + MapMode(aSourceMapUnit), + MapMode(MapUnit::Map100thMM))); + + // Embed primitives to get them in 100th mm + const drawinglayer::primitive2d::Primitive2DReference xEmbedRef( + new drawinglayer::primitive2d::TransformPrimitive2D( + aMapTransform, + xPrimitives)); + + xPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xEmbedRef }; + + // Update basegfx::B2DRange aRange, too. Here we have the + // choice of transforming the existing value or get newly by + // again using 'xPrimitives.getB2DRange(aViewInformation2D)' + aRange.transform(aMapTransform); + } + + const BitmapEx aBmp( + convertPrimitive2DSequenceToBitmapEx( + xPrimitives, + aRange)); + + Graphic aGraph(aBmp); + + aGraph.SetPrefSize(aBmp.GetPrefSize()); + aGraph.SetPrefMapMode(aBmp.GetPrefMapMode()); + + Reference< awt::XBitmap > xBmp( aGraph.GetXGraphic(), UNO_QUERY ); + aAny <<= xBmp; + } + } + } + + return aAny; +} + +uno::Sequence< uno::Type > SAL_CALL SvxShape::getTypes() +{ + if( mpImpl->mpMaster ) + { + return mpImpl->mpMaster->getTypes(); + } + else + { + return _getTypes(); + } +} + + +uno::Sequence< uno::Type > const & SvxShape::_getTypes() +{ + switch( mpImpl->mnObjId ) + { + // shapes without text + case OBJ_PAGE: + case OBJ_FRAME: + case OBJ_OLE2_PLUGIN: + case OBJ_OLE2_APPLET: + case E3D_CUBEOBJ_ID|E3D_INVENTOR_FLAG: + case E3D_SPHEREOBJ_ID|E3D_INVENTOR_FLAG: + case E3D_LATHEOBJ_ID|E3D_INVENTOR_FLAG: + case E3D_EXTRUDEOBJ_ID|E3D_INVENTOR_FLAG: + case E3D_POLYGONOBJ_ID|E3D_INVENTOR_FLAG: + case OBJ_MEDIA: + case OBJ_TABLE: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + }; + + return aTypeSequence; + } + // group shape + case OBJ_GRUP: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + cppu::UnoType<drawing::XShapes>::get(), + cppu::UnoType<drawing::XShapeGroup>::get(), + }; + + return aTypeSequence; + } + // connector shape + case OBJ_EDGE: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + cppu::UnoType<drawing::XConnectorShape>::get(), + // from SvxUnoTextBase::getTypes() + cppu::UnoType<text::XTextAppend>::get(), + cppu::UnoType<text::XTextCopy>::get(), + cppu::UnoType<container::XEnumerationAccess>::get(), + cppu::UnoType<text::XTextRangeMover>::get(), + }; + + return aTypeSequence; + } + // control shape + case OBJ_UNO: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + cppu::UnoType<drawing::XControlShape>::get(), + }; + + return aTypeSequence; + } + // 3d scene shape + case E3D_SCENE_ID|E3D_INVENTOR_FLAG: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + cppu::UnoType<drawing::XShapes>::get(), + }; + + return aTypeSequence; + } + case OBJ_CUSTOMSHAPE: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + // from SvxUnoTextBase::getTypes() + cppu::UnoType<text::XText>::get(), + cppu::UnoType<container::XEnumerationAccess>::get(), + cppu::UnoType<text::XTextRangeMover>::get(), + cppu::UnoType<drawing::XEnhancedCustomShapeDefaulter>::get(), + }; + + return aTypeSequence; + } + // shapes with text + case OBJ_RECT: + case OBJ_CIRC: + case OBJ_MEASURE: + case OBJ_LINE: + case OBJ_POLY: + case OBJ_PLIN: + case OBJ_PATHLINE: + case OBJ_PATHFILL: + case OBJ_FREELINE: + case OBJ_FREEFILL: + case OBJ_PATHPOLY: + case OBJ_PATHPLIN: + case OBJ_GRAF: + case OBJ_TEXT: + case OBJ_CAPTION: + case OBJ_OLE2: // #i118485# Moved to shapes with text + default: + { + static uno::Sequence<uno::Type> aTypeSequence{ + cppu::UnoType<drawing::XShape>::get(), + cppu::UnoType<lang::XComponent>::get(), + cppu::UnoType<beans::XPropertySet>::get(), + cppu::UnoType<beans::XMultiPropertySet>::get(), + cppu::UnoType<beans::XPropertyState>::get(), + cppu::UnoType<beans::XMultiPropertyStates>::get(), + cppu::UnoType<drawing::XGluePointsSupplier>::get(), + cppu::UnoType<container::XChild>::get(), + cppu::UnoType<lang::XServiceInfo>::get(), + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<lang::XUnoTunnel>::get(), + cppu::UnoType<container::XNamed>::get(), + // from SvxUnoTextBase::getTypes() + cppu::UnoType<text::XTextAppend>::get(), + cppu::UnoType<text::XTextCopy>::get(), + cppu::UnoType<container::XEnumerationAccess>::get(), + cppu::UnoType<text::XTextRangeMover>::get(), + }; + + return aTypeSequence; + } + } +} + + +uno::Sequence< sal_Int8 > SAL_CALL SvxShape::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +void SvxShape::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw() +{ + DBG_TESTSOLARMUTEX(); + if( !HasSdrObject() ) + return; + + // #i55919# SdrHintKind::ObjectChange is only interesting if it's for this object + if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint) + return; + SdrObject* pSdrObject(GetSdrObject()); + const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint); + if ((pSdrHint->GetKind() != SdrHintKind::ModelCleared) && + (pSdrHint->GetKind() != SdrHintKind::ObjectChange || pSdrHint->GetObject() != pSdrObject )) + return; + + uno::Reference< uno::XInterface > xSelf( pSdrObject->getWeakUnoShape() ); + if( !xSelf.is() ) + { + EndListening(pSdrObject->getSdrModelFromSdrObject()); + mpSdrObjectWeakReference.reset(nullptr); + return; + } + + bool bClearMe = false; + + switch( pSdrHint->GetKind() ) + { + case SdrHintKind::ObjectChange: + { + updateShapeKind(); + break; + } + case SdrHintKind::ModelCleared: + { + bClearMe = true; + break; + } + default: + break; + }; + + if( bClearMe ) + { + if(!HasSdrObjectOwnership()) + { + if(nullptr != pSdrObject) + { + EndListening(pSdrObject->getSdrModelFromSdrObject()); + pSdrObject->setUnoShape(nullptr); + } + + mpSdrObjectWeakReference.reset(nullptr); + + // SdrModel *is* going down, try to Free SdrObject even + // when !HasSdrObjectOwnership + if(nullptr != pSdrObject && !pSdrObject->IsInserted()) + { + SdrObject::Free(pSdrObject); + } + } + + if(!mpImpl->mbDisposing) + { + dispose(); + } + } +} + +// XShape + + +// The "*LogicRectHack" functions also existed in sch, and those +// duplicate symbols cause Bad Things To Happen (TM) #i9462#. +// Prefixing with 'svx' and marking static to make sure name collisions +// do not occur. + +static bool svx_needLogicRectHack( SdrObject const * pObj ) +{ + if( pObj->GetObjInventor() == SdrInventor::Default) + { + switch(pObj->GetObjIdentifier()) + { + case OBJ_GRUP: + case OBJ_LINE: + case OBJ_POLY: + case OBJ_PLIN: + case OBJ_PATHLINE: + case OBJ_PATHFILL: + case OBJ_FREELINE: + case OBJ_FREEFILL: + case OBJ_SPLNLINE: + case OBJ_SPLNFILL: + case OBJ_EDGE: + case OBJ_PATHPOLY: + case OBJ_PATHPLIN: + case OBJ_MEASURE: + return true; + } + } + return false; +} + + +static tools::Rectangle svx_getLogicRectHack( SdrObject const * pObj ) +{ + if(svx_needLogicRectHack(pObj)) + { + return pObj->GetSnapRect(); + } + else + { + return pObj->GetLogicRect(); + } +} + + +static void svx_setLogicRectHack( SdrObject* pObj, const tools::Rectangle& rRect ) +{ + if(svx_needLogicRectHack(pObj)) + { + pObj->SetSnapRect( rRect ); + } + else + { + pObj->SetLogicRect( rRect ); + } +} + + +awt::Point SAL_CALL SvxShape::getPosition() +{ + ::SolarMutexGuard aGuard; + + if(HasSdrObject()) + { + tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) ); + Point aPt( aRect.Left(), aRect.Top() ); + + // Position is relative to anchor, so recalc to absolute position + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aPt -= GetSdrObject()->GetAnchorPos(); + + ForceMetricTo100th_mm(aPt); + return css::awt::Point( aPt.X(), aPt.Y() ); + } + else + { + return maPosition; + } +} + + +void SAL_CALL SvxShape::setPosition( const awt::Point& Position ) +{ + ::SolarMutexGuard aGuard; + + if(HasSdrObject()) + { + // do NOT move 3D objects, this would change the homogen + // transformation matrix + if(dynamic_cast<const E3dCompoundObject* >(GetSdrObject()) == nullptr) + { + tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) ); + Point aLocalPos( Position.X, Position.Y ); + ForceMetricToItemPoolMetric(aLocalPos); + + // Position is absolute, so recalc to position relative to anchor + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aLocalPos += GetSdrObject()->GetAnchorPos(); + + long nDX = aLocalPos.X() - aRect.Left(); + long nDY = aLocalPos.Y() - aRect.Top(); + + GetSdrObject()->Move( Size( nDX, nDY ) ); + GetSdrObject()->getSdrModelFromSdrObject().SetChanged(); + } + } + + maPosition = Position; +} + + +awt::Size SAL_CALL SvxShape::getSize() +{ + ::SolarMutexGuard aGuard; + + if(HasSdrObject()) + { + tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) ); + Size aObjSize( aRect.getWidth(), aRect.getHeight() ); + ForceMetricTo100th_mm(aObjSize); + return css::awt::Size( aObjSize.getWidth(), aObjSize.getHeight() ); + } + else + return maSize; +} + + +void SAL_CALL SvxShape::setSize( const awt::Size& rSize ) +{ + ::SolarMutexGuard aGuard; + + if(HasSdrObject()) + { + // #i123539# optimization for 3D chart object generation: do not use UNO + // API commands to get the range, this is too expensive since for 3D + // scenes it may recalculate the whole scene since in AOO this depends + // on the contained geometry (layouted to show all content) + const bool b3DConstruction(dynamic_cast< E3dObject* >(GetSdrObject()) && GetSdrObject()->getSdrModelFromSdrObject().isLocked()); + tools::Rectangle aRect( + b3DConstruction ? + tools::Rectangle(maPosition.X, maPosition.Y, maSize.Width, maSize.Height) : + svx_getLogicRectHack(GetSdrObject()) ); + Size aLocalSize( rSize.Width, rSize.Height ); + ForceMetricToItemPoolMetric(aLocalSize); + + if(GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_MEASURE ) + { + Fraction aWdt(aLocalSize.Width(),aRect.Right()-aRect.Left()); + Fraction aHgt(aLocalSize.Height(),aRect.Bottom()-aRect.Top()); + Point aPt = GetSdrObject()->GetSnapRect().TopLeft(); + GetSdrObject()->Resize(aPt,aWdt,aHgt); + } + else + { + //aRect.SetSize(aLocalSize); // this call subtract 1 // https://bz.apache.org/ooo/show_bug.cgi?id=83193 + if ( !aLocalSize.Width() ) + { + aRect.SetWidthEmpty(); + } + else + aRect.setWidth(aLocalSize.Width()); + if ( !aLocalSize.Height() ) + { + aRect.SetHeightEmpty(); + } + else + aRect.setHeight(aLocalSize.Height()); + + svx_setLogicRectHack( GetSdrObject(), aRect ); + } + + GetSdrObject()->getSdrModelFromSdrObject().SetChanged(); + } + maSize = rSize; +} + + +// XNamed +OUString SAL_CALL SvxShape::getName( ) +{ + ::SolarMutexGuard aGuard; + if( HasSdrObject() ) + { + return GetSdrObject()->GetName(); + } + else + { + return maShapeName; + } +} + + +void SAL_CALL SvxShape::setName( const OUString& aName ) +{ + ::SolarMutexGuard aGuard; + if( HasSdrObject() ) + { + GetSdrObject()->SetName( aName ); + } + else + { + maShapeName = aName; + } +} + +// XShapeDescriptor + + +OUString SAL_CALL SvxShape::getShapeType() +{ + if( !maShapeType.getLength() ) + return UHashMap::getNameFromId( mpImpl->mnObjId ); + else + return maShapeType; +} + +// XComponent + + +void SAL_CALL SvxShape::dispose() +{ + ::SolarMutexGuard aGuard; + + if( mpImpl->mbDisposing ) + return; // caught a recursion + + mpImpl->mbDisposing = true; + + lang::EventObject aEvt; + aEvt.Source = *static_cast<OWeakAggObject*>(this); + mpImpl->maDisposeListeners.disposeAndClear(aEvt); + mpImpl->maPropertyNotifier.disposing(); + + if ( HasSdrObject() ) + { + SdrObject* pObject = GetSdrObject(); + + EndListening( pObject->getSdrModelFromSdrObject() ); + bool bFreeSdrObject = false; + + if ( pObject->IsInserted() && pObject->getSdrPageFromSdrObject() ) + { + OSL_ENSURE( HasSdrObjectOwnership(), "SvxShape::dispose: is the below code correct?" ); + // normally, we are allowed to free the SdrObject only if we have its ownership. + // Why isn't this checked here? + + SdrPage* pPage = pObject->getSdrPageFromSdrObject(); + // delete the SdrObject from the page + const size_t nCount = pPage->GetObjCount(); + for ( size_t nNum = 0; nNum < nCount; ++nNum ) + { + if ( pPage->GetObj( nNum ) == pObject ) + { + OSL_VERIFY( pPage->RemoveObject( nNum ) == pObject ); + bFreeSdrObject = true; + break; + } + } + } + + pObject->setUnoShape(nullptr); + + if ( bFreeSdrObject ) + { + // in case we have the ownership of the SdrObject, a Free + // would do nothing. So ensure the ownership is reset. + mpImpl->mbHasSdrObjectOwnership = false; + SdrObject::Free( pObject ); + } + } +} + + +void SAL_CALL SvxShape::addEventListener( const Reference< lang::XEventListener >& xListener ) +{ + mpImpl->maDisposeListeners.addInterface(xListener); +} + + +void SAL_CALL SvxShape::removeEventListener( const Reference< lang::XEventListener >& aListener ) +{ + mpImpl->maDisposeListeners.removeInterface(aListener); +} + +// XPropertySet + + +Reference< beans::XPropertySetInfo > SAL_CALL + SvxShape::getPropertySetInfo() +{ + if( mpImpl->mpMaster ) + { + return mpImpl->mpMaster->getPropertySetInfo(); + } + else + { + return _getPropertySetInfo(); + } +} + +Reference< beans::XPropertySetInfo > const & + SvxShape::_getPropertySetInfo() +{ + return mpPropSet->getPropertySetInfo(); +} + + +void SAL_CALL SvxShape::addPropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener ) +{ + ::osl::MutexGuard aGuard( maMutex ); + mpImpl->maPropertyNotifier.addPropertyChangeListener( _propertyName, _listener ); +} + + +void SAL_CALL SvxShape::removePropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener ) +{ + ::osl::MutexGuard aGuard( maMutex ); + mpImpl->maPropertyNotifier.removePropertyChangeListener( _propertyName, _listener ); +} + + +void SAL_CALL SvxShape::addVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) +{ + OSL_FAIL( "SvxShape::addVetoableChangeListener: don't have any vetoable properties, so why ...?" ); +} + + +void SAL_CALL SvxShape::removeVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) +{ + OSL_FAIL( "SvxShape::removeVetoableChangeListener: don't have any vetoable properties, so why ...?" ); +} + + +bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName ) +{ + if(HasSdrObject()) + { + SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{nWID, nWID}} ); + + if( SetFillAttribute( nWID, rName, aSet, &GetSdrObject()->getSdrModelFromSdrObject() ) ) + { + //GetSdrObject()->SetItemSetAndBroadcast(aSet); + GetSdrObject()->SetMergedItemSetAndBroadcast(aSet); + + return true; + } + } + + return false; +} + + +bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet, SdrModel const * pModel ) +{ + // check if an item with the given name and which id is inside the models + // pool or the stylesheet pool, if found it's put in the itemset + if( !SetFillAttribute( nWID, rName, rSet ) ) + { + // we did not find such item in one of the pools, so we check + // the property lists that are loaded for the model for items + // that support such. + OUString aStrName = SvxUnogetInternalNameForItem(nWID, rName); + + switch( nWID ) + { + case XATTR_FILLBITMAP: + { + XBitmapListRef pBitmapList = pModel->GetBitmapList(); + + if( !pBitmapList.is() ) + return false; + + long nPos = pBitmapList->GetIndex(aStrName); + if( nPos == -1 ) + return false; + + const XBitmapEntry* pEntry = pBitmapList->GetBitmap(nPos); + XFillBitmapItem aBmpItem(rName, pEntry->GetGraphicObject()); + rSet.Put(aBmpItem); + break; + } + case XATTR_FILLGRADIENT: + { + XGradientListRef pGradientList = pModel->GetGradientList(); + + if( !pGradientList.is() ) + return false; + + long nPos = pGradientList->GetIndex(aStrName); + if( nPos == -1 ) + return false; + + const XGradientEntry* pEntry = pGradientList->GetGradient(nPos); + XFillGradientItem aGrdItem(rName, pEntry->GetGradient()); + rSet.Put( aGrdItem ); + break; + } + case XATTR_FILLHATCH: + { + XHatchListRef pHatchList = pModel->GetHatchList(); + + if( !pHatchList.is() ) + return false; + + long nPos = pHatchList->GetIndex(aStrName); + if( nPos == -1 ) + return false; + + const XHatchEntry* pEntry = pHatchList->GetHatch( nPos ); + XFillHatchItem aHatchItem(rName, pEntry->GetHatch()); + rSet.Put( aHatchItem ); + break; + } + case XATTR_LINEEND: + case XATTR_LINESTART: + { + XLineEndListRef pLineEndList = pModel->GetLineEndList(); + + if( !pLineEndList.is() ) + return false; + + long nPos = pLineEndList->GetIndex(aStrName); + if( nPos == -1 ) + return false; + + const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos); + if( sal_uInt16(XATTR_LINEEND) == nWID ) + { + XLineEndItem aLEItem(rName, pEntry->GetLineEnd()); + rSet.Put( aLEItem ); + } + else + { + XLineStartItem aLSItem(rName, pEntry->GetLineEnd()); + rSet.Put( aLSItem ); + } + + break; + } + case XATTR_LINEDASH: + { + XDashListRef pDashList = pModel->GetDashList(); + + if( !pDashList.is() ) + return false; + + long nPos = pDashList->GetIndex(aStrName); + if( nPos == -1 ) + return false; + + const XDashEntry* pEntry = pDashList->GetDash(nPos); + XLineDashItem aDashItem(rName, pEntry->GetDash()); + rSet.Put( aDashItem ); + break; + } + default: + return false; + } + } + + return true; +} + + +bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet ) +{ + OUString aName = SvxUnogetInternalNameForItem(nWID, rName); + + if (aName.isEmpty()) + { + switch( nWID ) + { + case XATTR_LINEEND: + case XATTR_LINESTART: + { + const basegfx::B2DPolyPolygon aEmptyPoly; + if( nWID == sal_uInt16(XATTR_LINEEND) ) + rSet.Put( XLineEndItem( "", aEmptyPoly ) ); + else + rSet.Put( XLineStartItem( "", aEmptyPoly ) ); + + return true; + } + case XATTR_FILLFLOATTRANSPARENCE: + { + // #85953# Set a disabled XFillFloatTransparenceItem + rSet.Put(XFillFloatTransparenceItem()); + + return true; + } + } + + return false; + } + + for (const SfxPoolItem* p : rSet.GetPool()->GetItemSurrogates(nWID)) + { + const NameOrIndex* pItem = static_cast<const NameOrIndex*>(p); + if( pItem->GetName() == aName ) + { + rSet.Put( *pItem ); + return true; + } + } + + return false; +} + + +void SAL_CALL SvxShape::setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal ) +{ + if( mpImpl->mpMaster ) + { + mpImpl->mpMaster->setPropertyValue( rPropertyName, rVal ); + } + else + { + _setPropertyValue( rPropertyName, rVal ); + } +} + +void SvxShape::_setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal ) +{ + ::SolarMutexGuard aGuard; + + const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName); + + if (!HasSdrObject()) + { + // Since we have no actual sdr object right now, remember all + // properties in a list. These properties will be set when the sdr + // object is created. + + if (pMap && pMap->nWID) + { + // FIXME: We should throw a UnknownPropertyException here. + // But since this class is aggregated from classes that + // support additional properties that we don't know here we + // silently store *all* properties, even if they may be not + // supported after creation. + mpPropSet->setPropertyValue( pMap, rVal ); + } + + return; + } + + if (!pMap) + { + // reduce log noise by ignoring two properties that higher level code queries for on all objects + SAL_WARN_IF(rPropertyName != "FromWordArt" && rPropertyName != "GraphicColorMode", + "svx.uno", "Unknown Property: " << rPropertyName); + throw beans::UnknownPropertyException( rPropertyName, static_cast<cppu::OWeakObject*>(this)); + } + + if ((pMap->nFlags & beans::PropertyAttribute::READONLY) != 0) + throw beans::PropertyVetoException( + "Readonly property can't be set: " + rPropertyName, + uno::Reference<drawing::XShape>(this)); + + GetSdrObject()->getSdrModelFromSdrObject().SetChanged(); + + if (setPropertyValueImpl(rPropertyName, pMap, rVal)) + return; + + DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST, "Not persist item not handled!" ); + DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" ); + + bool bIsNotPersist = pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST && pMap->nWID != SDRATTR_TEXTDIRECTION; + + if( pMap->nWID == SDRATTR_ECKENRADIUS ) + { + sal_Int32 nCornerRadius = 0; + if( !(rVal >>= nCornerRadius) || (nCornerRadius < 0) || (nCornerRadius > 5000000)) + throw IllegalArgumentException(); + } + + SfxItemSet* pSet; + if( mbIsMultiPropertyCall && !bIsNotPersist ) + { + if( mpImpl->mpItemSet == nullptr ) + { + mpImpl->mpItemSet.reset(new SfxItemSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{pMap->nWID, pMap->nWID}})); + } + else + { + mpImpl->mpItemSet->MergeRange(pMap->nWID, pMap->nWID); + } + pSet = mpImpl->mpItemSet.get(); + } + else + { + pSet = new SfxItemSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{pMap->nWID, pMap->nWID}}); + } + + if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET ) + pSet->Put(GetSdrObject()->GetMergedItem(pMap->nWID)); + + if( !SvxUnoTextRangeBase::SetPropertyValueHelper( pMap, rVal, *pSet )) + { + if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET ) + { + if(bIsNotPersist) + { + // not-persistent attribute, get those extra + GetSdrObject()->TakeNotPersistAttr(*pSet); + } + } + + if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET ) + { + // get default from ItemPool + if(SfxItemPool::IsWhich(pMap->nWID)) + pSet->Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID)); + } + + if( pSet->GetItemState( pMap->nWID ) == SfxItemState::SET ) + { + SvxItemPropertySet_setPropertyValue( pMap, rVal, *pSet ); + } + } + + if(bIsNotPersist) + { + // set not-persistent attribute extra + GetSdrObject()->ApplyNotPersistAttr( *pSet ); + delete pSet; + } + else + { + // if we have a XMultiProperty call then the item set + // will be set in setPropertyValues later + if( !mbIsMultiPropertyCall ) + { + GetSdrObject()->SetMergedItemSetAndBroadcast( *pSet ); + + delete pSet; + } + } +} + + +uno::Any SAL_CALL SvxShape::getPropertyValue( const OUString& PropertyName ) +{ + if ( mpImpl->mpMaster ) + return mpImpl->mpMaster->getPropertyValue( PropertyName ); + else + return _getPropertyValue( PropertyName ); +} + + +uno::Any SvxShape::_getPropertyValue( const OUString& PropertyName ) +{ + ::SolarMutexGuard aGuard; + + const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName); + + uno::Any aAny; + if(HasSdrObject()) + { + if(pMap == nullptr ) + throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this)); + + if( !getPropertyValueImpl( PropertyName, pMap, aAny ) ) + { + DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || (pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST), "Not persist item not handled!" ); + DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" ); + + SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{pMap->nWID, pMap->nWID}}); + aSet.Put(GetSdrObject()->GetMergedItem(pMap->nWID)); + + if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pMap, aAny )) + return aAny; + + if(!aSet.Count()) + { + if(pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST) + { + // not-persistent attribute, get those extra + GetSdrObject()->TakeNotPersistAttr(aSet); + } + } + + if(!aSet.Count()) + { + // get default from ItemPool + if(SfxItemPool::IsWhich(pMap->nWID)) + aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID)); + } + + if(aSet.Count()) + aAny = GetAnyForItem( aSet, pMap ); + } + } + else + { + +// Fixme: we should return default values for OWN_ATTR ! + + if(pMap && pMap->nWID) +// FixMe: see setPropertyValue + aAny = mpPropSet->getPropertyValue( pMap ); + + } + return aAny; +} + + +// XMultiPropertySet +void SAL_CALL SvxShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) +{ + ::SolarMutexGuard aSolarGuard; + + const sal_Int32 nCount = aPropertyNames.getLength(); + const OUString* pNames = aPropertyNames.getConstArray(); + + const uno::Any* pValues = aValues.getConstArray(); + + // make sure mbIsMultiPropertyCall and mpImpl->mpItemSet are + // reset even when an exception is thrown + const ::comphelper::ScopeGuard aGuard( [this] () { return this->endSetPropertyValues(); } ); + + mbIsMultiPropertyCall = true; + + if( mpImpl->mpMaster ) + { + for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ ) + { + try + { + setPropertyValue( *pNames, *pValues ); + } + catch( beans::UnknownPropertyException& ) {} + catch( uno::Exception& ) {} + } + } + else + { + uno::Reference< beans::XPropertySet > xSet; + queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet; + + for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ ) + { + try + { + xSet->setPropertyValue( *pNames, *pValues ); + } + catch( beans::UnknownPropertyException& ) {} + catch( uno::Exception& ) {} + } + } + + if( mpImpl->mpItemSet && HasSdrObject() ) + GetSdrObject()->SetMergedItemSetAndBroadcast( *mpImpl->mpItemSet ); +} + + +void SvxShape::endSetPropertyValues() +{ + mbIsMultiPropertyCall = false; + mpImpl->mpItemSet.reset(); +} + + +css::uno::Sequence< css::uno::Any > SAL_CALL SvxShape::getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames ) +{ + const sal_Int32 nCount = aPropertyNames.getLength(); + const OUString* pNames = aPropertyNames.getConstArray(); + + uno::Sequence< uno::Any > aRet( nCount ); + uno::Any* pValue = aRet.getArray(); + + if( mpImpl->mpMaster ) + { + for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ ) + { + try + { + *pValue = getPropertyValue( *pNames ); + } + catch( uno::Exception& ) + { + OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" ); + } + } + } + else + { + uno::Reference< beans::XPropertySet > xSet; + queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet; + + for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ ) + { + try + { + *pValue = xSet->getPropertyValue( *pNames ); + } + catch( uno::Exception& ) + { + OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" ); + } + } + } + + return aRet; +} + +void SAL_CALL SvxShape::addPropertiesChangeListener( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) +{ +} + +void SAL_CALL SvxShape::removePropertiesChangeListener( const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) +{ +} + +void SAL_CALL SvxShape::firePropertiesChangeEvent( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >& ) +{ +} + + +uno::Any SvxShape::GetAnyForItem( SfxItemSet const & aSet, const SfxItemPropertySimpleEntry* pMap ) const +{ + DBG_TESTSOLARMUTEX(); + uno::Any aAny; + + switch(pMap->nWID) + { + case SDRATTR_CIRCSTARTANGLE: + { + const SfxPoolItem* pPoolItem=nullptr; + if(aSet.GetItemState(SDRATTR_CIRCSTARTANGLE,false,&pPoolItem)==SfxItemState::SET) + { + sal_Int32 nAngle = static_cast<const SdrAngleItem*>(pPoolItem)->GetValue(); + aAny <<= nAngle; + } + break; + } + + case SDRATTR_CIRCENDANGLE: + { + const SfxPoolItem* pPoolItem=nullptr; + if (aSet.GetItemState(SDRATTR_CIRCENDANGLE,false,&pPoolItem)==SfxItemState::SET) + { + sal_Int32 nAngle = static_cast<const SdrAngleItem*>(pPoolItem)->GetValue(); + aAny <<= nAngle; + } + break; + } + + case SDRATTR_CIRCKIND: + { + if( GetSdrObject()->GetObjInventor() == SdrInventor::Default) + { + drawing::CircleKind eKind; + switch(GetSdrObject()->GetObjIdentifier()) + { + case OBJ_CIRC: // circle, ellipse + eKind = drawing::CircleKind_FULL; + break; + case OBJ_CCUT: // segment of circle + eKind = drawing::CircleKind_CUT; + break; + case OBJ_CARC: // arc of circle + eKind = drawing::CircleKind_ARC; + break; + case OBJ_SECT: // sector + eKind = drawing::CircleKind_SECTION; + break; + } + aAny <<= eKind; + } + break; + } + default: + { + // get value from ItemSet + aAny = SvxItemPropertySet_getPropertyValue( pMap, aSet ); + + if( pMap->aType != aAny.getValueType() ) + { + // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here + if( ( pMap->aType == ::cppu::UnoType<sal_Int16>::get()) && aAny.getValueType() == ::cppu::UnoType<sal_Int32>::get() ) + { + sal_Int32 nValue = 0; + aAny >>= nValue; + aAny <<= static_cast<sal_Int16>(nValue); + } + else + { + OSL_FAIL("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" ); + } + } + + } + } + + return aAny; +} + + +// XPropertyState +beans::PropertyState SAL_CALL SvxShape::getPropertyState( const OUString& PropertyName ) +{ + if( mpImpl->mpMaster ) + { + return mpImpl->mpMaster->getPropertyState( PropertyName ); + } + else + { + return _getPropertyState( PropertyName ); + } +} + +beans::PropertyState SvxShape::_getPropertyState( const OUString& PropertyName ) +{ + ::SolarMutexGuard aGuard; + + const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName); + + if( !HasSdrObject() || pMap == nullptr ) + throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this)); + + beans::PropertyState eState; + if( !getPropertyStateImpl( pMap, eState ) ) + { + const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet(); + + switch( rSet.GetItemState( pMap->nWID, false ) ) + { + case SfxItemState::READONLY: + case SfxItemState::SET: + eState = beans::PropertyState_DIRECT_VALUE; + break; + case SfxItemState::DEFAULT: + eState = beans::PropertyState_DEFAULT_VALUE; + break; + default: + eState = beans::PropertyState_AMBIGUOUS_VALUE; + break; + } + + // if an item is set, this doesn't mean we want it :) + if( beans::PropertyState_DIRECT_VALUE == eState ) + { + switch( pMap->nWID ) + { + // the following items are disabled by changing the + // fill style or the line style. so there is no need + // to export items without names which should be empty + case XATTR_FILLBITMAP: + case XATTR_FILLGRADIENT: + case XATTR_FILLHATCH: + case XATTR_LINEDASH: + { + const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID); + if( ( pItem == nullptr ) || pItem->GetName().isEmpty() ) + eState = beans::PropertyState_DEFAULT_VALUE; + } + break; + + // #i36115# + // If e.g. the LineStart is on NONE and thus the string has length 0, it still + // may be a hard attribute covering the set LineStart of the parent (Style). + // #i37644# + // same is for fill float transparency + case XATTR_LINEEND: + case XATTR_LINESTART: + case XATTR_FILLFLOATTRANSPARENCE: + { + const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID); + if ( pItem == nullptr ) + eState = beans::PropertyState_DEFAULT_VALUE; + } + break; + } + } + } + return eState; +} + +bool SvxShape::setPropertyValueImpl( const OUString&, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) +{ + switch( pProperty->nWID ) + { + case OWN_ATTR_CAPTION_POINT: + { + awt::Point aPnt; + if( rValue >>= aPnt ) + { + Point aVclPoint( aPnt.X, aPnt.Y ); + + // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm + // Need to adapt aVclPoint from 100thmm to app-specific + ForceMetricToItemPoolMetric(aVclPoint); + + // #90763# position is relative to top left, make it absolute + basegfx::B2DPolyPolygon aNewPolyPolygon; + basegfx::B2DHomMatrix aNewHomogenMatrix; + GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon); + + aVclPoint.AdjustX(basegfx::fround(aNewHomogenMatrix.get(0, 2)) ); + aVclPoint.AdjustY(basegfx::fround(aNewHomogenMatrix.get(1, 2)) ); + + // #88491# position relative to anchor + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + { + aVclPoint += GetSdrObject()->GetAnchorPos(); + } + + static_cast<SdrCaptionObj*>(GetSdrObject())->SetTailPos(aVclPoint); + + return true; + } + break; + } + case OWN_ATTR_TRANSFORMATION: + { + drawing::HomogenMatrix3 aMatrix; + if(rValue >>= aMatrix) + { + basegfx::B2DPolyPolygon aNewPolyPolygon; + basegfx::B2DHomMatrix aNewHomogenMatrix; + + // tdf#117145 SdrModel data is app-specific + GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon); + + aNewHomogenMatrix.set(0, 0, aMatrix.Line1.Column1); + aNewHomogenMatrix.set(0, 1, aMatrix.Line1.Column2); + aNewHomogenMatrix.set(0, 2, aMatrix.Line1.Column3); + aNewHomogenMatrix.set(1, 0, aMatrix.Line2.Column1); + aNewHomogenMatrix.set(1, 1, aMatrix.Line2.Column2); + aNewHomogenMatrix.set(1, 2, aMatrix.Line2.Column3); + aNewHomogenMatrix.set(2, 0, aMatrix.Line3.Column1); + aNewHomogenMatrix.set(2, 1, aMatrix.Line3.Column2); + aNewHomogenMatrix.set(2, 2, aMatrix.Line3.Column3); + + // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm + // Need to adapt aNewHomogenMatrix from 100thmm to app-specific + ForceMetricToItemPoolMetric(aNewHomogenMatrix); + + GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon); + return true; + } + break; + } + + case OWN_ATTR_ZORDER: + { + sal_Int32 nNewOrdNum = 0; + if(rValue >>= nNewOrdNum) + { + SdrObjList* pObjList = GetSdrObject()->getParentSdrObjListFromSdrObject(); + if( pObjList ) + { + SdrObject* pCheck = + pObjList->SetObjectOrdNum( GetSdrObject()->GetOrdNum(), static_cast<size_t>(nNewOrdNum) ); + DBG_ASSERT( pCheck == GetSdrObject(), "GetOrdNum() failed!" ); + } + return true; + } + break; + } + case OWN_ATTR_FRAMERECT: + { + awt::Rectangle aUnoRect; + if(rValue >>= aUnoRect) + { + Point aTopLeft( aUnoRect.X, aUnoRect.Y ); + Size aObjSize( aUnoRect.Width, aUnoRect.Height ); + ForceMetricToItemPoolMetric(aTopLeft); + ForceMetricToItemPoolMetric(aObjSize); + tools::Rectangle aRect; + aRect.SetPos(aTopLeft); + aRect.SetSize(aObjSize); + GetSdrObject()->SetSnapRect(aRect); + return true; + } + break; + } + case OWN_ATTR_MIRRORED: + { + bool bMirror; + if(rValue >>= bMirror ) + { + SdrGrafObj* pObj = dynamic_cast< SdrGrafObj* >( GetSdrObject() ); + if( pObj ) + pObj->SetMirrored(bMirror); + return true; + } + break; + } + case OWN_ATTR_EDGE_START_OBJ: + case OWN_ATTR_EDGE_END_OBJ: + case OWN_ATTR_GLUEID_HEAD: + case OWN_ATTR_GLUEID_TAIL: + case OWN_ATTR_EDGE_START_POS: + case OWN_ATTR_EDGE_END_POS: + case OWN_ATTR_EDGE_POLYPOLYGONBEZIER: + { + SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >(GetSdrObject()); + if(pEdgeObj) + { + switch(pProperty->nWID) + { + case OWN_ATTR_EDGE_START_OBJ: + case OWN_ATTR_EDGE_END_OBJ: + { + Reference< drawing::XShape > xShape; + if( rValue >>= xShape ) + { + SdrObject* pNode = GetSdrObjectFromXShape( xShape ); + if( pNode ) + { + pEdgeObj->ConnectToNode( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ, pNode ); + pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ ); + return true; + } + } + break; + } + + case OWN_ATTR_EDGE_START_POS: + case OWN_ATTR_EDGE_END_POS: + { + awt::Point aUnoPoint; + if( rValue >>= aUnoPoint ) + { + Point aPoint( aUnoPoint.X, aUnoPoint.Y ); + + // Reintroduction of fix for issue i59051 (#i108851#) + // perform metric change before applying anchor position, + // because the anchor position is in pool metric. + ForceMetricToItemPoolMetric( aPoint ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aPoint += GetSdrObject()->GetAnchorPos(); + + pEdgeObj->SetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS, aPoint ); + return true; + } + break; + } + + case OWN_ATTR_GLUEID_HEAD: + case OWN_ATTR_GLUEID_TAIL: + { + sal_Int32 nId = 0; + if( rValue >>= nId ) + { + pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD, nId ); + return true; + } + break; + } + case OWN_ATTR_EDGE_POLYPOLYGONBEZIER: + { + basegfx::B2DPolyPolygon aNewPolyPolygon; + + // #123616# be a little bit more flexible regarding the data type used + if( auto s = o3tl::tryAccess<drawing::PointSequenceSequence>(rValue) ) + { + // get polygpon data from PointSequenceSequence + aNewPolyPolygon = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon( + *s); + } + else if( auto cs = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rValue) ) + { + // get polygpon data from PolyPolygonBezierCoords + aNewPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( + *cs); + } + + if(aNewPolyPolygon.count()) + { + // Reintroduction of fix for issue i59051 (#i108851#) + ForceMetricToItemPoolMetric( aNewPolyPolygon ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + { + Point aPoint( GetSdrObject()->GetAnchorPos() ); + aNewPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(aPoint.X(), aPoint.Y())); + } + pEdgeObj->SetEdgeTrackPath( aNewPolyPolygon ); + return true; + } + } + } + } + break; + } + case OWN_ATTR_MEASURE_START_POS: + case OWN_ATTR_MEASURE_END_POS: + { + SdrMeasureObj* pMeasureObj = dynamic_cast< SdrMeasureObj* >(GetSdrObject()); + awt::Point aUnoPoint; + if(pMeasureObj && ( rValue >>= aUnoPoint ) ) + { + Point aPoint( aUnoPoint.X, aUnoPoint.Y ); + + // Reintroduction of fix for issue #i59051# (#i108851#) + ForceMetricToItemPoolMetric( aPoint ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aPoint += GetSdrObject()->GetAnchorPos(); + + pMeasureObj->NbcSetPoint( aPoint, pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 ); + pMeasureObj->SetChanged(); + pMeasureObj->BroadcastObjectChange(); + return true; + } + break; + } + case OWN_ATTR_FILLBMP_MODE: + { + drawing::BitmapMode eMode; + if(!(rValue >>= eMode) ) + { + sal_Int32 nMode = 0; + if(!(rValue >>= nMode)) + break; + + eMode = static_cast<drawing::BitmapMode>(nMode); + } + GetSdrObject()->SetMergedItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) ); + GetSdrObject()->SetMergedItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) ); + return true; + } + + case SDRATTR_LAYERID: + { + sal_Int16 nLayerId = sal_Int16(); + if( rValue >>= nLayerId ) + { + SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(SdrLayerID(nLayerId)); + if( pLayer ) + { + GetSdrObject()->SetLayer(SdrLayerID(nLayerId)); + return true; + } + } + break; + } + + case SDRATTR_LAYERNAME: + { + OUString aLayerName; + if( rValue >>= aLayerName ) + { + const SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayer(aLayerName); + if( pLayer != nullptr ) + { + GetSdrObject()->SetLayer( pLayer->GetID() ); + return true; + } + } + break; + } + case SDRATTR_ROTATEANGLE: + { + sal_Int32 nAngle = 0; + if( rValue >>= nAngle ) + { + Point aRef1(GetSdrObject()->GetSnapRect().Center()); + nAngle -= GetSdrObject()->GetRotateAngle(); + if (nAngle!=0) + { + double nSin = sin(nAngle * F_PI18000); + double nCos = cos(nAngle * F_PI18000); + GetSdrObject()->Rotate(aRef1,nAngle,nSin,nCos); + } + return true; + } + + break; + } + + case SDRATTR_SHEARANGLE: + { + sal_Int32 nShear = 0; + if( rValue >>= nShear ) + { + nShear -= GetSdrObject()->GetShearAngle(); + if(nShear != 0 ) + { + Point aRef1(GetSdrObject()->GetSnapRect().Center()); + double nTan = tan(nShear * F_PI18000); + GetSdrObject()->Shear(aRef1,nShear,nTan,false); + return true; + } + } + + break; + } + + case OWN_ATTR_INTEROPGRABBAG: + { + GetSdrObject()->SetGrabBagItem(rValue); + return true; + } + + case SDRATTR_OBJMOVEPROTECT: + { + bool bMoveProtect; + if( rValue >>= bMoveProtect ) + { + GetSdrObject()->SetMoveProtect(bMoveProtect); + return true; + } + break; + } + case SDRATTR_OBJECTNAME: + { + OUString aName; + if( rValue >>= aName ) + { + GetSdrObject()->SetName( aName ); + return true; + } + break; + } + + case OWN_ATTR_TEXTFITTOSIZESCALE: + { + sal_Int16 nMaxScale = 0; + if (rValue >>= nMaxScale) + { + SdrTextFitToSizeTypeItem aItem(GetSdrObject()->GetMergedItem(SDRATTR_TEXT_FITTOSIZE)); + aItem.SetMaxScale(nMaxScale); + GetSdrObject()->SetMergedItem(aItem); + return true; + } + break; + } + + // #i68101# + case OWN_ATTR_MISC_OBJ_TITLE: + { + OUString aTitle; + if( rValue >>= aTitle ) + { + GetSdrObject()->SetTitle( aTitle ); + return true; + } + break; + } + case OWN_ATTR_MISC_OBJ_DESCRIPTION: + { + OUString aDescription; + if( rValue >>= aDescription ) + { + GetSdrObject()->SetDescription( aDescription ); + return true; + } + break; + } + + case SDRATTR_OBJPRINTABLE: + { + bool bPrintable; + if( rValue >>= bPrintable ) + { + GetSdrObject()->SetPrintable(bPrintable); + return true; + } + break; + } + case SDRATTR_OBJVISIBLE: + { + bool bVisible; + if( rValue >>= bVisible ) + { + GetSdrObject()->SetVisible(bVisible); + return true; + } + break; + } + case SDRATTR_OBJSIZEPROTECT: + { + bool bResizeProtect; + if( rValue >>= bResizeProtect ) + { + GetSdrObject()->SetResizeProtect(bResizeProtect); + return true; + } + break; + } + case OWN_ATTR_PAGE_NUMBER: + { + sal_Int32 nPageNum = 0; + if( (rValue >>= nPageNum) && ( nPageNum >= 0 ) && ( nPageNum <= 0xffff ) ) + { + SdrPageObj* pPageObj = dynamic_cast< SdrPageObj* >(GetSdrObject()); + if( pPageObj ) + { + SdrModel& rModel(pPageObj->getSdrModelFromSdrObject()); + SdrPage* pNewPage = nullptr; + const sal_uInt16 nDestinationPageNum(static_cast<sal_uInt16>((nPageNum << 1) - 1)); + + if(nDestinationPageNum < rModel.GetPageCount()) + { + pNewPage = rModel.GetPage(nDestinationPageNum); + } + + pPageObj->SetReferencedPage(pNewPage); + } + + return true; + } + break; + } + case XATTR_FILLBITMAP: + case XATTR_FILLGRADIENT: + case XATTR_FILLHATCH: + case XATTR_FILLFLOATTRANSPARENCE: + case XATTR_LINEEND: + case XATTR_LINESTART: + case XATTR_LINEDASH: + { + if( pProperty->nMemberId == MID_NAME ) + { + OUString aApiName; + if( rValue >>= aApiName ) + { + if( SetFillAttribute( pProperty->nWID, aApiName ) ) + return true; + } + break; + } + else + { + return false; + } + } + default: + { + return false; + } + } + + OUString sExceptionMessage ("IllegalArgumentException in SvxShape::setPropertyValueImpl." + " Property Type: " + pProperty->aType.getTypeName() + " Property nWID: " + OUString::number(pProperty->nWID) + + " Value Type: " + (rValue.hasValue() ? rValue.getValueTypeName() : "void (no value)")); + + throw lang::IllegalArgumentException(sExceptionMessage, nullptr, 1); +} + + +bool SvxShape::getPropertyValueImpl( const OUString&, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue ) +{ + switch( pProperty->nWID ) + { + case OWN_ATTR_CAPTION_POINT: + { + Point aVclPoint = static_cast<SdrCaptionObj*>(GetSdrObject())->GetTailPos(); + + // #88491# make pos relative to anchor + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + { + aVclPoint -= GetSdrObject()->GetAnchorPos(); + } + + // #90763# pos is absolute, make it relative to top left + basegfx::B2DPolyPolygon aNewPolyPolygon; + basegfx::B2DHomMatrix aNewHomogenMatrix; + GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon); + + aVclPoint.AdjustX( -(basegfx::fround(aNewHomogenMatrix.get(0, 2))) ); + aVclPoint.AdjustY( -(basegfx::fround(aNewHomogenMatrix.get(1, 2))) ); + + // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm + // Need to adapt aVclPoint from app-specific to 100thmm + ForceMetricTo100th_mm(aVclPoint); + + awt::Point aPnt( aVclPoint.X(), aVclPoint.Y() ); + rValue <<= aPnt; + break; + } + + case OWN_ATTR_TRANSFORMATION: + { + basegfx::B2DPolyPolygon aNewPolyPolygon; + basegfx::B2DHomMatrix aNewHomogenMatrix; + GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon); + drawing::HomogenMatrix3 aMatrix; + + // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm + // Need to adapt aNewHomogenMatrix from app-specific to 100thmm + ForceMetricTo100th_mm(aNewHomogenMatrix); + + aMatrix.Line1.Column1 = aNewHomogenMatrix.get(0, 0); + aMatrix.Line1.Column2 = aNewHomogenMatrix.get(0, 1); + aMatrix.Line1.Column3 = aNewHomogenMatrix.get(0, 2); + aMatrix.Line2.Column1 = aNewHomogenMatrix.get(1, 0); + aMatrix.Line2.Column2 = aNewHomogenMatrix.get(1, 1); + aMatrix.Line2.Column3 = aNewHomogenMatrix.get(1, 2); + aMatrix.Line3.Column1 = aNewHomogenMatrix.get(2, 0); + aMatrix.Line3.Column2 = aNewHomogenMatrix.get(2, 1); + aMatrix.Line3.Column3 = aNewHomogenMatrix.get(2, 2); + + rValue <<= aMatrix; + + break; + } + + case OWN_ATTR_ZORDER: + { + rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetOrdNum()); + break; + } + + case OWN_ATTR_BITMAP: + { + rValue = GetBitmap(); + if(!rValue.hasValue()) + throw uno::RuntimeException(); + + break; + } + + case OWN_ATTR_ISFONTWORK: + { + rValue <<= dynamic_cast<const SdrTextObj*>(GetSdrObject()) != nullptr && static_cast<SdrTextObj*>(GetSdrObject())->IsFontwork(); + break; + } + + case OWN_ATTR_FRAMERECT: + { + tools::Rectangle aRect( GetSdrObject()->GetSnapRect() ); + Point aTopLeft( aRect.TopLeft() ); + Size aObjSize( aRect.GetWidth(), aRect.GetHeight() ); + ForceMetricTo100th_mm(aTopLeft); + ForceMetricTo100th_mm(aObjSize); + css::awt::Rectangle aUnoRect( + aTopLeft.X(), aTopLeft.Y(), + aObjSize.getWidth(), aObjSize.getHeight() ); + rValue <<= aUnoRect; + break; + } + + case OWN_ATTR_BOUNDRECT: + { + tools::Rectangle aRect( GetSdrObject()->GetCurrentBoundRect() ); + Point aTopLeft( aRect.TopLeft() ); + Size aObjSize( aRect.GetWidth(), aRect.GetHeight() ); + ForceMetricTo100th_mm(aTopLeft); + ForceMetricTo100th_mm(aObjSize); + css::awt::Rectangle aUnoRect( + aTopLeft.X(), aTopLeft.Y(), + aObjSize.getWidth(), aObjSize.getHeight() ); + rValue <<= aUnoRect; + break; + } + + case OWN_ATTR_LDNAME: + { + OUString aName( GetSdrObject()->GetName() ); + rValue <<= aName; + break; + } + + case OWN_ATTR_LDBITMAP: + { + OUString sId; + if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_OLE2 ) + { + sId = RID_UNODRAW_OLE2; + } + else if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_GRAF ) + { + sId = RID_UNODRAW_GRAPHICS; + } + else + { + sId = RID_UNODRAW_OBJECTS; + } + + BitmapEx aBmp(sId); + Reference<awt::XBitmap> xBmp(VCLUnoHelper::CreateBitmap(aBmp)); + + rValue <<= xBmp; + break; + } + + case OWN_ATTR_MIRRORED: + { + bool bMirror = false; + if( HasSdrObject() && dynamic_cast<const SdrGrafObj*>(GetSdrObject()) != nullptr ) + bMirror = static_cast<SdrGrafObj*>(GetSdrObject())->IsMirrored(); + + rValue <<= bMirror; + break; + } + + case OWN_ATTR_EDGE_START_OBJ: + case OWN_ATTR_EDGE_START_POS: + case OWN_ATTR_EDGE_END_POS: + case OWN_ATTR_EDGE_END_OBJ: + case OWN_ATTR_GLUEID_HEAD: + case OWN_ATTR_GLUEID_TAIL: + case OWN_ATTR_EDGE_POLYPOLYGONBEZIER: + { + SdrEdgeObj* pEdgeObj = dynamic_cast<SdrEdgeObj*>(GetSdrObject()); + if(pEdgeObj) + { + switch(pProperty->nWID) + { + case OWN_ATTR_EDGE_START_OBJ: + case OWN_ATTR_EDGE_END_OBJ: + { + SdrObject* pNode = pEdgeObj->GetConnectedNode(pProperty->nWID == OWN_ATTR_EDGE_START_OBJ); + if(pNode) + { + Reference< drawing::XShape > xShape( GetXShapeForSdrObject( pNode ) ); + if(xShape.is()) + rValue <<= xShape; + + } + break; + } + + case OWN_ATTR_EDGE_START_POS: + case OWN_ATTR_EDGE_END_POS: + { + Point aPoint( pEdgeObj->GetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS ) ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aPoint -= GetSdrObject()->GetAnchorPos(); + + ForceMetricTo100th_mm( aPoint ); + awt::Point aUnoPoint( aPoint.X(), aPoint.Y() ); + + rValue <<= aUnoPoint; + break; + } + case OWN_ATTR_GLUEID_HEAD: + case OWN_ATTR_GLUEID_TAIL: + { + rValue <<= pEdgeObj->getGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD ); + break; + } + case OWN_ATTR_EDGE_POLYPOLYGONBEZIER: + { + basegfx::B2DPolyPolygon aPolyPoly( pEdgeObj->GetEdgeTrackPath() ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + { + Point aPoint( GetSdrObject()->GetAnchorPos() ); + aPolyPoly.transform(basegfx::utils::createTranslateB2DHomMatrix(-aPoint.X(), -aPoint.Y())); + } + // Reintroduction of fix for issue #i59051# (#i108851#) + ForceMetricTo100th_mm( aPolyPoly ); + drawing::PolyPolygonBezierCoords aRetval; + basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( aPolyPoly, aRetval); + rValue <<= aRetval; + break; + } + } + } + break; + } + + case OWN_ATTR_MEASURE_START_POS: + case OWN_ATTR_MEASURE_END_POS: + { + SdrMeasureObj* pMeasureObj = dynamic_cast<SdrMeasureObj*>(GetSdrObject()); + if(pMeasureObj) + { + Point aPoint( pMeasureObj->GetPoint( pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 ) ); + if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() ) + aPoint -= GetSdrObject()->GetAnchorPos(); + + // Reintroduction of fix for issue #i59051# (#i108851#) + ForceMetricTo100th_mm( aPoint ); + awt::Point aUnoPoint( aPoint.X(), aPoint.Y() ); + + rValue <<= aUnoPoint; + break; + } + break; + } + + case OWN_ATTR_FILLBMP_MODE: + { + const SfxItemSet& rObjItemSet = GetSdrObject()->GetMergedItemSet(); + + if (rObjItemSet.Get(XATTR_FILLBMP_TILE).GetValue()) + { + rValue <<= drawing::BitmapMode_REPEAT; + } + else if (rObjItemSet.Get(XATTR_FILLBMP_STRETCH).GetValue()) + { + rValue <<= drawing::BitmapMode_STRETCH; + } + else + { + rValue <<= drawing::BitmapMode_NO_REPEAT; + } + break; + } + case SDRATTR_LAYERID: + rValue <<= sal_uInt16(sal_uInt8(GetSdrObject()->GetLayer())); + break; + + case SDRATTR_LAYERNAME: + { + SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(GetSdrObject()->GetLayer()); + if( pLayer ) + { + rValue <<= pLayer->GetName(); + } + break; + } + + case SDRATTR_ROTATEANGLE: + rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetRotateAngle()); + break; + + case SDRATTR_SHEARANGLE: + rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetShearAngle()); + break; + + case OWN_ATTR_INTEROPGRABBAG: + { + GetSdrObject()->GetGrabBagItem(rValue); + break; + } + + case SDRATTR_OBJMOVEPROTECT: + rValue <<= GetSdrObject()->IsMoveProtect(); + break; + + case SDRATTR_OBJECTNAME: + { + OUString aName( GetSdrObject()->GetName() ); + rValue <<= aName; + break; + } + + // #i68101# + case OWN_ATTR_MISC_OBJ_TITLE: + { + OUString aTitle( GetSdrObject()->GetTitle() ); + rValue <<= aTitle; + break; + } + + case OWN_ATTR_MISC_OBJ_DESCRIPTION: + { + OUString aDescription( GetSdrObject()->GetDescription() ); + rValue <<= aDescription; + break; + } + + case SDRATTR_OBJPRINTABLE: + rValue <<= GetSdrObject()->IsPrintable(); + break; + + case SDRATTR_OBJVISIBLE: + rValue <<= GetSdrObject()->IsVisible(); + break; + + case SDRATTR_OBJSIZEPROTECT: + rValue <<= GetSdrObject()->IsResizeProtect(); + break; + + case OWN_ATTR_PAGE_NUMBER: + { + SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(GetSdrObject()); + if(pPageObj) + { + SdrPage* pPage = pPageObj->GetReferencedPage(); + sal_Int32 nPageNumber = pPage ? pPage->GetPageNum() : 0; + nPageNumber++; + nPageNumber >>= 1; + rValue <<= nPageNumber; + } + break; + } + + case OWN_ATTR_UINAME_SINGULAR: + { + rValue <<= GetSdrObject()->TakeObjNameSingul(); + break; + } + + case OWN_ATTR_TEXTFITTOSIZESCALE: + { + rValue <<= GetTextFitToSizeScale(GetSdrObject()); + break; + } + + case OWN_ATTR_UINAME_PLURAL: + { + rValue <<= GetSdrObject()->TakeObjNamePlural(); + break; + } + case OWN_ATTR_METAFILE: + { + SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(GetSdrObject()); + if( pObj ) + { + const Graphic* pGraphic = pObj->GetGraphic(); + if( pGraphic ) + { + bool bIsWMF = false; + if ( pGraphic->IsGfxLink() ) + { + GfxLink aLnk = pGraphic->GetGfxLink(); + if ( aLnk.GetType() == GfxLinkType::NativeWmf ) + { + bIsWMF = true; + uno::Sequence<sal_Int8> aSeq(reinterpret_cast<sal_Int8 const *>(aLnk.GetData()), static_cast<sal_Int32>(aLnk.GetDataSize())); + rValue <<= aSeq; + } + } + if ( !bIsWMF ) + { + // #119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically + GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile()); + SvMemoryStream aDestStrm( 65535, 65535 ); + ConvertGDIMetaFileToWMF( aMtf, aDestStrm, nullptr, false ); + const uno::Sequence<sal_Int8> aSeq( + static_cast< const sal_Int8* >(aDestStrm.GetData()), + aDestStrm.GetEndOfData()); + rValue <<= aSeq; + } + } + } + else + { + rValue = GetBitmap( true ); + } + break; + } + + + default: + return false; + } + return true; +} + + +bool SvxShape::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, css::beans::PropertyState& rState ) +{ + if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE ) + { + const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet(); + + if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SfxItemState::SET || + rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SfxItemState::SET ) + { + rState = beans::PropertyState_DIRECT_VALUE; + } + else + { + rState = beans::PropertyState_AMBIGUOUS_VALUE; + } + } + else if((( pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) || + ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST )) && ( pProperty->nWID != SDRATTR_TEXTDIRECTION ) ) + { + rState = beans::PropertyState_DIRECT_VALUE; + } + else + { + return false; + } + + return true; +} + + +bool SvxShape::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty ) +{ + if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE ) + { + GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_STRETCH ); + GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_TILE ); + return true; + } + else if((pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) || + ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST )) + { + return true; + } + else + { + return false; + } +} + + +uno::Sequence< beans::PropertyState > SAL_CALL SvxShape::getPropertyStates( const uno::Sequence< OUString >& aPropertyName ) +{ + const sal_Int32 nCount = aPropertyName.getLength(); + uno::Sequence< beans::PropertyState > aRet( nCount ); + + std::transform(aPropertyName.begin(), aPropertyName.end(), aRet.begin(), + [this](const OUString& rName) -> beans::PropertyState { return getPropertyState(rName); }); + + return aRet; +} + + +void SAL_CALL SvxShape::setPropertyToDefault( const OUString& PropertyName ) +{ + if( mpImpl->mpMaster ) + { + mpImpl->mpMaster->setPropertyToDefault( PropertyName ); + } + else + { + _setPropertyToDefault( PropertyName ); + } +} + +void SvxShape::_setPropertyToDefault( const OUString& PropertyName ) +{ + ::SolarMutexGuard aGuard; + + const SfxItemPropertySimpleEntry* pProperty = mpPropSet->getPropertyMapEntry(PropertyName); + + if( !HasSdrObject() || pProperty == nullptr ) + throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this)); + + if( !setPropertyToDefaultImpl( pProperty ) ) + { + GetSdrObject()->ClearMergedItem( pProperty->nWID ); + } + + GetSdrObject()->getSdrModelFromSdrObject().SetChanged(); +} + + +uno::Any SAL_CALL SvxShape::getPropertyDefault( const OUString& aPropertyName ) +{ + if( mpImpl->mpMaster ) + { + return mpImpl->mpMaster->getPropertyDefault( aPropertyName ); + } + else + { + return _getPropertyDefault( aPropertyName ); + } +} + +uno::Any SvxShape::_getPropertyDefault( const OUString& aPropertyName ) +{ + ::SolarMutexGuard aGuard; + + const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName); + + if( !HasSdrObject() || pMap == nullptr ) + throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this)); + + if(( pMap->nWID >= OWN_ATTR_VALUE_START && pMap->nWID <= OWN_ATTR_VALUE_END ) || + ( pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST )) + { + return getPropertyValue( aPropertyName ); + } + + // get default from ItemPool + if(!SfxItemPool::IsWhich(pMap->nWID)) + throw beans::UnknownPropertyException( "No WhichID " + OUString::number(pMap->nWID) + " for " + aPropertyName, static_cast<cppu::OWeakObject*>(this)); + + SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{pMap->nWID, pMap->nWID}}); + aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID)); + + return GetAnyForItem( aSet, pMap ); +} + +// XMultiPropertyStates +void SvxShape::setAllPropertiesToDefault() +{ + ::SolarMutexGuard aGuard; + + if( !HasSdrObject() ) + throw lang::DisposedException(); + GetSdrObject()->ClearMergedItem(); // nWhich == 0 => all + + if(dynamic_cast<const SdrGrafObj*>(GetSdrObject()) != nullptr) + { + // defaults for graphic objects have changed: + GetSdrObject()->SetMergedItem( XFillStyleItem( drawing::FillStyle_NONE ) ); + GetSdrObject()->SetMergedItem( XLineStyleItem( drawing::LineStyle_NONE ) ); + } + + // #i68523# special handling for Svx3DCharacterModeItem, this is not saved + // but needs to be sal_True in svx, pool default (false) in sch. Since sch + // does not load lathe or extrude objects, it is possible to set the items + // here. + // For other solution possibilities, see task description. + if( dynamic_cast<const E3dLatheObj* >(GetSdrObject()) != nullptr|| dynamic_cast<const E3dExtrudeObj* >(GetSdrObject()) != nullptr) + { + GetSdrObject()->SetMergedItem(Svx3DCharacterModeItem(true)); + } + + GetSdrObject()->getSdrModelFromSdrObject().SetChanged(); +} + +void SvxShape::setPropertiesToDefault( + const uno::Sequence<OUString>& aPropertyNames ) +{ + for ( const auto& rPropertyName : aPropertyNames ) + setPropertyToDefault( rPropertyName ); +} + +uno::Sequence<uno::Any> SvxShape::getPropertyDefaults( + const uno::Sequence<OUString>& aPropertyNames ) +{ + ::std::vector<uno::Any> ret; + ret.reserve(aPropertyNames.getLength()); + std::transform(aPropertyNames.begin(), aPropertyNames.end(), std::back_inserter(ret), + [this](const OUString& rName) -> uno::Any { return getPropertyDefault(rName); }); + return uno::Sequence<uno::Any>( ret.data(), ret.size() ); +} + + +// XServiceInfo + +OUString SAL_CALL SvxShape::getImplementationName() +{ + return "SvxShape"; +} + +const char sUNO_service_style_ParagraphProperties[] = "com.sun.star.style.ParagraphProperties"; +const char sUNO_service_style_ParagraphPropertiesComplex[] = "com.sun.star.style.ParagraphPropertiesComplex"; +const char sUNO_service_style_ParagraphPropertiesAsian[] = "com.sun.star.style.ParagraphPropertiesAsian"; +const char sUNO_service_style_CharacterProperties[] = "com.sun.star.style.CharacterProperties"; +const char sUNO_service_style_CharacterPropertiesComplex[] = "com.sun.star.style.CharacterPropertiesComplex"; +const char sUNO_service_style_CharacterPropertiesAsian[] = "com.sun.star.style.CharacterPropertiesAsian"; + +const char sUNO_service_drawing_FillProperties[] = "com.sun.star.drawing.FillProperties"; +const char sUNO_service_drawing_TextProperties[] = "com.sun.star.drawing.TextProperties"; +const char sUNO_service_drawing_LineProperties[] = "com.sun.star.drawing.LineProperties"; +const char sUNO_service_drawing_ConnectorProperties[] = "com.sun.star.drawing.ConnectorProperties"; +const char sUNO_service_drawing_MeasureProperties[] = "com.sun.star.drawing.MeasureProperties"; +const char sUNO_service_drawing_ShadowProperties[] = "com.sun.star.drawing.ShadowProperties"; + +const char sUNO_service_drawing_RotationDescriptor[] = "com.sun.star.drawing.RotationDescriptor"; + +const char sUNO_service_drawing_Text[] = "com.sun.star.drawing.Text"; +const char sUNO_service_drawing_GroupShape[] = "com.sun.star.drawing.GroupShape"; + +const char sUNO_service_drawing_CustomShapeProperties[] = "com.sun.star.drawing.CustomShapeProperties"; +const char sUNO_service_drawing_CustomShape[] = "com.sun.star.drawing.CustomShape"; + +const char sUNO_service_drawing_PolyPolygonDescriptor[] = "com.sun.star.drawing.PolyPolygonDescriptor"; +const char sUNO_service_drawing_PolyPolygonBezierDescriptor[]= "com.sun.star.drawing.PolyPolygonBezierDescriptor"; + +const char sUNO_service_drawing_LineShape[] = "com.sun.star.drawing.LineShape"; +const char sUNO_service_drawing_Shape[] = "com.sun.star.drawing.Shape"; +const char sUNO_service_drawing_RectangleShape[] = "com.sun.star.drawing.RectangleShape"; +const char sUNO_service_drawing_EllipseShape[] = "com.sun.star.drawing.EllipseShape"; +const char sUNO_service_drawing_PolyPolygonShape[] = "com.sun.star.drawing.PolyPolygonShape"; +const char sUNO_service_drawing_PolyLineShape[] = "com.sun.star.drawing.PolyLineShape"; +const char sUNO_service_drawing_OpenBezierShape[] = "com.sun.star.drawing.OpenBezierShape"; +const char sUNO_service_drawing_ClosedBezierShape[] = "com.sun.star.drawing.ClosedBezierShape"; +const char sUNO_service_drawing_TextShape[] = "com.sun.star.drawing.TextShape"; +const char sUNO_service_drawing_GraphicObjectShape[] = "com.sun.star.drawing.GraphicObjectShape"; +const char sUNO_service_drawing_OLE2Shape[] = "com.sun.star.drawing.OLE2Shape"; +const char sUNO_service_drawing_PageShape[] = "com.sun.star.drawing.PageShape"; +const char sUNO_service_drawing_CaptionShape[] = "com.sun.star.drawing.CaptionShape"; +const char sUNO_service_drawing_MeasureShape[] = "com.sun.star.drawing.MeasureShape"; +const char sUNO_service_drawing_FrameShape[] = "com.sun.star.drawing.FrameShape"; +const char sUNO_service_drawing_ControlShape[] = "com.sun.star.drawing.ControlShape"; +const char sUNO_service_drawing_ConnectorShape[] = "com.sun.star.drawing.ConnectorShape"; +const char sUNO_service_drawing_MediaShape[] = "com.sun.star.drawing.MediaShape"; + + +uno::Sequence< OUString > SAL_CALL SvxShape::getSupportedServiceNames() +{ + if( mpImpl->mpMaster ) + { + return mpImpl->mpMaster->getSupportedServiceNames(); + } + else + { + return _getSupportedServiceNames(); + } +} + +uno::Sequence< OUString > SvxShape::_getSupportedServiceNames() +{ + ::SolarMutexGuard aGuard; + + if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::Default) + { + const sal_uInt16 nIdent = GetSdrObject()->GetObjIdentifier(); + + switch(nIdent) + { + case OBJ_GRUP: + { + static const uno::Sequence<OUString> aSvxShape_GroupServices + = { sUNO_service_drawing_GroupShape, + sUNO_service_drawing_Shape }; + return aSvxShape_GroupServices; + } + case OBJ_CUSTOMSHAPE: + { + static const uno::Sequence<OUString> aSvxShape_CustomShapeServices + = { sUNO_service_drawing_CustomShape, + sUNO_service_drawing_Shape, + sUNO_service_drawing_CustomShapeProperties, + sUNO_service_drawing_FillProperties, + sUNO_service_drawing_LineProperties, + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_CustomShapeServices; + } + case OBJ_LINE: + { + static const uno::Sequence<OUString> aSvxShape_LineServices + = { sUNO_service_drawing_LineShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_PolyPolygonDescriptor, + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_LineServices; + } + + case OBJ_RECT: + { + static const uno::Sequence<OUString> aSvxShape_RectServices + = { sUNO_service_drawing_RectangleShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_FillProperties, + sUNO_service_drawing_LineProperties, + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_RectServices; + } + + case OBJ_CIRC: + case OBJ_SECT: + case OBJ_CARC: + case OBJ_CCUT: + { + static const uno::Sequence<OUString> aSvxShape_CircServices + = { sUNO_service_drawing_EllipseShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_FillProperties, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_CircServices; + } + + case OBJ_PATHPLIN: + case OBJ_PLIN: + { + static const uno::Sequence<OUString> aSvxShape_PathServices + = { sUNO_service_drawing_PolyLineShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_PolyPolygonDescriptor, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_PathServices; + } + + case OBJ_PATHPOLY: + case OBJ_POLY: + { + static const uno::Sequence<OUString> aSvxShape_PolyServices + = { sUNO_service_drawing_PolyPolygonShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + sUNO_service_drawing_FillProperties, + + sUNO_service_drawing_PolyPolygonDescriptor, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_PolyServices; + } + + case OBJ_FREELINE: + case OBJ_PATHLINE: + { + static const uno::Sequence<OUString> aSvxShape_FreeLineServices + = { sUNO_service_drawing_OpenBezierShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + sUNO_service_drawing_FillProperties, + + sUNO_service_drawing_PolyPolygonBezierDescriptor, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_FreeLineServices; + } + + case OBJ_FREEFILL: + case OBJ_PATHFILL: + { + static const uno::Sequence<OUString> aSvxShape_FreeFillServices + = { sUNO_service_drawing_ClosedBezierShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + sUNO_service_drawing_FillProperties, + + sUNO_service_drawing_PolyPolygonBezierDescriptor, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_FreeFillServices; + } + + case OBJ_OUTLINETEXT: + case OBJ_TITLETEXT: + case OBJ_TEXT: + { + static const uno::Sequence<OUString> aSvxShape_TextServices + = { sUNO_service_drawing_TextShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_FillProperties, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_TextServices; + } + + case OBJ_GRAF: + { + static const uno::Sequence<OUString> aSvxShape_GrafServices + = { sUNO_service_drawing_GraphicObjectShape, + + sUNO_service_drawing_Shape, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor}; + return aSvxShape_GrafServices; + } + + case OBJ_OLE2: + { + static const uno::Sequence<OUString> aSvxShape_Ole2Services + = { sUNO_service_drawing_OLE2Shape, + sUNO_service_drawing_Shape, + + // #i118485# Added Text, Shadow and Rotation + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_Ole2Services; + } + + case OBJ_CAPTION: + { + static const uno::Sequence<OUString> aSvxShape_CaptionServices + = { sUNO_service_drawing_CaptionShape, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_FillProperties, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_CaptionServices; + } + + case OBJ_PAGE: + { + static const uno::Sequence<OUString> aSvxShape_PageServices + = { sUNO_service_drawing_PageShape, + sUNO_service_drawing_Shape }; + return aSvxShape_PageServices; + } + + case OBJ_MEASURE: + { + static const uno::Sequence<OUString> aSvxShape_MeasureServices + = { sUNO_service_drawing_MeasureShape, + + sUNO_service_drawing_MeasureProperties, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_PolyPolygonDescriptor, + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_MeasureServices; + } + + case OBJ_FRAME: + { + static const uno::Sequence<OUString> aSvxShape_FrameServices + = { sUNO_service_drawing_FrameShape, + sUNO_service_drawing_Shape }; + return aSvxShape_FrameServices; + } + + case OBJ_UNO: + { + static const uno::Sequence<OUString> aSvxShape_UnoServices + = { sUNO_service_drawing_ControlShape, + sUNO_service_drawing_Shape }; + return aSvxShape_UnoServices; + } + + case OBJ_EDGE: + { + static const uno::Sequence<OUString> aSvxShape_EdgeServices + = { sUNO_service_drawing_ConnectorShape, + sUNO_service_drawing_ConnectorProperties, + + sUNO_service_drawing_Shape, + sUNO_service_drawing_LineProperties, + + sUNO_service_drawing_Text, + sUNO_service_drawing_TextProperties, + sUNO_service_style_ParagraphProperties, + sUNO_service_style_ParagraphPropertiesComplex, + sUNO_service_style_ParagraphPropertiesAsian, + sUNO_service_style_CharacterProperties, + sUNO_service_style_CharacterPropertiesComplex, + sUNO_service_style_CharacterPropertiesAsian, + + sUNO_service_drawing_PolyPolygonDescriptor, + sUNO_service_drawing_ShadowProperties, + sUNO_service_drawing_RotationDescriptor }; + return aSvxShape_EdgeServices; + } + case OBJ_MEDIA: + { + static const uno::Sequence<OUString> aSvxShape_MediaServices + = { sUNO_service_drawing_MediaShape, + sUNO_service_drawing_Shape }; + return aSvxShape_MediaServices; + } + } + } + else if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::FmForm) + { +#if OSL_DEBUG_LEVEL > 0 + const sal_uInt16 nIdent = GetSdrObject()->GetObjIdentifier(); + OSL_ENSURE( nIdent == OBJ_UNO, "SvxShape::_getSupportedServiceNames: SdrInventor::FmForm, but no UNO object?" ); +#endif + static const uno::Sequence<OUString> aSvxShape_UnoServices + = { sUNO_service_drawing_ControlShape, + sUNO_service_drawing_Shape }; + return aSvxShape_UnoServices; + } + OSL_FAIL( "SvxShape::_getSupportedServiceNames: could not determine object type!" ); + uno::Sequence< OUString > aSeq; + return aSeq; +} + +sal_Bool SAL_CALL SvxShape::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +// XGluePointsSupplier +uno::Reference< container::XIndexContainer > SAL_CALL SvxShape::getGluePoints() +{ + ::SolarMutexGuard aGuard; + uno::Reference< container::XIndexContainer > xGluePoints( mxGluePoints ); + + if( HasSdrObject() && !xGluePoints.is() ) + { + uno::Reference< container::XIndexContainer > xNew( SvxUnoGluePointAccess_createInstance( GetSdrObject() ), uno::UNO_QUERY ); + mxGluePoints = xGluePoints = xNew; + } + + return xGluePoints; +} + +// XChild +uno::Reference<uno::XInterface> SAL_CALL SvxShape::getParent() +{ + ::SolarMutexGuard aGuard; + const SdrObject* pSdrObject(GetSdrObject()); + + if(nullptr != pSdrObject) + { + const SdrObjList* pParentSdrObjList(GetSdrObject()->getParentSdrObjListFromSdrObject()); + + if(nullptr != pParentSdrObjList) + { + // SdrObject is member of a SdrObjList. That may be a SdrObject + // (SdrObjGroup or E3dScene) or a SdrPage. + // Check for SdrObject first - using getSdrPageFromSdrObjList + // *will* get the SdrPage even when the SdrObject is deep buried + // in a construct of SdrObjGroup. + // We want to ask for the direct parent here... + SdrObject* pParentSdrObject(pParentSdrObjList->getSdrObjectFromSdrObjList()); + + if(nullptr != pParentSdrObject) + { + // SdrObject is member of a SdrObject-based Group (SdrObjGroup or E3dScene). + return pParentSdrObject->getUnoShape(); + } + else + { + SdrPage* pParentSdrPage(pParentSdrObjList->getSdrPageFromSdrObjList()); + + if(nullptr != pParentSdrPage) + { + // SdrObject is inserted to a SdrPage. Since + // we checked for getSdrObjectFromSdrObjList first, + // we can even say that it is directly member of that + // SdrPage. + return pParentSdrPage->getUnoPage(); + } + } + + // not member of any SdrObjList, no parent + OSL_FAIL( "SvxShape::getParent( ): unexpected Parent SdrObjList" ); + } + } + + // no SdrObject, no parent + return uno::Reference<uno::XInterface>(); +} + +void SAL_CALL SvxShape::setParent( const css::uno::Reference< css::uno::XInterface >& ) +{ + throw lang::NoSupportException(); +} + + +/** called from the XActionLockable interface methods on initial locking */ +void SvxShape::lock() +{ +} + + +/** called from the XActionLockable interface methods on final unlock */ +void SvxShape::unlock() +{ +} + + +// XActionLockable +sal_Bool SAL_CALL SvxShape::isActionLocked( ) +{ + ::SolarMutexGuard aGuard; + + return mnLockCount != 0; +} + + +void SAL_CALL SvxShape::addActionLock( ) +{ + ::SolarMutexGuard aGuard; + + DBG_ASSERT( mnLockCount < 0xffff, "lock overflow in SvxShape!" ); + mnLockCount++; + + if( mnLockCount == 1 ) + lock(); +} + + +void SAL_CALL SvxShape::removeActionLock( ) +{ + ::SolarMutexGuard aGuard; + + DBG_ASSERT( mnLockCount > 0, "lock underflow in SvxShape!" ); + mnLockCount--; + + if( mnLockCount == 0 ) + unlock(); +} + + +void SAL_CALL SvxShape::setActionLocks( sal_Int16 nLock ) +{ + ::SolarMutexGuard aGuard; + + if( (mnLockCount == 0) && (nLock != 0) ) + unlock(); + + if( (mnLockCount != 0) && (nLock == 0) ) + lock(); + + mnLockCount = static_cast<sal_uInt16>(nLock); +} + + +sal_Int16 SAL_CALL SvxShape::resetActionLocks( ) +{ + ::SolarMutexGuard aGuard; + + if( mnLockCount != 0 ) + unlock(); + + sal_Int16 nOldLocks = static_cast<sal_Int16>(mnLockCount); + mnLockCount = 0; + + return nOldLocks; +} + + +/** since polygon shapes can change their kind during editing, we have + to recheck it here. + Circle shapes also change their kind, but they are all treated equal + so no update is necessary. +*/ +void SvxShape::updateShapeKind() +{ + switch( mpImpl->mnObjId ) + { + case OBJ_LINE: + case OBJ_POLY: + case OBJ_PLIN: + case OBJ_PATHLINE: + case OBJ_PATHFILL: + case OBJ_FREELINE: + case OBJ_FREEFILL: + case OBJ_PATHPOLY: + case OBJ_PATHPLIN: + { + const sal_uInt32 nId = GetSdrObject()->GetObjIdentifier(); + + if( nId != mpImpl->mnObjId ) + { + mpImpl->mnObjId = nId; + + } + break; + } + } +} + +SvxShapeText::SvxShapeText(SdrObject* pObject) +: SvxShape( pObject, getSvxMapProvider().GetMap(SVXMAP_TEXT), getSvxMapProvider().GetPropertySet(SVXMAP_TEXT, SdrObject::GetGlobalDrawObjectItemPool()) ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() ) +{ + if( pObject ) + SetEditSource( new SvxTextEditSource( pObject, nullptr ) ); +} + + +SvxShapeText::SvxShapeText(SdrObject* pObject, const SfxItemPropertyMapEntry* pPropertyMap, const SvxItemPropertySet* pPropertySet) +: SvxShape( pObject, pPropertyMap, pPropertySet ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() ) +{ + if( pObject ) + SetEditSource( new SvxTextEditSource( pObject, nullptr ) ); +} + + +SvxShapeText::~SvxShapeText() throw () +{ + // check if only this instance is registered at the ranges + DBG_ASSERT( (nullptr == GetEditSource()) || (GetEditSource()->getRanges().size()==1), + "svx::SvxShapeText::~SvxShapeText(), text shape with living text ranges destroyed!"); +} + +void SvxShapeText::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage ) +{ + if( pNewObj && (nullptr == GetEditSource())) + SetEditSource( new SvxTextEditSource( pNewObj, nullptr ) ); + SvxShape::Create( pNewObj, pNewPage ); +} + +// XInterface + +uno::Any SAL_CALL SvxShapeText::queryInterface( const uno::Type & rType ) +{ + return SvxShape::queryInterface( rType ); +} + + +uno::Any SAL_CALL SvxShapeText::queryAggregation( const uno::Type & rType ) +{ + uno::Any aAny( SvxShape::queryAggregation( rType ) ); + if( aAny.hasValue() ) + return aAny; + + return SvxUnoTextBase::queryAggregation( rType ); +} + + +// XServiceInfo + +OUString SAL_CALL SvxShapeText::getImplementationName() +{ + return "SvxShapeText"; +} + + +uno::Sequence< OUString > SAL_CALL SvxShapeText::getSupportedServiceNames() +{ + return SvxShape::getSupportedServiceNames(); +} + + +sal_Bool SAL_CALL SvxShapeText::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(static_cast<SvxShape*>(this), ServiceName); +} + + // XTypeProvider + +uno::Sequence< uno::Type > SAL_CALL SvxShapeText::getTypes() +{ + return SvxShape::getTypes(); +} + +sal_Int64 SAL_CALL SvxShapeText::getSomething( const css::uno::Sequence< sal_Int8 >& rId ) +{ + const sal_Int64 nReturn = SvxShape::getSomething( rId ); + if( nReturn ) + return nReturn; + + return SvxUnoTextBase::getSomething( rId ); +} + + +uno::Sequence< sal_Int8 > SAL_CALL SvxShapeText::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +/** called from the XActionLockable interface methods on initial locking */ +void SvxShapeText::lock() +{ + SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource()); + if( pEditSource ) + pEditSource->lock(); +} + + +/** called from the XActionLockable interface methods on final unlock */ +void SvxShapeText::unlock() +{ + SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource()); + if( pEditSource ) + pEditSource->unlock(); +} + +// css::text::XTextRange +uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getStart() +{ + ::SolarMutexGuard aGuard; + SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr; + if( pForwarder ) + ::GetSelection( maSelection, pForwarder ); + return SvxUnoTextBase::getStart(); + +} + +uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getEnd() +{ + ::SolarMutexGuard aGuard; + SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr; + if( pForwarder ) + ::GetSelection( maSelection, pForwarder ); + return SvxUnoTextBase::getEnd(); +} + +OUString SAL_CALL SvxShapeText::getString() +{ + ::SolarMutexGuard aGuard; + SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr; + if( pForwarder ) + ::GetSelection( maSelection, pForwarder ); + return SvxUnoTextBase::getString(); +} + + +void SAL_CALL SvxShapeText::setString( const OUString& aString ) +{ + ::SolarMutexGuard aGuard; + SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr; + if( pForwarder ) + ::GetSelection( maSelection, pForwarder ); + SvxUnoTextBase::setString( aString ); +} + +// override these for special property handling in subcasses. Return true if property is handled +bool SvxShapeText::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) +{ + // HACK-fix #99090# + // since SdrTextObj::SetVerticalWriting exchanges + // SDRATTR_TEXT_AUTOGROWWIDTH and SDRATTR_TEXT_AUTOGROWHEIGHT, + // we have to set the textdirection here + + if( pProperty->nWID == SDRATTR_TEXTDIRECTION ) + { + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetSdrObject() ); + if( pTextObj ) + { + css::text::WritingMode eMode; + if( rValue >>= eMode ) + { + pTextObj->SetVerticalWriting( eMode == css::text::WritingMode_TB_RL ); + } + } + return true; + } + return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); +} + +bool SvxShapeText::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue ) +{ + if( pProperty->nWID == SDRATTR_TEXTDIRECTION ) + { + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetSdrObject() ); + if( pTextObj && pTextObj->IsVerticalWriting() ) + rValue <<= css::text::WritingMode_TB_RL; + else + rValue <<= css::text::WritingMode_LR_TB; + return true; + } + + return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); +} + +bool SvxShapeText::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, css::beans::PropertyState& rState ) +{ + return SvxShape::getPropertyStateImpl( pProperty, rState ); +} + +bool SvxShapeText::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty ) +{ + return SvxShape::setPropertyToDefaultImpl( pProperty ); +} + +SvxShapeRect::SvxShapeRect(SdrObject* pObj) +: SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_SHAPE), getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool())) +{ +} + +SvxShapeRect::~SvxShapeRect() throw() +{ +} + +uno::Any SAL_CALL SvxShapeRect::queryInterface( const uno::Type & rType ) +{ + return SvxShapeText::queryInterface( rType ); +} + +uno::Any SAL_CALL SvxShapeRect::queryAggregation( const uno::Type & rType ) +{ + return SvxShapeText::queryAggregation( rType ); +} + +// XServiceInfo + +uno::Sequence< OUString > SvxShapeRect::getSupportedServiceNames() +{ + return SvxShape::getSupportedServiceNames(); +} + +/** returns a StarOffice API wrapper for the given SdrObject */ +uno::Reference< drawing::XShape > GetXShapeForSdrObject( SdrObject* pObj ) throw () +{ + uno::Reference< drawing::XShape > xShape( pObj->getUnoShape(), uno::UNO_QUERY ); + return xShape; +} + +/** returns the SdrObject from the given StarOffice API wrapper */ +SdrObject* GetSdrObjectFromXShape( const uno::Reference< drawing::XShape >& xShape ) throw() +{ + SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape ); + return pShape ? pShape->GetSdrObject() : nullptr; +} + + +SdrObject* SdrObject::getSdrObjectFromXShape( const css::uno::Reference< css::uno::XInterface >& xInt ) +{ + SvxShape* pSvxShape = comphelper::getUnoTunnelImplementation<SvxShape>( xInt ); + return pSvxShape ? pSvxShape->GetSdrObject() : nullptr; +} + +uno::Any SvxItemPropertySet_getPropertyValue( const SfxItemPropertySimpleEntry* pMap, const SfxItemSet& rSet ) +{ + if(!pMap || !pMap->nWID) + return uno::Any(); + + // Check is for items that store either metric values if they are positive or percentage if they are negative. + bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY ); + return SvxItemPropertySet::getPropertyValue( pMap, rSet, (pMap->nWID != SDRATTR_XMLATTRIBUTES), bDontConvertNegativeValues ); +} + +void SvxItemPropertySet_setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rVal, SfxItemSet& rSet ) +{ + if(!pMap || !pMap->nWID) + return; + + bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY ); + SvxItemPropertySet::setPropertyValue( pMap, rVal, rSet, bDontConvertNegativeValues ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |