Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / core / unocore / unodraw.cxx
blob: dbfc02959c2dbb524fc50ffc84b719f91ed8dfd9 [file] [log] [blame]
/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#include <swtypes.hxx>
#include <cmdid.h>
#include <unomid.h>
#include <unodraw.hxx>
#include <unocoll.hxx>
#include <unoframe.hxx>
#include <unoparagraph.hxx>
#include <unotextrange.hxx>
#include <unoprnms.hxx>
#include <editeng/unoprnms.hxx>
#include <svx/svditer.hxx>
#include <swunohelper.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <fmtcntnt.hxx>
#include <fmtflcnt.hxx>
#include <txtatr.hxx>
#include <docsh.hxx>
#include <unomap.hxx>
#include <unoport.hxx>
#include <unocrsr.hxx>
#include <TextCursorHelper.hxx>
#include <swundo.hxx>
#include <dflyobj.hxx>
#include <ndtxt.hxx>
#include <svx/svdview.hxx>
#include <svx/unoshape.hxx>
#include <dcontact.hxx>
#include <svx/fmglob.hxx>
#include <fmtornt.hxx>
#include <fmtanchr.hxx>
#include <fmtsrnd.hxx>
#include <fmtfollowtextflow.hxx>
#include <rootfrm.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/ulspitem.hxx>
#include <svx/shapepropertynotifier.hxx>
#include <crstate.hxx>
#include <vos/mutex.hxx>
#include <comphelper/extract.hxx>
#include <comphelper/stl_types.hxx>
#include <comphelper/makesequence.hxx>
#include <svx/scene3d.hxx>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/drawing/XDrawPageSupplier.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <basegfx/numeric/ftools.hxx>
#include <algorithm>
#include <fmtwrapinfluenceonobjpos.hxx>
#include <com/sun/star/text/TextContentAnchorType.hpp>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <com/sun/star/drawing/PointSequence.hpp>
#include <vcl/svapp.hxx>
#include <list>
#include <iterator>
#include <switerator.hxx>
using ::rtl::OUString;
using namespace ::com::sun::star;
DECLARE_STL_USTRINGACCESS_MAP( uno::Sequence< sal_Int8 > *, SwShapeImplementationIdMap );
static SwShapeImplementationIdMap aImplementationIdMap;
class SwShapeDescriptor_Impl
{
SwFmtHoriOrient* pHOrient;
SwFmtVertOrient* pVOrient;
SwFmtAnchor* pAnchor;
SwFmtSurround* pSurround;
SvxULSpaceItem* pULSpace;
SvxLRSpaceItem* pLRSpace;
sal_Bool bOpaque;
uno::Reference< text::XTextRange > xTextRange;
// OD 2004-04-21 #i26791#
SwFmtFollowTextFlow* mpFollowTextFlow;
// OD 2004-05-05 #i28701# - add property 'WrapInfluenceOnObjPos'
SwFmtWrapInfluenceOnObjPos* pWrapInfluenceOnObjPos;
// --> OD 2004-08-06 #i28749#
sal_Int16 mnPositionLayoutDir;
// <--
public:
bool bInitializedPropertyNotifier;
public:
SwShapeDescriptor_Impl() :
// --> OD 2004-08-18 #i32349# - no defaults, in order to determine on
// adding a shape, if positioning attributes are set or not.
pHOrient( 0L ),
pVOrient( 0L ),
// <--
pAnchor(0),
pSurround(0),
pULSpace(0),
pLRSpace(0),
bOpaque(sal_False),
// OD 2004-04-21 #i26791#
mpFollowTextFlow( new SwFmtFollowTextFlow( sal_False ) ),
// OD 2004-05-05 #i28701#
// --> OD 2004-10-18 #i35017# - constant name has changed
pWrapInfluenceOnObjPos( new SwFmtWrapInfluenceOnObjPos(
text::WrapInfluenceOnPosition::ONCE_CONCURRENT ) ),
// <--
// --> OD 2004-08-06 #i28749#
mnPositionLayoutDir( text::PositionLayoutDir::PositionInLayoutDirOfAnchor ),
bInitializedPropertyNotifier(false)
{}
~SwShapeDescriptor_Impl()
{
delete pHOrient;
delete pVOrient;
delete pAnchor;
delete pSurround;
delete pULSpace;
delete pLRSpace;
// OD 2004-04-22 #i26791#
delete mpFollowTextFlow;
// OD 2004-05-05 #i28701#
delete pWrapInfluenceOnObjPos;
}
SwFmtAnchor* GetAnchor(sal_Bool bCreate = sal_False)
{
if(bCreate && !pAnchor)
{
pAnchor = new SwFmtAnchor(FLY_AS_CHAR);
}
return pAnchor;
}
SwFmtHoriOrient* GetHOrient(sal_Bool bCreate = sal_False)
{
if (bCreate && !pHOrient)
{
// OD 2004-06-03 #i26791# - change default
pHOrient = new SwFmtHoriOrient( 0, text::HoriOrientation::NONE, text::RelOrientation::FRAME );
}
return pHOrient;
}
SwFmtVertOrient* GetVOrient(sal_Bool bCreate = sal_False)
{
if(bCreate && !pVOrient)
{
// OD 2004-04-21 #i26791# - change default
pVOrient = new SwFmtVertOrient( 0, text::VertOrientation::NONE, text::RelOrientation::FRAME );
}
return pVOrient;
}
SwFmtSurround* GetSurround(sal_Bool bCreate = sal_False)
{
if(bCreate && !pSurround)
pSurround = new SwFmtSurround();
return pSurround;
}
SvxLRSpaceItem* GetLRSpace(sal_Bool bCreate = sal_False)
{
if(bCreate && !pLRSpace)
pLRSpace = new SvxLRSpaceItem(RES_LR_SPACE);
return pLRSpace;
}
SvxULSpaceItem* GetULSpace(sal_Bool bCreate = sal_False)
{
if(bCreate && !pULSpace)
pULSpace = new SvxULSpaceItem(RES_UL_SPACE);
return pULSpace;
}
uno::Reference< text::XTextRange > & GetTextRange()
{
return xTextRange;
}
sal_Bool IsOpaque()
{
return bOpaque;
}
const sal_Bool& GetOpaque()
{
return bOpaque;
}
void RemoveHOrient(){DELETEZ(pHOrient);}
void RemoveVOrient(){DELETEZ(pVOrient);}
void RemoveAnchor(){DELETEZ(pAnchor);}
void RemoveSurround(){DELETEZ(pSurround);}
void RemoveULSpace(){DELETEZ(pULSpace);}
void RemoveLRSpace(){DELETEZ(pLRSpace);}
void SetOpaque(sal_Bool bSet){bOpaque = bSet;}
// OD 2004-04-21 #i26791#
SwFmtFollowTextFlow* GetFollowTextFlow( sal_Bool _bCreate = sal_False )
{
if ( _bCreate && !mpFollowTextFlow )
mpFollowTextFlow = new SwFmtFollowTextFlow( sal_False );
return mpFollowTextFlow;
}
void RemoveFollowTextFlow()
{
DELETEZ(mpFollowTextFlow);
}
// --> OD 2004-08-06 #i28749#
sal_Int16 GetPositionLayoutDir() const
{
return mnPositionLayoutDir;
}
void SetPositionLayoutDir( sal_Int16 _nPositionLayoutDir )
{
switch ( _nPositionLayoutDir )
{
case text::PositionLayoutDir::PositionInHoriL2R:
case text::PositionLayoutDir::PositionInLayoutDirOfAnchor:
{
mnPositionLayoutDir = _nPositionLayoutDir;
}
break;
default:
{
ASSERT( false,
"<SwShapeDescriptor_Impl::SetPositionLayoutDir(..)> - invalid attribute value." );
}
}
}
void RemovePositionLayoutDir()
{
mnPositionLayoutDir = text::PositionLayoutDir::PositionInLayoutDirOfAnchor;
}
// <--
// OD 2004-05-05 #i28701#
inline SwFmtWrapInfluenceOnObjPos* GetWrapInfluenceOnObjPos(
const sal_Bool _bCreate = sal_False )
{
if ( _bCreate && !pWrapInfluenceOnObjPos )
{
pWrapInfluenceOnObjPos = new SwFmtWrapInfluenceOnObjPos(
// --> OD 2004-10-18 #i35017# - constant name has changed
text::WrapInfluenceOnPosition::ONCE_CONCURRENT );
// <--
}
return pWrapInfluenceOnObjPos;
}
inline void RemoveWrapInfluenceOnObjPos()
{
DELETEZ(pWrapInfluenceOnObjPos);
}
};
/****************************************************************************
class SwFmDrawPage
****************************************************************************/
SwFmDrawPage::SwFmDrawPage( SdrPage* pPage ) :
SvxFmDrawPage( pPage ), pPageView(0)
{
}
SwFmDrawPage::~SwFmDrawPage() throw ()
{
RemovePageView();
}
const SdrMarkList& SwFmDrawPage::PreGroup(const uno::Reference< drawing::XShapes > & xShapes)
{
_SelectObjectsInView( xShapes, GetPageView() );
const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
return rMarkList;
}
void SwFmDrawPage::PreUnGroup(const uno::Reference< drawing::XShapeGroup > xShapeGroup)
{
uno::Reference< drawing::XShape > xShape( xShapeGroup, uno::UNO_QUERY);
_SelectObjectInView( xShape, GetPageView() );
}
SdrPageView* SwFmDrawPage::GetPageView()
{
if(!pPageView)
pPageView = mpView->ShowSdrPage( mpPage );
return pPageView;
}
void SwFmDrawPage::RemovePageView()
{
if(pPageView && mpView)
mpView->HideSdrPage();
pPageView = 0;
}
uno::Reference< uno::XInterface > SwFmDrawPage::GetInterface( SdrObject* pObj )
{
uno::Reference< XInterface > xShape;
if( pObj )
{
SwFrmFmt* pFmt = ::FindFrmFmt( pObj );
SwXShape* pxShape = SwIterator<SwXShape,SwFmt>::FirstElement( *pFmt );
if(pxShape)
{
xShape = *(cppu::OWeakObject*)pxShape;
}
else
xShape = pObj->getUnoShape();
}
return xShape;
}
SdrObject* SwFmDrawPage::_CreateSdrObject( const uno::Reference< drawing::XShape > & xShape ) throw ()
{
//TODO: stimmt das so - kann die Methode weg?
return SvxFmDrawPage::_CreateSdrObject( xShape );
}
uno::Reference< drawing::XShape > SwFmDrawPage::_CreateShape( SdrObject *pObj ) const throw ()
{
uno::Reference< drawing::XShape > xRet;
if(pObj->ISA(SwVirtFlyDrawObj) || pObj->GetObjInventor() == SWGInventor)
{
SwFlyDrawContact* pFlyContact = (SwFlyDrawContact*)pObj->GetUserCall();
if(pFlyContact)
{
FlyCntType eType = FLYCNTTYPE_ALL;
SwFrmFmt* pFlyFmt = pFlyContact->GetFmt();
SwDoc* pDoc = pFlyFmt->GetDoc();
const SwNodeIndex* pIdx;
if( RES_FLYFRMFMT == pFlyFmt->Which()
&& 0 != ( pIdx = pFlyFmt->GetCntnt().GetCntntIdx() )
&& pIdx->GetNodes().IsDocNodes()
)
{
const SwNode* pNd = pDoc->GetNodes()[ pIdx->GetIndex() + 1 ];
if(!pNd->IsNoTxtNode())
eType = FLYCNTTYPE_FRM;
else if( pNd->IsGrfNode() )
eType = FLYCNTTYPE_GRF;
else if( pNd->IsOLENode() )
eType = FLYCNTTYPE_OLE;
}
else
{
ASSERT( false,
"<SwFmDrawPage::_CreateShape(..)> - could not retrieve type. Thus, no shape created." );
return xRet;
}
DBG_ASSERT( eType != FLYCNTTYPE_ALL, "unexpected FlyCntType value for eType" );
xRet = SwXFrames::GetObject( *pFlyFmt, eType );
}
}
else
{
// own block - temporary object has to be destroyed before
// the delegator is set #81670#
{
xRet = SvxFmDrawPage::_CreateShape( pObj );
}
uno::Reference< XUnoTunnel > xShapeTunnel(xRet, uno::UNO_QUERY);
//don't create an SwXShape if it already exists
SwXShape* pShape = 0;
if(xShapeTunnel.is())
pShape = reinterpret_cast< SwXShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething(SwXShape::getUnoTunnelId()) ));
if(!pShape)
{
xShapeTunnel = 0;
uno::Reference< uno::XInterface > xCreate(xRet, uno::UNO_QUERY);
xRet = 0;
uno::Reference< beans::XPropertySet > xPrSet;
if ( pObj->IsGroupObject() && (!pObj->Is3DObj() || ( PTR_CAST(E3dScene,pObj ) != NULL ) ) )
xPrSet = new SwXGroupShape( xCreate );
else
xPrSet = new SwXShape( xCreate );
xRet = uno::Reference< drawing::XShape >(xPrSet, uno::UNO_QUERY);
}
}
return xRet;
}
/****************************************************************************
class SwXShapesEnumeration
****************************************************************************/
namespace
{
class SwXShapesEnumeration
: public SwSimpleEnumeration_Base
{
private:
typedef ::std::list< ::com::sun::star::uno::Any > shapescontainer_t;
shapescontainer_t m_aShapes;
protected:
virtual ~SwXShapesEnumeration() {};
public:
SwXShapesEnumeration(SwXDrawPage* const pDrawPage);
//XEnumeration
virtual sal_Bool SAL_CALL hasMoreElements(void) throw(uno::RuntimeException);
virtual uno::Any SAL_CALL nextElement(void) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException);
//XServiceInfo
virtual OUString SAL_CALL getImplementationName(void) throw(uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) throw(uno::RuntimeException);
virtual uno::Sequence<OUString> SAL_CALL getSupportedServiceNames(void) throw(uno::RuntimeException);
};
}
SwXShapesEnumeration::SwXShapesEnumeration(SwXDrawPage* const pDrawPage)
: m_aShapes()
{
vos::OGuard aGuard(Application::GetSolarMutex());
::std::insert_iterator<shapescontainer_t> pInserter = ::std::insert_iterator<shapescontainer_t>(m_aShapes, m_aShapes.begin());
sal_Int32 nCount = pDrawPage->getCount();
for(sal_Int32 nIdx = 0; nIdx < nCount; nIdx++)
{
uno::Reference<drawing::XShape> xShape = uno::Reference<drawing::XShape>(pDrawPage->getByIndex(nIdx), uno::UNO_QUERY);
*pInserter++ = uno::makeAny(xShape);
}
}
sal_Bool SwXShapesEnumeration::hasMoreElements(void) throw(uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
return !m_aShapes.empty();
}
uno::Any SwXShapesEnumeration::nextElement(void) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(m_aShapes.empty())
throw container::NoSuchElementException();
uno::Any aResult = *m_aShapes.begin();
m_aShapes.pop_front();
return aResult;
}
OUString SwXShapesEnumeration::getImplementationName(void) throw(uno::RuntimeException)
{
return C2U("SwXShapeEnumeration");
}
sal_Bool SwXShapesEnumeration::supportsService(const OUString& ServiceName) throw(uno::RuntimeException)
{
return C2U("com.sun.star.container.XEnumeration") == ServiceName;
}
uno::Sequence< OUString > SwXShapesEnumeration::getSupportedServiceNames(void) throw(uno::RuntimeException)
{
return ::comphelper::makeSequence(C2U("com.sun.star.container.XEnumeration"));
}
/****************************************************************************
class SwXDrawPage
****************************************************************************/
uno::Reference< container::XEnumeration > SwXDrawPage::createEnumeration(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
return uno::Reference< container::XEnumeration >(
new SwXShapesEnumeration(this));
}
rtl::OUString SwXDrawPage::getImplementationName(void) throw( uno::RuntimeException )
{
return C2U("SwXDrawPage");
}
sal_Bool SwXDrawPage::supportsService(const rtl::OUString& rServiceName) throw( uno::RuntimeException )
{
return C2U("com.sun.star.drawing.GenericDrawPage") == rServiceName;
}
uno::Sequence< rtl::OUString > SwXDrawPage::getSupportedServiceNames(void) throw( uno::RuntimeException )
{
uno::Sequence< rtl::OUString > aRet(1);
rtl::OUString* pArray = aRet.getArray();
pArray[0] = C2U("com.sun.star.drawing.GenericDrawPage");
return aRet;
}
SwXDrawPage::SwXDrawPage(SwDoc* pDc) :
pDoc(pDc),
pDrawPage(0)
{
}
SwXDrawPage::~SwXDrawPage()
{
if(xPageAgg.is())
{
uno::Reference< uno::XInterface > xInt;
xPageAgg->setDelegator(xInt);
}
}
uno::Any SwXDrawPage::queryInterface( const uno::Type& aType )
throw( uno::RuntimeException )
{
uno::Any aRet = SwXDrawPageBaseClass::queryInterface(aType);
if(!aRet.hasValue())
{
// secure with checking if page exists. This may not be the case
// either for new SW docs with no yet graphics usage or when
// the doc is closed and someone else still holds a UNO reference
// to the XDrawPage (in that case, pDoc is set to 0)
SwFmDrawPage* pPage = GetSvxPage();
if(pPage)
{
aRet = pPage->queryAggregation(aType);
}
}
return aRet;
}
uno::Sequence< uno::Type > SwXDrawPage::getTypes() throw( uno::RuntimeException )
{
uno::Sequence< uno::Type > aPageTypes = SwXDrawPageBaseClass::getTypes();
uno::Sequence< uno::Type > aSvxTypes = GetSvxPage()->getTypes();
long nIndex = aPageTypes.getLength();
aPageTypes.realloc(aPageTypes.getLength() + aSvxTypes.getLength() + 1);
uno::Type* pPageTypes = aPageTypes.getArray();
const uno::Type* pSvxTypes = aSvxTypes.getConstArray();
long nPos;
for(nPos = 0; nPos < aSvxTypes.getLength(); nPos++)
{
pPageTypes[nIndex++] = pSvxTypes[nPos];
}
pPageTypes[nIndex] = ::getCppuType((uno::Reference<form::XFormsSupplier2>*)0);
return aPageTypes;
}
sal_Int32 SwXDrawPage::getCount(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
if(!pDoc->GetDrawModel())
return 0;
else
{
((SwXDrawPage*)this)->GetSvxPage();
return pDrawPage->getCount();
}
}
uno::Any SwXDrawPage::getByIndex(sal_Int32 nIndex)
throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException,
uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
if(!pDoc->GetDrawModel())
throw lang::IndexOutOfBoundsException();
((SwXDrawPage*)this)->GetSvxPage();
return pDrawPage->getByIndex( nIndex );
}
uno::Type SwXDrawPage::getElementType(void) throw( uno::RuntimeException )
{
return ::getCppuType((const uno::Reference<drawing::XShape>*)0);
}
sal_Bool SwXDrawPage::hasElements(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
if(!pDoc->GetDrawModel())
return sal_False;
else
return ((SwXDrawPage*)this)->GetSvxPage()->hasElements();
}
void SwXDrawPage::add(const uno::Reference< drawing::XShape > & xShape)
throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShape, uno::UNO_QUERY);
SwXShape* pShape = 0;
SvxShape* pSvxShape = 0;
if(xShapeTunnel.is())
{
pShape = reinterpret_cast< SwXShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething(SwXShape::getUnoTunnelId()) ));
pSvxShape = reinterpret_cast< SvxShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething(SvxShape::getUnoTunnelId()) ));
}
if(!pShape || pShape->GetRegisteredIn() || !pShape->m_bDescriptor )
{
uno::RuntimeException aExcept;
if(pShape)
aExcept.Message = C2U("object already inserted");
else
aExcept.Message = C2U("illegal object");
throw aExcept;
}
// --> OD, HB
if ( pSvxShape->GetSdrObject() )
{
if ( pSvxShape->GetSdrObject()->IsInserted() )
{
return;
}
}
// <--
GetSvxPage()->add(xShape);
uno::Reference< uno::XAggregation > xAgg = pShape->GetAggregationInterface();
DBG_ASSERT(pSvxShape, "warum gibt es hier kein SvxShape?");
//diese Position ist auf jeden Fall in 1/100 mm
awt::Point aMM100Pos(pSvxShape->getPosition());
//jetzt noch die Properties aus dem SwShapeDescriptor_Impl auswerten
SwShapeDescriptor_Impl* pDesc = pShape->GetDescImpl();
SfxItemSet aSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
RES_FRMATR_END-1 );
SwFmtAnchor aAnchor( FLY_AS_CHAR );
sal_Bool bOpaque = sal_False;
if( pDesc )
{
if(pDesc->GetSurround())
aSet.Put( *pDesc->GetSurround());
//die Items sind schon in Twip gesetzt
if(pDesc->GetLRSpace())
{
aSet.Put(*pDesc->GetLRSpace());
}
if(pDesc->GetULSpace())
{
aSet.Put(*pDesc->GetULSpace());
}
if(pDesc->GetAnchor())
aAnchor = *pDesc->GetAnchor();
// --> OD 2004-08-18 #i32349# - if no horizontal position exists, create one
if ( !pDesc->GetHOrient() )
{
SwFmtHoriOrient* pHori = pDesc->GetHOrient( sal_True );
SwTwips nHoriPos = MM100_TO_TWIP(aMM100Pos.X);
pHori->SetPos( nHoriPos );
}
// <--
{
if(pDesc->GetHOrient()->GetHoriOrient() == text::HoriOrientation::NONE)
aMM100Pos.X = TWIP_TO_MM100(pDesc->GetHOrient()->GetPos());
aSet.Put( *pDesc->GetHOrient() );
}
// --> OD 2004-08-18 #i32349# - if no vertical position exists, create one
if ( !pDesc->GetVOrient() )
{
SwFmtVertOrient* pVert = pDesc->GetVOrient( sal_True );
SwTwips nVertPos = MM100_TO_TWIP(aMM100Pos.Y);
pVert->SetPos( nVertPos );
}
// <--
{
if(pDesc->GetVOrient()->GetVertOrient() == text::VertOrientation::NONE)
aMM100Pos.Y = TWIP_TO_MM100(pDesc->GetVOrient()->GetPos());
aSet.Put( *pDesc->GetVOrient() );
}
if(pDesc->GetSurround())
aSet.Put( *pDesc->GetSurround());
bOpaque = pDesc->IsOpaque();
// OD 2004-04-22 #i26791#
if ( pDesc->GetFollowTextFlow() )
{
aSet.Put( *pDesc->GetFollowTextFlow() );
}
// OD 2004-05-05 #i28701#
if ( pDesc->GetWrapInfluenceOnObjPos() )
{
aSet.Put( *pDesc->GetWrapInfluenceOnObjPos() );
}
}
pSvxShape->setPosition(aMM100Pos);
SdrObject* pObj = pSvxShape->GetSdrObject();
// OD 25.06.2003 #108784# - set layer of new drawing object to corresponding
// invisible layer.
if(FmFormInventor != pObj->GetObjInventor())
pObj->SetLayer( bOpaque ? pDoc->GetInvisibleHeavenId() : pDoc->GetInvisibleHellId() );
else
pObj->SetLayer(pDoc->GetInvisibleControlsId());
SwPaM* pPam = new SwPaM(pDoc->GetNodes().GetEndOfContent());
SwUnoInternalPaM* pInternalPam = 0;
uno::Reference< text::XTextRange > xRg;
if( pDesc && (xRg = pDesc->GetTextRange()).is() )
{
pInternalPam = new SwUnoInternalPaM(*pDoc);
if (::sw::XTextRangeToSwPaM(*pInternalPam, xRg))
{
if(FLY_AT_FLY == aAnchor.GetAnchorId() &&
!pInternalPam->GetNode()->FindFlyStartNode())
{
aAnchor.SetType(FLY_AS_CHAR);
}
else if (FLY_AT_PAGE == aAnchor.GetAnchorId())
{
aAnchor.SetAnchor(pInternalPam->Start());
}
}
else
throw uno::RuntimeException();
}
else if ((aAnchor.GetAnchorId() != FLY_AT_PAGE) && pDoc->GetCurrentLayout())
{
SwCrsrMoveState aState( MV_SETONLYTEXT );
Point aTmp(MM100_TO_TWIP(aMM100Pos.X), MM100_TO_TWIP(aMM100Pos.Y));
pDoc->GetCurrentLayout()->GetCrsrOfst( pPam->GetPoint(), aTmp, &aState ); //swmod 080218
aAnchor.SetAnchor( pPam->GetPoint() );
// --> OD 2004-08-18 #i32349# - adjustment of vertical positioning
// attributes no longer needed, because its already got a default.
}
else
{
aAnchor.SetType(FLY_AT_PAGE);
// --> OD 2004-08-18 #i32349# - adjustment of vertical positioning
// attributes no longer needed, because its already got a default.
}
aSet.Put(aAnchor);
SwPaM* pTemp = pInternalPam;
if ( !pTemp )
pTemp = pPam;
UnoActionContext aAction(pDoc);
pDoc->InsertDrawObj( *pTemp, *pObj, aSet );
SwFrmFmt* pFmt = ::FindFrmFmt( pObj );
if(pFmt)
pFmt->Add(pShape);
pShape->m_bDescriptor = sal_False;
delete pPam;
delete pInternalPam;
}
void SwXDrawPage::remove(const uno::Reference< drawing::XShape > & xShape) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
uno::Reference<lang::XComponent> xComp(xShape, uno::UNO_QUERY);
xComp->dispose();
}
uno::Reference< drawing::XShapeGroup > SwXDrawPage::group(const uno::Reference< drawing::XShapes > & xShapes) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc || !xShapes.is())
throw uno::RuntimeException();
uno::Reference< drawing::XShapeGroup > xRet;
if(xPageAgg.is())
{
SwFmDrawPage* pPage = GetSvxPage();
if(pPage)//kann das auch Null sein?
{
//markieren und MarkList zurueckgeben
const SdrMarkList& rMarkList = pPage->PreGroup(xShapes);
if ( rMarkList.GetMarkCount() > 1 )
{
sal_Bool bFlyInCnt = sal_False;
for ( sal_uInt16 i = 0; !bFlyInCnt && i < rMarkList.GetMarkCount(); ++i )
{
const SdrObject *pObj = rMarkList.GetMark( i )->GetMarkedSdrObj();
if (FLY_AS_CHAR == ::FindFrmFmt(const_cast<SdrObject*>(
pObj))->GetAnchor().GetAnchorId())
{
bFlyInCnt = sal_True;
}
}
if( bFlyInCnt )
throw uno::RuntimeException();
if( !bFlyInCnt )
{
UnoActionContext aContext(pDoc);
pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL );
SwDrawContact* pContact = pDoc->GroupSelection( *pPage->GetDrawView() );
pDoc->ChgAnchor(
pPage->GetDrawView()->GetMarkedObjectList(),
FLY_AT_PARA/*int eAnchorId*/,
sal_True, sal_False );
pPage->GetDrawView()->UnmarkAll();
if(pContact)
{
uno::Reference< uno::XInterface > xInt = pPage->GetInterface( pContact->GetMaster() );
xRet = uno::Reference< drawing::XShapeGroup >(xInt, uno::UNO_QUERY);
}
pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
}
}
pPage->RemovePageView();
}
}
return xRet;
}
void SwXDrawPage::ungroup(const uno::Reference< drawing::XShapeGroup > & xShapeGroup) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
if(!pDoc)
throw uno::RuntimeException();
if(xPageAgg.is())
{
SwFmDrawPage* pPage = GetSvxPage();
if(pPage)//kann das auch Null sein?
{
pPage->PreUnGroup(xShapeGroup);
UnoActionContext aContext(pDoc);
pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL );
pDoc->UnGroupSelection( *pPage->GetDrawView() );
pDoc->ChgAnchor( pPage->GetDrawView()->GetMarkedObjectList(),
FLY_AT_PARA/*int eAnchorId*/,
sal_True, sal_False );
pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
}
pPage->RemovePageView();
}
}
SwFmDrawPage* SwXDrawPage::GetSvxPage()
{
if(!xPageAgg.is() && pDoc)
{
vos::OGuard aGuard(Application::GetSolarMutex());
// --> OD 2005-08-08 #i52858# - method name changed
SdrModel* pModel = pDoc->GetOrCreateDrawModel();
// <--
SdrPage* pPage = pModel->GetPage( 0 );
{
// waehrend des queryInterface braucht man ein Ref auf das
// Objekt, sonst wird es geloescht.
pDrawPage = new SwFmDrawPage(pPage);
uno::Reference< drawing::XDrawPage > xPage = pDrawPage;
uno::Any aAgg = xPage->queryInterface(::getCppuType((uno::Reference< uno::XAggregation >*)0));
if(aAgg.getValueType() == ::getCppuType((uno::Reference< uno::XAggregation >*)0))
xPageAgg = *(uno::Reference< uno::XAggregation >*)aAgg.getValue();
}
if( xPageAgg.is() )
xPageAgg->setDelegator( (cppu::OWeakObject*)this );
}
return pDrawPage;
}
// renamed and outlined to detect where it's called
void SwXDrawPage::InvalidateSwDoc()
{
pDoc = 0;
}
/****************************************************************************
****************************************************************************/
TYPEINIT1(SwXShape, SwClient);
const uno::Sequence< sal_Int8 > & SwXShape::getUnoTunnelId()
{
static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
return aSeq;
}
sal_Int64 SAL_CALL SwXShape::getSomething( const uno::Sequence< sal_Int8 >& rId )
throw(uno::RuntimeException)
{
if( rId.getLength() == 16
&& 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
rId.getConstArray(), 16 ) )
{
return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
}
if( xShapeAgg.is() )
{
const uno::Type& rTunnelType = ::getCppuType((uno::Reference<lang::XUnoTunnel>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rTunnelType );
if(aAgg.getValueType() == rTunnelType)
{
uno::Reference<lang::XUnoTunnel> xAggTunnel =
*(uno::Reference<lang::XUnoTunnel>*)aAgg.getValue();
if(xAggTunnel.is())
return xAggTunnel->getSomething(rId);
}
}
return 0;
}
namespace
{
static void lcl_addShapePropertyEventFactories( SdrObject& _rObj, SwXShape& _rShape )
{
::svx::PPropertyValueProvider pProvider( new ::svx::PropertyValueProvider( _rShape, "AnchorType" ) );
_rObj.getShapePropertyChangeNotifier().registerProvider( ::svx::eTextShapeAnchorType, pProvider );
}
}
SwXShape::SwXShape(uno::Reference< uno::XInterface > & xShape) :
m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_SHAPE)),
m_pPropertyMapEntries(aSwMapProvider.GetPropertyMapEntries(PROPERTY_MAP_TEXT_SHAPE)),
pImplementationId(0),
pImpl(new SwShapeDescriptor_Impl()),
m_bDescriptor(sal_True)
{
if(xShape.is()) // default Ctor
{
const uno::Type& rAggType = ::getCppuType((const uno::Reference< uno::XAggregation >*)0);
//aAgg contains a reference of the SvxShape!
{
uno::Any aAgg = xShape->queryInterface(rAggType);
if(aAgg.getValueType() == rAggType)
xShapeAgg = *(uno::Reference< uno::XAggregation >*)aAgg.getValue();
// --> OD 2004-07-23 #i31698#
if ( xShapeAgg.is() )
{
xShapeAgg->queryAggregation( ::getCppuType((uno::Reference< drawing::XShape >*)0) ) >>= mxShape;
ASSERT( mxShape.is(),
"<SwXShape::SwXShape(..)> - no XShape found at <xShapeAgg>" );
}
// <--
}
xShape = 0;
m_refCount++;
if( xShapeAgg.is() )
xShapeAgg->setDelegator( (cppu::OWeakObject*)this );
m_refCount--;
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShapeAgg, uno::UNO_QUERY);
SvxShape* pShape = 0;
if(xShapeTunnel.is())
pShape = reinterpret_cast< SvxShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething(SvxShape::getUnoTunnelId()) ));
SdrObject* pObj = pShape ? pShape->GetSdrObject() : 0;
if(pObj)
{
SwFrmFmt* pFmt = ::FindFrmFmt( pObj );
if(pFmt)
pFmt->Add(this);
lcl_addShapePropertyEventFactories( *pObj, *this );
pImpl->bInitializedPropertyNotifier = true;
}
}
}
void SwXShape::AddExistingShapeToFmt( SdrObject& _rObj )
{
SdrObjListIter aIter( _rObj, IM_DEEPNOGROUPS );
while ( aIter.IsMore() )
{
SdrObject* pCurrent = aIter.Next();
OSL_ENSURE( pCurrent, "SwXShape::AddExistingShapeToFmt: invalid object list element!" );
if ( !pCurrent )
continue;
SwXShape* pSwShape = NULL;
uno::Reference< lang::XUnoTunnel > xShapeTunnel( pCurrent->getWeakUnoShape(), uno::UNO_QUERY );
if ( xShapeTunnel.is() )
pSwShape = reinterpret_cast< SwXShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething( SwXShape::getUnoTunnelId() ) ) );
if ( pSwShape )
{
if ( pSwShape->m_bDescriptor )
{
SwFrmFmt* pFmt = ::FindFrmFmt( const_cast< SdrObject* >( pCurrent ) );
if ( pFmt )
pFmt->Add( pSwShape );
pSwShape->m_bDescriptor = sal_False;
}
if ( !pSwShape->pImpl->bInitializedPropertyNotifier )
{
lcl_addShapePropertyEventFactories( *pCurrent, *pSwShape );
pSwShape->pImpl->bInitializedPropertyNotifier = true;
}
}
}
}
SwXShape::~SwXShape()
{
if (xShapeAgg.is())
{
uno::Reference< uno::XInterface > xRef;
xShapeAgg->setDelegator(xRef);
}
delete pImpl;
}
uno::Any SwXShape::queryInterface( const uno::Type& aType ) throw( uno::RuntimeException )
{
uno::Any aRet = SwXShapeBaseClass::queryInterface(aType);
// --> OD 2005-08-15 #i53320# - follow-up of #i31698#
// interface drawing::XShape is overloaded. Thus, provide
// correct object instance.
if(!aRet.hasValue() && xShapeAgg.is())
{
if(aType == ::getCppuType((uno::Reference<XShape>*)0))
aRet <<= uno::Reference<XShape>(this);
else
aRet = xShapeAgg->queryAggregation(aType);
}
// <--
return aRet;
}
uno::Sequence< uno::Type > SwXShape::getTypes( ) throw(uno::RuntimeException)
{
uno::Sequence< uno::Type > aRet = SwXShapeBaseClass::getTypes();
if(xShapeAgg.is())
{
uno::Any aProv = xShapeAgg->queryAggregation(::getCppuType((uno::Reference< XTypeProvider >*)0));
if(aProv.hasValue())
{
uno::Reference< XTypeProvider > xAggProv;
aProv >>= xAggProv;
uno::Sequence< uno::Type > aAggTypes = xAggProv->getTypes();
const uno::Type* pAggTypes = aAggTypes.getConstArray();
long nIndex = aRet.getLength();
aRet.realloc(nIndex + aAggTypes.getLength());
uno::Type* pBaseTypes = aRet.getArray();
for(long i = 0; i < aAggTypes.getLength(); i++)
pBaseTypes[nIndex++] = pAggTypes[i];
}
}
return aRet;
}
uno::Sequence< sal_Int8 > SwXShape::getImplementationId( ) throw(uno::RuntimeException)
{
vos::OGuard aGuard( Application::GetSolarMutex() );
// do we need to compute the implementation id for this instance?
if( !pImplementationId && xShapeAgg.is())
{
uno::Reference< XShape > xAggShape;
xShapeAgg->queryAggregation( ::getCppuType((uno::Reference< XShape >*)0) ) >>= xAggShape;
if( xAggShape.is() )
{
const rtl::OUString aShapeType( xAggShape->getShapeType() );
// did we already compute an implementation id for the agregated shape type?
SwShapeImplementationIdMap::iterator aIter( aImplementationIdMap.find(aShapeType ) );
if( aIter == aImplementationIdMap.end() )
{
// we need to create a new implementation id for this
// note: this memory is not free'd until application exists
// but since we have a fixed set of shapetypes and the
// memory will be reused this is ok.
pImplementationId = new uno::Sequence< sal_Int8 >( 16 );
rtl_createUuid( (sal_uInt8 *) pImplementationId->getArray(), 0, sal_True );
aImplementationIdMap[ aShapeType ] = pImplementationId;
}
else
{
// use the already computed implementation id
pImplementationId = (*aIter).second;
}
}
}
if( NULL == pImplementationId )
{
DBG_ERROR( "Could not create an implementation id for a SwXShape!" );
return uno::Sequence< sal_Int8 > ();
}
else
{
return *pImplementationId;
}
}
uno::Reference< beans::XPropertySetInfo > SwXShape::getPropertySetInfo(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference< beans::XPropertySetInfo > aRet;
if(xShapeAgg.is())
{
const uno::Type& rPropSetType = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
uno::Any aPSet = xShapeAgg->queryAggregation( rPropSetType );
if(aPSet.getValueType() == rPropSetType && aPSet.getValue())
{
uno::Reference< beans::XPropertySet > xPrSet =
*(uno::Reference< beans::XPropertySet >*)aPSet.getValue();
uno::Reference< beans::XPropertySetInfo > xInfo = xPrSet->getPropertySetInfo();
// PropertySetInfo verlaengern!
const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
aRet = new SfxExtItemPropertySetInfo( m_pPropertyMapEntries, aPropSeq );
}
}
if(!aRet.is())
aRet = m_pPropSet->getPropertySetInfo();
return aRet;
}
void SwXShape::setPropertyValue(const rtl::OUString& rPropertyName, const uno::Any& aValue)
throw( beans::UnknownPropertyException, beans::PropertyVetoException,
lang::IllegalArgumentException, lang::WrappedTargetException,
uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
SwFrmFmt* pFmt = GetFrmFmt();
const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
if(xShapeAgg.is())
{
if(pEntry)
{
if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
throw beans::PropertyVetoException ( rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
//mit Layout kann der Anker umgesetzt werden, ohne dass sich die Position aendert
if(pFmt)
{
SwAttrSet aSet(pFmt->GetAttrSet());
SwDoc* pDoc = pFmt->GetDoc();
if(RES_ANCHOR == pEntry->nWID && MID_ANCHOR_ANCHORFRAME == pEntry->nMemberId)
{
sal_Bool bDone = sal_True;
uno::Reference<text::XTextFrame> xFrame;
if(aValue >>= xFrame)
{
uno::Reference<lang::XUnoTunnel> xTunnel(xFrame, uno::UNO_QUERY);
SwXFrame* pFrame = xTunnel.is() ?
reinterpret_cast< SwXFrame * >(
sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SwXFrame::getUnoTunnelId()) ))
: 0;
if(pFrame && pFrame->GetFrmFmt() &&
pFrame->GetFrmFmt()->GetDoc() == pDoc)
{
UnoActionContext aCtx(pDoc);
SfxItemSet aItemSet( pDoc->GetAttrPool(),
RES_FRMATR_BEGIN, RES_FRMATR_END - 1 );
aItemSet.SetParent(&pFmt->GetAttrSet());
SwFmtAnchor aAnchor = (const SwFmtAnchor&)aItemSet.Get(pEntry->nWID);
SwPosition aPos(*pFrame->GetFrmFmt()->GetCntnt().GetCntntIdx());
aAnchor.SetAnchor(&aPos);
aAnchor.SetType(FLY_AT_FLY);
aItemSet.Put(aAnchor);
pFmt->SetFmtAttr(aItemSet);
bDone = sal_True;
}
}
if(!bDone)
throw lang::IllegalArgumentException();
}
else if(RES_OPAQUE == pEntry->nWID)
{
SvxShape* pSvxShape = GetSvxShape();
DBG_ASSERT(pSvxShape, "No SvxShape found!");
if(pSvxShape)
{
SdrObject* pObj = pSvxShape->GetSdrObject();
// OD 25.06.2003 #108784# - set layer of new drawing
// object to corresponding invisible layer.
bool bIsVisible = pDoc->IsVisibleLayerId( pObj->GetLayer() );
if(FmFormInventor != pObj->GetObjInventor())
{
pObj->SetLayer( *(sal_Bool*)aValue.getValue()
? ( bIsVisible ? pDoc->GetHeavenId() : pDoc->GetInvisibleHeavenId() )
: ( bIsVisible ? pDoc->GetHellId() : pDoc->GetInvisibleHellId() ));
}
else
{
pObj->SetLayer( bIsVisible ? pDoc->GetControlsId() : pDoc->GetInvisibleControlsId());
}
}
}
// OD 2004-04-22 #i26791# - special handling for property FN_TEXT_RANGE
else if ( FN_TEXT_RANGE == pEntry->nWID )
{
SwFmtAnchor aAnchor( static_cast<const SwFmtAnchor&>(aSet.Get( RES_ANCHOR )) );
if (aAnchor.GetAnchorId() == FLY_AT_PAGE)
{
// set property <TextRange> not valid for to-page anchored shapes
throw lang::IllegalArgumentException();
}
else
{
SwUnoInternalPaM* pInternalPam =
new SwUnoInternalPaM( *(pFmt->GetDoc()) );
uno::Reference< text::XTextRange > xRg;
aValue >>= xRg;
if (::sw::XTextRangeToSwPaM(*pInternalPam, xRg) )
{
if (aAnchor.GetAnchorId() == FLY_AS_CHAR)
{
//delete old SwFmtFlyCnt
//With AnchorAsCharacter the current TxtAttribute has to be deleted.
//Tbis removes the frame format too.
//To prevent this the connection between format and attribute has to be broken before.
const SwPosition *pPos = aAnchor.GetCntntAnchor();
SwTxtNode *pTxtNode = pPos->nNode.GetNode().GetTxtNode();
ASSERT( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
const xub_StrLen nIdx = pPos->nContent.GetIndex();
SwTxtAttr * const pHnt =
pTxtNode->GetTxtAttrForCharAt(
nIdx, RES_TXTATR_FLYCNT );
DBG_ASSERT( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
"Missing FlyInCnt-Hint." );
DBG_ASSERT( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pFmt,
"Wrong TxtFlyCnt-Hint." );
const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt())
.SetFlyFmt();
//The connection is removed now the attribute can be deleted.
pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx );
//create a new one
SwTxtNode *pNd = pInternalPam->GetNode()->GetTxtNode();
DBG_ASSERT( pNd, "Cursor not at TxtNode." );
SwFmtFlyCnt aFmt( pFmt );
pNd->InsertItem(aFmt, pInternalPam->GetPoint()
->nContent.GetIndex(), 0 );
}
else
{
aAnchor.SetAnchor( pInternalPam->GetPoint() );
aSet.Put(aAnchor);
pFmt->SetFmtAttr(aSet);
}
}
else
{
throw uno::RuntimeException();
}
delete pInternalPam;
}
}
// --> OD 2004-08-06 #i28749#
else if ( FN_SHAPE_POSITION_LAYOUT_DIR == pEntry->nWID )
{
sal_Int16 nPositionLayoutDir = 0;
aValue >>= nPositionLayoutDir;
pFmt->SetPositionLayoutDir( nPositionLayoutDir );
}
// <--
else if( pDoc->GetCurrentLayout()) //swmod 080218
{
UnoActionContext aCtx(pDoc);
if(RES_ANCHOR == pEntry->nWID && MID_ANCHOR_ANCHORTYPE == pEntry->nMemberId)
{
SdrObject* pObj = pFmt->FindSdrObject();
SdrMarkList aList;
SdrMark aMark(pObj);
aList.InsertEntry(aMark);
sal_Int32 nAnchor = 0;
cppu::enum2int( nAnchor, aValue );
pDoc->ChgAnchor( aList, (RndStdIds)nAnchor,
sal_False, sal_True );
}
else
{
m_pPropSet->setPropertyValue(*pEntry, aValue, aSet);
pFmt->SetFmtAttr(aSet);
}
}
else
{
m_pPropSet->setPropertyValue( *pEntry, aValue, aSet );
if(RES_ANCHOR == pEntry->nWID && MID_ANCHOR_ANCHORTYPE == pEntry->nMemberId)
{
bool bSetAttr = true;
sal_Int32 eNewAnchor = SWUnoHelper::GetEnumAsInt32( aValue );
//if old anchor was in_cntnt the related text attribute has to be removed
const SwFmtAnchor& rOldAnchor = pFmt->GetAnchor();
RndStdIds eOldAnchorId = rOldAnchor.GetAnchorId();
SdrObject* pObj = pFmt->FindSdrObject();
SwFrmFmt *pFlyFmt = FindFrmFmt( pObj );
pFlyFmt->DelFrms();
if( text::TextContentAnchorType_AS_CHARACTER != eNewAnchor &&
(FLY_AS_CHAR == eOldAnchorId))
{
//With AnchorAsCharacter the current TxtAttribute has to be deleted.
//Tbis removes the frame format too.
//To prevent this the connection between format and attribute has to be broken before.
const SwPosition *pPos = rOldAnchor.GetCntntAnchor();
SwTxtNode *pTxtNode = pPos->nNode.GetNode().GetTxtNode();
ASSERT( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
const xub_StrLen nIdx = pPos->nContent.GetIndex();
SwTxtAttr * const pHnt =
pTxtNode->GetTxtAttrForCharAt(
nIdx, RES_TXTATR_FLYCNT );
DBG_ASSERT( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
"Missing FlyInCnt-Hint." );
DBG_ASSERT( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pFlyFmt,
"Wrong TxtFlyCnt-Hint." );
const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt())
.SetFlyFmt();
//The connection is removed now the attribute can be deleted.
pTxtNode->DeleteAttributes(RES_TXTATR_FLYCNT, nIdx);
}
else if( text::TextContentAnchorType_AT_PAGE != eNewAnchor &&
(FLY_AT_PAGE == eOldAnchorId))
{
SwFmtAnchor aNewAnchor( dynamic_cast< const SwFmtAnchor& >( aSet.Get( RES_ANCHOR ) ) );
//if the fly has been anchored at page then it needs to be connected
//to the content position
SwPaM aPam(pDoc->GetNodes().GetEndOfContent());
if( pDoc->GetCurrentLayout() )
{
SwCrsrMoveState aState( MV_SETONLYTEXT );
Point aTmp( pObj->GetSnapRect().TopLeft() );
pDoc->GetCurrentLayout()->GetCrsrOfst( aPam.GetPoint(), aTmp, &aState );
}
else
{
//without access to the layout the last node of the body will be used as anchor position
aPam.Move( fnMoveBackward, fnGoDoc );
}
//anchor position has to be inserted after the text attribute has been inserted
aNewAnchor.SetAnchor( aPam.GetPoint() );
aSet.Put( aNewAnchor );
pFmt->SetFmtAttr(aSet);
bSetAttr = false;
if( text::TextContentAnchorType_AS_CHARACTER == eNewAnchor &&
(FLY_AS_CHAR != eOldAnchorId))
{
//the RES_TXTATR_FLYCNT needs to be added now
SwTxtNode *pNd = aPam.GetNode()->GetTxtNode();
DBG_ASSERT( pNd, "Crsr is not in a TxtNode." );
SwFmtFlyCnt aFmt( pFlyFmt );
pNd->InsertItem(aFmt,
aPam.GetPoint()->nContent.GetIndex(), 0 );
//aPam.GetPoint()->nContent--;
}
}
if( bSetAttr )
pFmt->SetFmtAttr(aSet);
}
else
pFmt->SetFmtAttr(aSet);
}
}
else
{
SfxPoolItem* pItem = 0;
switch(pEntry->nWID)
{
case RES_ANCHOR:
pItem = pImpl->GetAnchor(sal_True);
break;
case RES_HORI_ORIENT:
pItem = pImpl->GetHOrient(sal_True);
break;
case RES_VERT_ORIENT:
pItem = pImpl->GetVOrient(sal_True);
break;
case RES_LR_SPACE:
pItem = pImpl->GetLRSpace(sal_True);
break;
case RES_UL_SPACE:
pItem = pImpl->GetULSpace(sal_True);
break;
case RES_SURROUND:
pItem = pImpl->GetSurround(sal_True);
break;
case FN_TEXT_RANGE:
{
const uno::Type rTextRangeType =
::getCppuType((uno::Reference< text::XTextRange>*)0);
if(aValue.getValueType() == rTextRangeType)
{
uno::Reference< text::XTextRange > & rRange = pImpl->GetTextRange();
rRange = *(uno::Reference< text::XTextRange > *)aValue.getValue();
}
}
break;
case RES_OPAQUE :
pImpl->SetOpaque(*(sal_Bool*)aValue.getValue());
break;
// OD 2004-04-22 #i26791#
case RES_FOLLOW_TEXT_FLOW:
{
pItem = pImpl->GetFollowTextFlow( sal_True );
}
break;
// OD 2004-05-05 #i28701#
case RES_WRAP_INFLUENCE_ON_OBJPOS:
{
pItem = pImpl->GetWrapInfluenceOnObjPos( sal_True );
}
break;
// --> OD 2004-08-06 #i28749#
case FN_SHAPE_POSITION_LAYOUT_DIR :
{
sal_Int16 nPositionLayoutDir = 0;
aValue >>= nPositionLayoutDir;
pImpl->SetPositionLayoutDir( nPositionLayoutDir );
}
break;
// <--
}
if(pItem)
((SfxPoolItem*)pItem)->PutValue(aValue, pEntry->nMemberId);
}
}
else
{
uno::Reference< beans::XPropertySet > xPrSet;
const uno::Type& rPSetType =
::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
uno::Any aPSet = xShapeAgg->queryAggregation(rPSetType);
if(aPSet.getValueType() != rPSetType || !aPSet.getValue())
throw uno::RuntimeException();
xPrSet = *(uno::Reference< beans::XPropertySet >*)aPSet.getValue();
// --> OD 2004-08-05 #i31698# - setting the caption point of a
// caption object doesn't have to change the object position.
// Thus, keep the position, before the caption point is set and
// restore it afterwards.
awt::Point aKeepedPosition( 0, 0 );
if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CaptionPoint"))) &&
getShapeType().equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.CaptionShape"))) )
{
aKeepedPosition = getPosition();
}
// <--
if( pFmt && pFmt->GetDoc()->GetCurrentViewShell() ) //swmod 071108//swmod 071225
{
UnoActionContext aCtx(pFmt->GetDoc());
xPrSet->setPropertyValue(rPropertyName, aValue);
}
else
xPrSet->setPropertyValue(rPropertyName, aValue);
// --> OD 2004-11-11 #i35007# - adjustment of the position
// attributes, if the transformation is set, causes wrong alignments
// and is no longer needed.
// The position attributes are set, if the drawing object is added
// to the draw page - see <SwXDrawPage::add(..)> - and on its first
// positioning - see <SwAnchoredDrawObject::MakeObjPos().
// // --> OD 2004-07-28 #i31698# - additionally adjust the position
// // properties of the shape, if the transformation is set and
// // the shape isn't a group member.
// if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation"))) &&
// !_GetTopGroupObj() )
// {
// drawing::HomogenMatrix3 aMatrix;
// aValue >>= aMatrix;
// awt::Point aNewPos( basegfx::fround( aMatrix.Line1.Column3 ),
// basegfx::fround( aMatrix.Line2.Column3 ) );
// _AdjustPositionProperties( aNewPos );
// }
// --> OD 2004-08-05 #i31698# - restore object position, if caption
// point is set.
if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CaptionPoint"))) &&
getShapeType().equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.CaptionShape"))) )
{
setPosition( aKeepedPosition );
}
}
}
}
uno::Any SwXShape::getPropertyValue(const rtl::OUString& rPropertyName)
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Any aRet;
SwFrmFmt* pFmt = GetFrmFmt();
if(xShapeAgg.is())
{
const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
if(pEntry)
{
if(pFmt)
{
if(RES_OPAQUE == pEntry->nWID)
{
SvxShape* pSvxShape = GetSvxShape();
DBG_ASSERT(pSvxShape, "No SvxShape found!");
if(pSvxShape)
{
SdrObject* pObj = pSvxShape->GetSdrObject();
// OD 02.07.2003 #108784# - consider invisible layers
sal_Bool bOpaque =
( pObj->GetLayer() != pFmt->GetDoc()->GetHellId() &&
pObj->GetLayer() != pFmt->GetDoc()->GetInvisibleHellId() );
aRet.setValue(&bOpaque, ::getBooleanCppuType());
}
}
else if(FN_ANCHOR_POSITION == pEntry->nWID)
{
SvxShape* pSvxShape = GetSvxShape();
DBG_ASSERT(pSvxShape, "No SvxShape found!");
if(pSvxShape)
{
SdrObject* pObj = pSvxShape->GetSdrObject();
Point aPt = pObj->GetAnchorPos();
awt::Point aPoint( TWIP_TO_MM100( aPt.X() ),
TWIP_TO_MM100( aPt.Y() ) );
aRet.setValue(&aPoint, ::getCppuType( (awt::Point*)0 ));
}
}
// OD 2004-04-22 #i26791# - special handling for FN_TEXT_RANGE
else if ( FN_TEXT_RANGE == pEntry->nWID )
{
const SwFmtAnchor aAnchor = pFmt->GetAnchor();
if (aAnchor.GetAnchorId() == FLY_AT_PAGE)
{
// return nothing, because property <TextRange> isn't
// valid for to-page anchored shapes
uno::Any aAny;
aRet = aAny;
}
else
{
if ( aAnchor.GetCntntAnchor() )
{
const uno::Reference< text::XTextRange > xTextRange
= SwXTextRange::CreateXTextRange(
*pFmt->GetDoc(),
*aAnchor.GetCntntAnchor(),
0L );
aRet.setValue(&xTextRange, ::getCppuType((uno::Reference<text::XTextRange>*)0));
}
else
{
// return nothing
uno::Any aAny;
aRet = aAny;
}
}
}
// --> OD 2004-08-06 #i28749#
else if ( FN_SHAPE_TRANSFORMATION_IN_HORI_L2R == pEntry->nWID )
{
// get property <::drawing::Shape::Transformation>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")) );
}
else if ( FN_SHAPE_POSITION_LAYOUT_DIR == pEntry->nWID )
{
aRet <<= pFmt->GetPositionLayoutDir();
}
// <--
// --> OD 2004-10-28 #i36248#
else if ( FN_SHAPE_STARTPOSITION_IN_HORI_L2R == pEntry->nWID )
{
// get property <::drawing::Shape::StartPosition>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition")) );
}
else if ( FN_SHAPE_ENDPOSITION_IN_HORI_L2R == pEntry->nWID )
{
// get property <::drawing::Shape::EndPosition>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition")) );
}
// <--
else
{
const SwAttrSet& rSet = pFmt->GetAttrSet();
m_pPropSet->getPropertyValue(*pEntry, rSet, aRet);
}
}
else
{
SfxPoolItem* pItem = 0;
switch(pEntry->nWID)
{
case RES_ANCHOR:
pItem = pImpl->GetAnchor();
break;
case RES_HORI_ORIENT:
pItem = pImpl->GetHOrient();
break;
case RES_VERT_ORIENT:
pItem = pImpl->GetVOrient();
break;
case RES_LR_SPACE:
pItem = pImpl->GetLRSpace();
break;
case RES_UL_SPACE:
pItem = pImpl->GetULSpace();
break;
case RES_SURROUND:
pItem = pImpl->GetSurround();
break;
case FN_TEXT_RANGE :
aRet.setValue(&pImpl->GetTextRange(), ::getCppuType((uno::Reference<text::XTextRange>*)0));
break;
case RES_OPAQUE :
aRet.setValue(&pImpl->GetOpaque(), ::getBooleanCppuType());
break;
case FN_ANCHOR_POSITION :
{
awt::Point aPoint;
aRet.setValue(&aPoint, ::getCppuType( (awt::Point*)0 ));
}
break;
// OD 2004-04-22 #i26791#
case RES_FOLLOW_TEXT_FLOW :
{
pItem = pImpl->GetFollowTextFlow();
}
break;
// OD 2004-05-05 #i28701#
case RES_WRAP_INFLUENCE_ON_OBJPOS:
{
pItem = pImpl->GetWrapInfluenceOnObjPos();
}
break;
// --> OD 2004-08-06 #i28749#
case FN_SHAPE_TRANSFORMATION_IN_HORI_L2R:
{
// get property <::drawing::Shape::Transformation>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")) );
}
break;
case FN_SHAPE_POSITION_LAYOUT_DIR:
{
aRet <<= pImpl->GetPositionLayoutDir();
}
break;
// <--
// --> OD 2004-08-06 #i36248#
case FN_SHAPE_STARTPOSITION_IN_HORI_L2R:
{
// get property <::drawing::Shape::StartPosition>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition")) );
}
break;
case FN_SHAPE_ENDPOSITION_IN_HORI_L2R:
{
// get property <::drawing::Shape::StartPosition>
// without conversion to layout direction as below
aRet = _getPropAtAggrObj( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition")) );
}
break;
// <--
}
if(pItem)
pItem->QueryValue(aRet, pEntry->nMemberId);
}
}
else
{
aRet = _getPropAtAggrObj( rPropertyName );
// --> OD 2004-07-28 #i31698# - convert the position (translation)
// of the drawing object in the transformation
if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation"))) )
{
drawing::HomogenMatrix3 aMatrix;
aRet >>= aMatrix;
aRet <<= _ConvertTransformationToLayoutDir( aMatrix );
}
// <--
// --> OD 2004-10-28 #i36248#
else if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition"))) )
{
awt::Point aStartPos;
aRet >>= aStartPos;
// --> OD 2009-01-12 #i59051#
aRet <<= _ConvertStartOrEndPosToLayoutDir( aStartPos );
// <--
}
else if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition"))) )
{
awt::Point aEndPos;
aRet >>= aEndPos;
// --> OD 2009-01-12 #i59051#
aRet <<= _ConvertStartOrEndPosToLayoutDir( aEndPos );
// <--
}
// --> OD 2009-01-16 #i59051#
else if ( rPropertyName.equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PolyPolygonBezier"))) )
{
drawing::PolyPolygonBezierCoords aPath;
aRet >>= aPath;
aRet <<= _ConvertPolyPolygonBezierToLayoutDir( aPath );
// <--
}
// <--
}
}
return aRet;
}
uno::Any SwXShape::_getPropAtAggrObj( const ::rtl::OUString& _rPropertyName )
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
uno::Any aRet;
uno::Reference< beans::XPropertySet > xPrSet;
const uno::Type& rPSetType =
::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
uno::Any aPSet = xShapeAgg->queryAggregation(rPSetType);
if ( aPSet.getValueType() != rPSetType || !aPSet.getValue() )
{
throw uno::RuntimeException();
}
xPrSet = *(uno::Reference< beans::XPropertySet >*)aPSet.getValue();
aRet = xPrSet->getPropertyValue( _rPropertyName );
return aRet;
}
beans::PropertyState SwXShape::getPropertyState( const rtl::OUString& rPropertyName )
throw(beans::UnknownPropertyException, uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Sequence< rtl::OUString > aNames(1);
rtl::OUString* pStrings = aNames.getArray();
pStrings[0] = rPropertyName;
uno::Sequence< beans::PropertyState > aStates = getPropertyStates(aNames);
return aStates.getConstArray()[0];
}
uno::Sequence< beans::PropertyState > SwXShape::getPropertyStates(
const uno::Sequence< rtl::OUString >& aPropertyNames )
throw(beans::UnknownPropertyException, uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
SwFrmFmt* pFmt = GetFrmFmt();
uno::Sequence< beans::PropertyState > aRet(aPropertyNames.getLength());
if(xShapeAgg.is())
{
SvxShape* pSvxShape = GetSvxShape();
sal_Bool bGroupMember = sal_False;
sal_Bool bFormControl = sal_False;
SdrObject* pObject = pSvxShape->GetSdrObject();
if(pObject)
{
bGroupMember = pObject->GetUpGroup() != 0;
bFormControl = pObject->GetObjInventor() == FmFormInventor;
}
const rtl::OUString* pNames = aPropertyNames.getConstArray();
beans::PropertyState* pRet = aRet.getArray();
uno::Reference< XPropertyState > xShapePrState;
for(sal_Int32 nProperty = 0; nProperty < aPropertyNames.getLength(); nProperty++)
{
const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( pNames[nProperty] );
if(pEntry)
{
if(RES_OPAQUE == pEntry->nWID)
pRet[nProperty] = bFormControl ?
beans::PropertyState_DEFAULT_VALUE : beans::PropertyState_DIRECT_VALUE;
else if(FN_ANCHOR_POSITION == pEntry->nWID)
pRet[nProperty] = beans::PropertyState_DIRECT_VALUE;
else if(FN_TEXT_RANGE == pEntry->nWID)
pRet[nProperty] = beans::PropertyState_DIRECT_VALUE;
else if(bGroupMember)
pRet[nProperty] = beans::PropertyState_DEFAULT_VALUE;
else if(pFmt)
{
const SwAttrSet& rSet = pFmt->GetAttrSet();
SfxItemState eItemState = rSet.GetItemState(pEntry->nWID, sal_False);
if(SFX_ITEM_SET == eItemState)
pRet[nProperty] = beans::PropertyState_DIRECT_VALUE;
else if(SFX_ITEM_DEFAULT == eItemState)
pRet[nProperty] = beans::PropertyState_DEFAULT_VALUE;
else
pRet[nProperty] = beans::PropertyState_AMBIGUOUS_VALUE;
}
else
{
SfxPoolItem* pItem = 0;
switch(pEntry->nWID)
{
case RES_ANCHOR:
pItem = pImpl->GetAnchor();
break;
case RES_HORI_ORIENT:
pItem = pImpl->GetHOrient();
break;
case RES_VERT_ORIENT:
pItem = pImpl->GetVOrient();
break;
case RES_LR_SPACE:
pItem = pImpl->GetLRSpace();
break;
case RES_UL_SPACE:
pItem = pImpl->GetULSpace();
break;
case RES_SURROUND:
pItem = pImpl->GetSurround();
break;
// OD 2004-05-05 #i28701#
case RES_WRAP_INFLUENCE_ON_OBJPOS:
{
pItem = pImpl->GetWrapInfluenceOnObjPos();
}
break;
}
if(pItem)
pRet[nProperty] = beans::PropertyState_DIRECT_VALUE;
else
pRet[nProperty] = beans::PropertyState_DEFAULT_VALUE;
}
}
else
{
if(!xShapePrState.is())
{
const uno::Type& rPStateType = ::getCppuType((uno::Reference< XPropertyState >*)0);
uno::Any aPState = xShapeAgg->queryAggregation(rPStateType);
if(aPState.getValueType() != rPStateType || !aPState.getValue())
throw uno::RuntimeException();
xShapePrState = *(uno::Reference< XPropertyState >*)aPState.getValue();
}
pRet[nProperty] = xShapePrState->getPropertyState(pNames[nProperty]);
}
}
}
else
throw uno::RuntimeException();
return aRet;
}
void SwXShape::setPropertyToDefault( const rtl::OUString& rPropertyName )
throw(beans::UnknownPropertyException, uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
SwFrmFmt* pFmt = GetFrmFmt();
if(xShapeAgg.is())
{
const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
if(pEntry)
{
if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
throw uno::RuntimeException( rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) );
if(pFmt)
{
const SfxItemSet& rSet = pFmt->GetAttrSet();
SfxItemSet aSet(pFmt->GetDoc()->GetAttrPool(), pEntry->nWID, pEntry->nWID);
aSet.SetParent(&rSet);
aSet.ClearItem(pEntry->nWID);
pFmt->GetDoc()->SetAttr(aSet, *pFmt);
}
else
{
switch(pEntry->nWID)
{
case RES_ANCHOR: pImpl->RemoveAnchor(); break;
case RES_HORI_ORIENT: pImpl->RemoveHOrient(); break;
case RES_VERT_ORIENT: pImpl->RemoveVOrient(); break;
case RES_LR_SPACE: pImpl->RemoveLRSpace(); break;
case RES_UL_SPACE: pImpl->RemoveULSpace(); break;
case RES_SURROUND: pImpl->RemoveSurround();break;
case RES_OPAQUE : pImpl->SetOpaque(sal_False); break;
case FN_TEXT_RANGE :
break;
// OD 2004-04-22 #i26791#
case RES_FOLLOW_TEXT_FLOW:
{
pImpl->RemoveFollowTextFlow();
}
break;
// OD 2004-05-05 #i28701#
case RES_WRAP_INFLUENCE_ON_OBJPOS:
{
pImpl->RemoveWrapInfluenceOnObjPos();
}
break;
}
}
}
else
{
const uno::Type& rPStateType = ::getCppuType((uno::Reference< XPropertyState >*)0);
uno::Any aPState = xShapeAgg->queryAggregation(rPStateType);
if(aPState.getValueType() != rPStateType || !aPState.getValue())
throw uno::RuntimeException();
uno::Reference< XPropertyState > xShapePrState = *(uno::Reference< XPropertyState >*)aPState.getValue();
xShapePrState->setPropertyToDefault( rPropertyName );
}
}
else
throw uno::RuntimeException();
}
uno::Any SwXShape::getPropertyDefault( const rtl::OUString& rPropertyName )
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
SwFrmFmt* pFmt = GetFrmFmt();
uno::Any aRet;
if(xShapeAgg.is())
{
const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName );
if(pEntry)
{
if(pEntry->nWID < RES_FRMATR_END && pFmt)
{
const SfxPoolItem& rDefItem =
pFmt->GetDoc()->GetAttrPool().GetDefaultItem(pEntry->nWID);
rDefItem.QueryValue(aRet, pEntry->nMemberId);
}
else
throw uno::RuntimeException();
}
else
{
const uno::Type& rPStateType = ::getCppuType((uno::Reference< XPropertyState >*)0);
uno::Any aPState = xShapeAgg->queryAggregation(rPStateType);
if(aPState.getValueType() != rPStateType || !aPState.getValue())
throw uno::RuntimeException();
uno::Reference< XPropertyState > xShapePrState = *(uno::Reference< XPropertyState >*)aPState.getValue();
xShapePrState->getPropertyDefault( rPropertyName );
}
}
else
throw uno::RuntimeException();
return aRet;
}
void SwXShape::addPropertyChangeListener(
const rtl::OUString& _propertyName,
const uno::Reference< beans::XPropertyChangeListener > & _listener )
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
if ( !xShapeAgg.is() )
throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "no shape aggregate" ) ), *this );
// must be handled by the aggregate
uno::Reference< beans::XPropertySet > xShapeProps;
if ( xShapeAgg->queryAggregation( beans::XPropertySet::static_type() ) >>= xShapeProps )
xShapeProps->addPropertyChangeListener( _propertyName, _listener );
}
void SwXShape::removePropertyChangeListener(
const rtl::OUString& _propertyName,
const uno::Reference< beans::XPropertyChangeListener > & _listener)
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
if ( !xShapeAgg.is() )
throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "no shape aggregate" ) ), *this );
// must be handled by the aggregate
uno::Reference< beans::XPropertySet > xShapeProps;
if ( xShapeAgg->queryAggregation( beans::XPropertySet::static_type() ) >>= xShapeProps )
xShapeProps->removePropertyChangeListener( _propertyName, _listener );
}
void SwXShape::addVetoableChangeListener(
const rtl::OUString& /*PropertyName*/,
const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/ )
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
DBG_WARNING("not implemented");
}
void SwXShape::removeVetoableChangeListener(
const rtl::OUString& /*PropertyName*/,
const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/)
throw( beans::UnknownPropertyException, lang::WrappedTargetException,
uno::RuntimeException )
{
DBG_WARNING("not implemented");
}
void SwXShape::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
{
ClientModify(this, pOld, pNew);
}
void SwXShape::attach(const uno::Reference< text::XTextRange > & xTextRange)
throw( lang::IllegalArgumentException, uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
// get access to SwDoc
// (see also SwXTextRange::XTextRangeToSwPaM)
SwDoc* pDoc = 0;
uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
if(xRangeTunnel.is())
{
SwXTextRange* pRange = 0;
OTextCursorHelper* pCursor = 0;
SwXTextPortion* pPortion = 0;
SwXText* pText = 0;
SwXParagraph* pParagraph = 0;
pRange = reinterpret_cast< SwXTextRange * >(
sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
pText = reinterpret_cast< SwXText * >(
sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXText::getUnoTunnelId()) ));
pCursor = reinterpret_cast< OTextCursorHelper * >(
sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
pPortion = reinterpret_cast< SwXTextPortion * >(
sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextPortion::getUnoTunnelId()) ));
pParagraph = reinterpret_cast< SwXParagraph * >(
sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXParagraph::getUnoTunnelId( ) ) ) );
if (pRange)
pDoc = pRange->GetDoc();
else if (!pDoc && pText)
pDoc = pText->GetDoc();
else if (!pDoc && pCursor)
pDoc = pCursor->GetDoc();
else if ( !pDoc && pPortion && pPortion->GetCursor() )
{
pDoc = pPortion->GetCursor()->GetDoc();
}
else if ( !pDoc && pParagraph && pParagraph->GetTxtNode( ) )
{
pDoc = const_cast<SwDoc*>(pParagraph->GetTxtNode()->GetDoc());
}
}
if(!pDoc)
throw uno::RuntimeException();
SwDocShell *pDocSh = pDoc->GetDocShell();
if (pDocSh)
{
uno::Reference< frame::XModel > xModel;
xModel = pDocSh->GetModel();
uno::Reference< drawing::XDrawPageSupplier > xDPS(xModel, uno::UNO_QUERY);
if (xDPS.is())
{
uno::Reference< drawing::XDrawPage > xDP( xDPS->getDrawPage() );
if (xDP.is())
{
uno::Any aPos;
aPos <<= xTextRange;
setPropertyValue( C2U("TextRange"), aPos);
uno::Reference< drawing::XShape > xTemp( (cppu::OWeakObject*) this, uno::UNO_QUERY );
xDP->add( xTemp );
}
}
}
}
uno::Reference< text::XTextRange > SwXShape::getAnchor(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference< text::XTextRange > aRef;
SwFrmFmt* pFmt = GetFrmFmt();
if(pFmt)
{
const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
// return an anchor for non-page bound frames
// and for page bound frames that have a page no == NULL and a content position
if ((rAnchor.GetAnchorId() != FLY_AT_PAGE) ||
(rAnchor.GetCntntAnchor() && !rAnchor.GetPageNum()))
{
const SwPosition &rPos = *(pFmt->GetAnchor().GetCntntAnchor());
aRef = SwXTextRange::CreateXTextRange(*pFmt->GetDoc(), rPos, 0);
}
}
else
aRef = pImpl->GetTextRange();
return aRef;
}
void SwXShape::dispose(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
SwFrmFmt* pFmt = GetFrmFmt();
if(pFmt)
{
// OD 10.07.2003 #110742# - determine correct <SdrObject>
//SdrObject* pObj = pFmt->FindSdrObject();
SdrObject* pObj = GetSvxShape()->GetSdrObject();
// OD 10.07.2003 #110742# - safety assertion:
// <pObj> must be the same as <pFmt->FindSdrObject()>, if <pObj> isn't
// a 'virtual' drawing object.
// OD 25.08.2003 #111713# - refine assertion for safety reason.
// --> OD 2005-02-02 #119236# - correct assertion and refine it.
ASSERT( !pObj ||
pObj->ISA(SwDrawVirtObj) ||
pObj->GetUpGroup() ||
pObj == pFmt->FindSdrObject(),
"<SwXShape::dispose(..) - different 'master' drawing objects!!" );
// <--
// OD 10.07.2003 #110742# - perform delete of draw frame format *not*
// for 'virtual' drawing objects.
// --> OD 2005-02-02 #119236# - no delete of draw format for members
// of a group
if ( pObj &&
!pObj->ISA(SwDrawVirtObj) &&
!pObj->GetUpGroup() &&
pObj->IsInserted() )
// <--
{
if (pFmt->GetAnchor().GetAnchorId() == FLY_AS_CHAR)
{
const SwPosition &rPos = *(pFmt->GetAnchor().GetCntntAnchor());
SwTxtNode *pTxtNode = rPos.nNode.GetNode().GetTxtNode();
const xub_StrLen nIdx = rPos.nContent.GetIndex();
pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx );
}
else
pFmt->GetDoc()->DelLayoutFmt( pFmt );
}
}
if(xShapeAgg.is())
{
uno::Any aAgg(xShapeAgg->queryAggregation( ::getCppuType((uno::Reference<XComponent>*)0)));
uno::Reference<XComponent> xComp;
aAgg >>= xComp;
if(xComp.is())
xComp->dispose();
}
}
void SwXShape::addEventListener(
const uno::Reference< lang::XEventListener > & aListener)
throw( uno::RuntimeException )
{
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShapeAgg, uno::UNO_QUERY);
SvxShape* pSvxShape = GetSvxShape();
if(pSvxShape)
pSvxShape->addEventListener(aListener);
}
void SwXShape::removeEventListener(
const uno::Reference< lang::XEventListener > & aListener)
throw( uno::RuntimeException )
{
SvxShape* pSvxShape = GetSvxShape();
if(pSvxShape)
pSvxShape->removeEventListener(aListener);
}
rtl::OUString SwXShape::getImplementationName(void) throw( uno::RuntimeException )
{
return C2U("SwXShape");
}
sal_Bool SwXShape::supportsService(const rtl::OUString& rServiceName) throw( uno::RuntimeException )
{
sal_Bool bRet = sal_False;
if(COMPARE_EQUAL == rServiceName.compareToAscii("com.sun.star.drawing.Shape"))
bRet = sal_True;
else if(xShapeAgg.is())
{
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShapeAgg, uno::UNO_QUERY);
SvxShape* pSvxShape = GetSvxShape();
bRet = pSvxShape->supportsService(rServiceName);
}
return bRet;
}
uno::Sequence< rtl::OUString > SwXShape::getSupportedServiceNames(void) throw( uno::RuntimeException )
{
uno::Sequence< rtl::OUString > aSeq;
if(xShapeAgg.is())
{
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShapeAgg, uno::UNO_QUERY);
SvxShape* pSvxShape = GetSvxShape();
if(pSvxShape)
aSeq = pSvxShape->getSupportedServiceNames();
}
else
{
aSeq.realloc(1);
aSeq.getArray()[0] = C2U("com.sun.star.drawing.Shape");
}
return aSeq;
}
SvxShape* SwXShape::GetSvxShape()
{
SvxShape* pSvxShape = 0;
if(xShapeAgg.is())
{
uno::Reference< lang::XUnoTunnel > xShapeTunnel(xShapeAgg, uno::UNO_QUERY);
if(xShapeTunnel.is())
pSvxShape = reinterpret_cast< SvxShape * >(
sal::static_int_cast< sal_IntPtr >( xShapeTunnel->getSomething(SvxShape::getUnoTunnelId()) ));
}
return pSvxShape;
}
// --> OD 2004-07-22 #i31698# -
// implementation of virtual methods from drawing::XShape
awt::Point SAL_CALL SwXShape::getPosition() throw ( uno::RuntimeException )
{
awt::Point aPos( _GetAttrPosition() );
// handle group members
SvxShape* pSvxShape = GetSvxShape();
if ( pSvxShape )
{
SdrObject* pTopGroupObj = _GetTopGroupObj( pSvxShape );
if ( pTopGroupObj )
{
// --> OD 2004-10-01 #i34750# - get attribute position of top group
// shape and add offset between top group object and group member
uno::Reference< drawing::XShape > xGroupShape =
uno::Reference< drawing::XShape >( pTopGroupObj->getUnoShape(),
uno::UNO_QUERY );
aPos = xGroupShape->getPosition();
// add offset between top group object and group member
// to the determined attribute position
// --> OD 2004-10-01 #i34750# - correction:
// consider the layout direction
const Rectangle aMemberObjRect = GetSvxShape()->GetSdrObject()->GetSnapRect();
const Rectangle aGroupObjRect = pTopGroupObj->GetSnapRect();
// --> OD 2005-08-16 #i53320# - relative position of group member and
// top group object is always given in horizontal left-to-right layout.
// const SwFrmFmt::tLayoutDir eLayoutDir = GetFrmFmt()
// ? GetFrmFmt()->GetLayoutDir()
// : SwFrmFmt::HORI_L2R;
awt::Point aOffset( 0, 0 );
// switch ( eLayoutDir )
// {
// case SwFrmFmt::HORI_L2R:
{
aOffset.X = ( aMemberObjRect.Left() - aGroupObjRect.Left() );
aOffset.Y = ( aMemberObjRect.Top() - aGroupObjRect.Top() );
}
// break;
// case SwFrmFmt::HORI_R2L:
// {
// aOffset.X = ( aGroupObjRect.Right() - aMemberObjRect.Right() );
// aOffset.Y = ( aMemberObjRect.Top() - aGroupObjRect.Top() );
// }
// break;
// case SwFrmFmt::VERT_R2L:
// {
// aOffset.X = ( aMemberObjRect.Top() - aGroupObjRect.Top() );
// aOffset.Y = ( aGroupObjRect.Right() - aMemberObjRect.Right() );
// }
// break;
// default:
// {
// ASSERT( false,
// "<SwXShape::getPosition()> - unsupported layout direction" );
// }
// }
// <--
aOffset.X = TWIP_TO_MM100(aOffset.X);
aOffset.Y = TWIP_TO_MM100(aOffset.Y);
aPos.X += aOffset.X;
aPos.Y += aOffset.Y;
// <--
}
}
return aPos;
}
void SAL_CALL SwXShape::setPosition( const awt::Point& aPosition )
throw ( uno::RuntimeException )
{
SdrObject* pTopGroupObj = _GetTopGroupObj();
if ( !pTopGroupObj )
{
// --> OD 2005-02-10 #i37877# - no adjustment of position attributes,
// if the position also has to be applied at the drawing object and
// a contact object is already registered at the drawing object.
bool bApplyPosAtDrawObj(false);
bool bNoAdjustOfPosProp(false);
// --> OD 2004-10-19 #i35798# - apply position also to drawing object,
// if drawing object has no anchor position set.
if ( mxShape.is() )
{
SvxShape* pSvxShape = GetSvxShape();
if ( pSvxShape )
{
const SdrObject* pObj = pSvxShape->GetSdrObject();
if ( pObj &&
pObj->GetAnchorPos().X() == 0 &&
pObj->GetAnchorPos().Y() == 0 )
{
bApplyPosAtDrawObj = true;
if ( pObj->GetUserCall() &&
pObj->GetUserCall()->ISA(SwDrawContact) )
{
bNoAdjustOfPosProp = true;
}
}
}
}
// <--
// shape isn't a group member. Thus, set positioning attributes
if ( !bNoAdjustOfPosProp )
{
_AdjustPositionProperties( aPosition );
}
if ( bApplyPosAtDrawObj )
{
mxShape->setPosition( aPosition );
}
// <--
}
else if ( mxShape.is() )
{
// shape is a member of a group. Thus, set its position.
awt::Point aNewPos( aPosition );
// The given position is given in the according layout direction. Thus,
// it has to be converted to a position in horizontal left-to-right
// layout.
// convert given absolute attribute position in layout direction into
// position in horizontal left-to-right layout.
{
aNewPos = _ConvertPositionToHoriL2R( aNewPos, getSize() );
}
// Convert given absolute position in horizontal left-to-right
// layout into relative position in horizontal left-to-right layout.
uno::Reference< drawing::XShape > xGroupShape =
uno::Reference< drawing::XShape >( pTopGroupObj->getUnoShape(),
uno::UNO_QUERY );
{
// --> OD 2004-09-29 #i34750# - correction:
// use method <xGroupShape->getPosition()> to get the correct
// position of the top group object.
awt::Point aAttrPosInHoriL2R(
_ConvertPositionToHoriL2R( xGroupShape->getPosition(),
xGroupShape->getSize() ) );
// <--
aNewPos.X -= aAttrPosInHoriL2R.X;
aNewPos.Y -= aAttrPosInHoriL2R.Y;
}
// convert relative position in horizontal left-to-right layout into
// absolute position in horizontal left-to-right layout
{
// --> OD 2004-10-01 #i34750# - correction:
// use method <SvxShape->getPosition()> to get the correct
// 'Drawing layer' position of the top group shape.
uno::Reference< lang::XUnoTunnel > xGrpShapeTunnel(
pTopGroupObj->getUnoShape(),
uno::UNO_QUERY );
SvxShape* pSvxGroupShape = reinterpret_cast< SvxShape * >(
sal::static_int_cast< sal_IntPtr >( xGrpShapeTunnel->getSomething(SvxShape::getUnoTunnelId()) ));
const awt::Point aGroupPos = pSvxGroupShape->getPosition();
aNewPos.X += aGroupPos.X;
aNewPos.Y += aGroupPos.Y;
// <--
}
// set position
mxShape->setPosition( aNewPos );
}
}
awt::Size SAL_CALL SwXShape::getSize() throw ( uno::RuntimeException )
{
awt::Size aSize;
if ( mxShape.is() )
{
aSize = mxShape->getSize();
}
return aSize;
}
void SAL_CALL SwXShape::setSize( const awt::Size& aSize )
throw ( beans::PropertyVetoException,
uno::RuntimeException )
{
if ( mxShape.is() )
{
mxShape->setSize( aSize );
}
}
// <--
// --> OD 2004-07-22 #i31698# -
// implementation of virtual methods from drawing::XShapeDescriptor
::rtl::OUString SAL_CALL SwXShape::getShapeType() throw ( uno::RuntimeException )
{
::rtl::OUString aType;
if ( mxShape.is() )
{
aType = mxShape->getShapeType();
}
return aType;
}
// <--
/** method to determine top group object
OD 2004-08-03 #i31698#
@author OD
*/
SdrObject* SwXShape::_GetTopGroupObj( SvxShape* _pSvxShape )
{
SdrObject* pTopGroupObj( 0L );
SvxShape* pSvxShape = _pSvxShape ? _pSvxShape : GetSvxShape();
if ( pSvxShape )
{
SdrObject* pSdrObj = pSvxShape->GetSdrObject();
if ( pSdrObj && pSdrObj->GetUpGroup() )
{
pTopGroupObj = pSdrObj->GetUpGroup();
while ( pTopGroupObj->GetUpGroup() )
{
pTopGroupObj = pTopGroupObj->GetUpGroup();
}
}
}
return pTopGroupObj;
}
/** method to determine position according to the positioning attributes
OD 2004-08-03 #i31698#
@author OD
*/
awt::Point SwXShape::_GetAttrPosition()
{
awt::Point aAttrPos;
uno::Any aHoriPos( getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HoriOrientPosition")) ) );
aHoriPos >>= aAttrPos.X;
uno::Any aVertPos( getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VertOrientPosition")) ) );
aVertPos >>= aAttrPos.Y;
// --> OD 2004-10-19 #i35798# - fallback, if attribute position is (0,0)
// and no anchor position is applied to the drawing object
SvxShape* pSvxShape = GetSvxShape();
if ( pSvxShape )
{
const SdrObject* pObj = pSvxShape->GetSdrObject();
if ( pObj &&
pObj->GetAnchorPos().X() == 0 &&
pObj->GetAnchorPos().Y() == 0 &&
aAttrPos.X == 0 && aAttrPos.Y == 0 )
{
const Rectangle aObjRect = pObj->GetSnapRect();
aAttrPos.X = TWIP_TO_MM100(aObjRect.Left());
aAttrPos.Y = TWIP_TO_MM100(aObjRect.Top());
}
}
// <--
// --> OD 2004-11-10 #i35007# - If drawing object is anchored as-character,
// it's x-position isn't sensible. Thus, return the x-position as zero in this case.
text::TextContentAnchorType eTextAnchorType =
text::TextContentAnchorType_AT_PARAGRAPH;
{
rtl::OUString sAnchorType( RTL_CONSTASCII_USTRINGPARAM( "AnchorType" ) );
uno::Any aAny = getPropertyValue( sAnchorType );
aAny >>= eTextAnchorType;
}
if ( eTextAnchorType == text::TextContentAnchorType_AS_CHARACTER )
{
aAttrPos.X = 0;
}
// <--
return aAttrPos;
}
/** method to convert the position (translation) of the drawing object to
the layout direction horizontal left-to-right.
OD 2004-07-27 #i31698#
@author OD
*/
awt::Point SwXShape::_ConvertPositionToHoriL2R( const awt::Point _aObjPos,
const awt::Size _aObjSize )
{
awt::Point aObjPosInHoriL2R( _aObjPos );
SwFrmFmt* pFrmFmt = GetFrmFmt();
if ( pFrmFmt )
{
SwFrmFmt::tLayoutDir eLayoutDir = pFrmFmt->GetLayoutDir();
switch ( eLayoutDir )
{
case SwFrmFmt::HORI_L2R:
{
// nothing to do
}
break;
case SwFrmFmt::HORI_R2L:
{
aObjPosInHoriL2R.X = -_aObjPos.X - _aObjSize.Width;
}
break;
case SwFrmFmt::VERT_R2L:
{
aObjPosInHoriL2R.X = -_aObjPos.Y - _aObjSize.Width;
aObjPosInHoriL2R.Y = _aObjPos.X;
}
break;
default:
{
ASSERT( false,
"<SwXShape::_ConvertPositionToHoriL2R(..)> - unsupported layout direction" );
}
}
}
return aObjPosInHoriL2R;
}
/** method to convert the transformation of the drawing object to the layout
direction, the drawing object is in
OD 2004-07-27 #i31698#
@author OD
*/
drawing::HomogenMatrix3 SwXShape::_ConvertTransformationToLayoutDir(
drawing::HomogenMatrix3 _aMatrixInHoriL2R )
{
drawing::HomogenMatrix3 aMatrix( _aMatrixInHoriL2R );
// --> OD 2005-03-10 #i44334#, #i44681# - direct manipulation of the
// tranformation structure isn't valid, if it contains rotation.
SvxShape* pSvxShape = GetSvxShape();
ASSERT( pSvxShape,
"<SwXShape::_ConvertTransformationToLayoutDir(..)> - no SvxShape found!")
if ( pSvxShape )
{
const SdrObject* pObj = pSvxShape->GetSdrObject();
ASSERT( pObj,
"<SwXShape::_ConvertTransformationToLayoutDir(..)> - no SdrObject found!")
if ( pObj )
{
// get position of object in Writer coordinate system.
awt::Point aPos( getPosition() );
// get position of object in Drawing layer coordinate system
const Point aTmpObjPos( pObj->GetSnapRect().TopLeft() );
const awt::Point aObjPos(
TWIP_TO_MM100( aTmpObjPos.X() - pObj->GetAnchorPos().X() ),
TWIP_TO_MM100( aTmpObjPos.Y() - pObj->GetAnchorPos().Y() ) );
// determine difference between these positions according to the
// Writer coordinate system
const awt::Point aTranslateDiff( aPos.X - aObjPos.X,
aPos.Y - aObjPos.Y );
// apply translation difference to transformation matrix.
if ( aTranslateDiff.X != 0 || aTranslateDiff.Y != 0 )
{
// --> OD 2007-01-03 #i73079# - use correct matrix type
::basegfx::B2DHomMatrix aTempMatrix;
// <--
aTempMatrix.set(0, 0, aMatrix.Line1.Column1 );
aTempMatrix.set(0, 1, aMatrix.Line1.Column2 );
aTempMatrix.set(0, 2, aMatrix.Line1.Column3 );
aTempMatrix.set(1, 0, aMatrix.Line2.Column1 );
aTempMatrix.set(1, 1, aMatrix.Line2.Column2 );
aTempMatrix.set(1, 2, aMatrix.Line2.Column3 );
aTempMatrix.set(2, 0, aMatrix.Line3.Column1 );
aTempMatrix.set(2, 1, aMatrix.Line3.Column2 );
aTempMatrix.set(2, 2, aMatrix.Line3.Column3 );
// --> OD 2007-01-03 #i73079#
aTempMatrix.translate( aTranslateDiff.X, aTranslateDiff.Y );
// <--
aMatrix.Line1.Column1 = aTempMatrix.get(0, 0);
aMatrix.Line1.Column2 = aTempMatrix.get(0, 1);
aMatrix.Line1.Column3 = aTempMatrix.get(0, 2);
aMatrix.Line2.Column1 = aTempMatrix.get(1, 0);
aMatrix.Line2.Column2 = aTempMatrix.get(1, 1);
aMatrix.Line2.Column3 = aTempMatrix.get(1, 2);
aMatrix.Line3.Column1 = aTempMatrix.get(2, 0);
aMatrix.Line3.Column2 = aTempMatrix.get(2, 1);
aMatrix.Line3.Column3 = aTempMatrix.get(2, 2);
}
}
}
// <--
return aMatrix;
}
/** method to adjust the positioning properties
OD 2004-08-02 #i31698#
@author OD
*/
void SwXShape::_AdjustPositionProperties( const awt::Point _aPosition )
{
// handle x-position
// --> OD 2004-11-10 #i35007# - no handling of x-position, if drawing
// object is anchored as-character, because it doesn't make sense.
text::TextContentAnchorType eTextAnchorType =
text::TextContentAnchorType_AT_PARAGRAPH;
{
rtl::OUString sAnchorType( RTL_CONSTASCII_USTRINGPARAM( "AnchorType" ) );
uno::Any aAny = getPropertyValue( sAnchorType );
aAny >>= eTextAnchorType;
}
if ( eTextAnchorType != text::TextContentAnchorType_AS_CHARACTER )
// <--
{
// determine current x-postion
rtl::OUString aHoriPosPropStr( RTL_CONSTASCII_USTRINGPARAM("HoriOrientPosition") );
uno::Any aHoriPos( getPropertyValue( aHoriPosPropStr ) );
sal_Int32 dCurrX = 0;
aHoriPos >>= dCurrX;
// change x-position attribute, if needed
if ( dCurrX != _aPosition.X )
{
// adjust x-position orientation to text::HoriOrientation::NONE, if needed
// Note: has to be done before setting x-position attribute
rtl::OUString aHoriOrientPropStr( RTL_CONSTASCII_USTRINGPARAM("HoriOrient") );
uno::Any aHoriOrient( getPropertyValue( aHoriOrientPropStr ) );
sal_Int16 eHoriOrient;
if (aHoriOrient >>= eHoriOrient) // may be void
{
if ( eHoriOrient != text::HoriOrientation::NONE )
{
eHoriOrient = text::HoriOrientation::NONE;
aHoriOrient <<= eHoriOrient;
setPropertyValue( aHoriOrientPropStr, aHoriOrient );
}
}
// set x-position attribute
aHoriPos <<= _aPosition.X;
setPropertyValue( aHoriPosPropStr, aHoriPos );
}
}
// handle y-position
{
// determine current y-postion
rtl::OUString aVertPosPropStr( RTL_CONSTASCII_USTRINGPARAM("VertOrientPosition") );
uno::Any aVertPos( getPropertyValue( aVertPosPropStr ) );
sal_Int32 dCurrY = 0;
aVertPos >>= dCurrY;
// change y-position attribute, if needed
if ( dCurrY != _aPosition.Y )
{
// adjust y-position orientation to text::VertOrientation::NONE, if needed
// Note: has to be done before setting y-position attribute
rtl::OUString aVertOrientPropStr( RTL_CONSTASCII_USTRINGPARAM("VertOrient") );
uno::Any aVertOrient( getPropertyValue( aVertOrientPropStr ) );
sal_Int16 eVertOrient;
if (aVertOrient >>= eVertOrient) // may be void
{
if ( eVertOrient != text::VertOrientation::NONE )
{
eVertOrient = text::VertOrientation::NONE;
aVertOrient <<= eVertOrient;
setPropertyValue( aVertOrientPropStr, aVertOrient );
}
}
// set y-position attribute
aVertPos <<= _aPosition.Y;
setPropertyValue( aVertPosPropStr, aVertPos );
}
}
}
/** method to convert start or end position of the drawing object to the
Writer specific position, which is the attribute position in layout direction
OD 2009-01-12 #i59051#
@author OD
*/
::com::sun::star::awt::Point SwXShape::_ConvertStartOrEndPosToLayoutDir(
const ::com::sun::star::awt::Point& aStartOrEndPos )
{
awt::Point aConvertedPos( aStartOrEndPos );
SvxShape* pSvxShape = GetSvxShape();
ASSERT( pSvxShape,
"<SwXShape::_ConvertStartOrEndPosToLayoutDir(..)> - no SvxShape found!")
if ( pSvxShape )
{
const SdrObject* pObj = pSvxShape->GetSdrObject();
ASSERT( pObj,
"<SwXShape::_ConvertStartOrEndPosToLayoutDir(..)> - no SdrObject found!")
if ( pObj )
{
// get position of object in Writer coordinate system.
awt::Point aPos( getPosition() );
// get position of object in Drawing layer coordinate system
const Point aTmpObjPos( pObj->GetSnapRect().TopLeft() );
const awt::Point aObjPos(
TWIP_TO_MM100( aTmpObjPos.X() - pObj->GetAnchorPos().X() ),
TWIP_TO_MM100( aTmpObjPos.Y() - pObj->GetAnchorPos().Y() ) );
// determine difference between these positions according to the
// Writer coordinate system
const awt::Point aTranslateDiff( aPos.X - aObjPos.X,
aPos.Y - aObjPos.Y );
// apply translation difference to transformation matrix.
if ( aTranslateDiff.X != 0 || aTranslateDiff.Y != 0 )
{
aConvertedPos.X = aConvertedPos.X + aTranslateDiff.X;
aConvertedPos.Y = aConvertedPos.Y + aTranslateDiff.Y;
}
}
}
return aConvertedPos;
}
::com::sun::star::drawing::PolyPolygonBezierCoords SwXShape::_ConvertPolyPolygonBezierToLayoutDir(
const ::com::sun::star::drawing::PolyPolygonBezierCoords& aPath )
{
drawing::PolyPolygonBezierCoords aConvertedPath( aPath );
SvxShape* pSvxShape = GetSvxShape();
ASSERT( pSvxShape,
"<SwXShape::_ConvertStartOrEndPosToLayoutDir(..)> - no SvxShape found!")
if ( pSvxShape )
{
const SdrObject* pObj = pSvxShape->GetSdrObject();
ASSERT( pObj,
"<SwXShape::_ConvertStartOrEndPosToLayoutDir(..)> - no SdrObject found!")
if ( pObj )
{
// get position of object in Writer coordinate system.
awt::Point aPos( getPosition() );
// get position of object in Drawing layer coordinate system
const Point aTmpObjPos( pObj->GetSnapRect().TopLeft() );
const awt::Point aObjPos(
TWIP_TO_MM100( aTmpObjPos.X() - pObj->GetAnchorPos().X() ),
TWIP_TO_MM100( aTmpObjPos.Y() - pObj->GetAnchorPos().Y() ) );
// determine difference between these positions according to the
// Writer coordinate system
const awt::Point aTranslateDiff( aPos.X - aObjPos.X,
aPos.Y - aObjPos.Y );
// apply translation difference to PolyPolygonBezier.
if ( aTranslateDiff.X != 0 || aTranslateDiff.Y != 0 )
{
const basegfx::B2DHomMatrix aMatrix(basegfx::tools::createTranslateB2DHomMatrix(
aTranslateDiff.X, aTranslateDiff.Y));
const sal_Int32 nOuterSequenceCount(aConvertedPath.Coordinates.getLength());
drawing::PointSequence* pInnerSequence = aConvertedPath.Coordinates.getArray();
for(sal_Int32 a(0); a < nOuterSequenceCount; a++)
{
const sal_Int32 nInnerSequenceCount(pInnerSequence->getLength());
awt::Point* pArray = pInnerSequence->getArray();
for(sal_Int32 b(0); b < nInnerSequenceCount; b++)
{
basegfx::B2DPoint aNewCoordinatePair(pArray->X, pArray->Y);
aNewCoordinatePair *= aMatrix;
pArray->X = basegfx::fround(aNewCoordinatePair.getX());
pArray->Y = basegfx::fround(aNewCoordinatePair.getY());
pArray++;
}
}
}
}
}
return aConvertedPath;
}
SwXGroupShape::SwXGroupShape(uno::Reference< XInterface > & xShape) :
SwXShape(xShape)
{
#ifdef DBG_UTIL
uno::Reference<XShapes> xShapes(xShapeAgg, uno::UNO_QUERY);
DBG_ASSERT(xShapes.is(), "no SvxShape found or shape is not a group shape");
#endif
}
SwXGroupShape::~SwXGroupShape()
{
}
uno::Any SwXGroupShape::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException)
{
uno::Any aRet;
if(rType == ::getCppuType((uno::Reference<XShapes>*)0))
aRet <<= uno::Reference<XShapes>(this);
else
aRet = SwXShape::queryInterface(rType);
return aRet;
}
void SwXGroupShape::acquire( ) throw()
{
SwXShape::acquire();
}
void SwXGroupShape::release( ) throw()
{
SwXShape::release();
}
void SwXGroupShape::add( const uno::Reference< XShape >& xShape ) throw (uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
SvxShape* pSvxShape = GetSvxShape();
SwFrmFmt* pFmt = GetFrmFmt();
if(pSvxShape && pFmt)
{
uno::Reference<XShapes> xShapes;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XShapes>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xShapes;
}
if(xShapes.is())
xShapes->add(xShape);
else
throw uno::RuntimeException();
uno::Reference<lang::XUnoTunnel> xTunnel(xShape, uno::UNO_QUERY);
SwXShape* pSwShape = 0;
if(xShape.is())
pSwShape = reinterpret_cast< SwXShape * >(
sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SwXShape::getUnoTunnelId()) ));
if(pSwShape && pSwShape->m_bDescriptor)
{
SvxShape* pAddShape = reinterpret_cast< SvxShape * >(
sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SvxShape::getUnoTunnelId()) ));
if(pAddShape)
{
SdrObject* pObj = pAddShape->GetSdrObject();
if(pObj)
{
SwDoc* pDoc = pFmt->GetDoc();
// OD 25.06.2003 #108784# - set layer of new drawing
// object to corresponding invisible layer.
if( FmFormInventor != pObj->GetObjInventor())
{
pObj->SetLayer( pSwShape->pImpl->GetOpaque()
? pDoc->GetInvisibleHeavenId()
: pDoc->GetInvisibleHellId() );
}
else
{
pObj->SetLayer(pDoc->GetInvisibleControlsId());
}
}
}
pSwShape->m_bDescriptor = sal_False;
//add the group member to the format of the group
SwFrmFmt* pShapeFmt = ::FindFrmFmt( pSvxShape->GetSdrObject() );
if(pShapeFmt)
pFmt->Add(pSwShape);
}
}
else
throw uno::RuntimeException();
}
void SwXGroupShape::remove( const uno::Reference< XShape >& xShape ) throw (uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference<XShapes> xShapes;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XShapes>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xShapes;
}
if(!xShapes.is())
throw uno::RuntimeException();
xShapes->remove(xShape);
}
sal_Int32 SwXGroupShape::getCount(void) throw( uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference<XIndexAccess> xAcc;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XIndexAccess>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xAcc;
}
if(!xAcc.is())
throw uno::RuntimeException();
return xAcc->getCount();
}
uno::Any SwXGroupShape::getByIndex(sal_Int32 nIndex)
throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException,
uno::RuntimeException )
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference<XIndexAccess> xAcc;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XIndexAccess>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xAcc;
}
if(!xAcc.is())
throw uno::RuntimeException();
return xAcc->getByIndex(nIndex);
}
uno::Type SwXGroupShape::getElementType( ) throw(uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference<XIndexAccess> xAcc;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XIndexAccess>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xAcc;
}
if(!xAcc.is())
throw uno::RuntimeException();
return xAcc->getElementType();
}
sal_Bool SwXGroupShape::hasElements( ) throw(uno::RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
uno::Reference<XIndexAccess> xAcc;
if( xShapeAgg.is() )
{
const uno::Type& rType = ::getCppuType((uno::Reference<XIndexAccess>*)0 );
uno::Any aAgg = xShapeAgg->queryAggregation( rType );
aAgg >>= xAcc;
}
if(!xAcc.is())
throw uno::RuntimeException();
return xAcc->hasElements();
}