Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / core / layout / atrfrm.cxx
blob: 35f25fe187bb337c921ccbbcee1796801bc36e89 [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 <hintids.hxx>
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/HorizontalAdjust.hpp>
#include <com/sun/star/text/DocumentStatistic.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/HoriOrientationFormat.hpp>
#include <com/sun/star/text/NotePrintMode.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <com/sun/star/text/VertOrientationFormat.hpp>
#include <com/sun/star/text/WrapTextMode.hpp>
#include <com/sun/star/text/XTextFrame.hpp>
#include <com/sun/star/text/TextContentAnchorType.hpp>
#include <com/sun/star/text/InvalidTextContentException.hpp>
#include <com/sun/star/container/XIndexContainer.hpp>
#include <com/sun/star/text/TextGridMode.hpp>
#include <com/sun/star/awt/Size.hpp>
#include <svtools/unoimap.hxx>
#include <svtools/unoevent.hxx>
#include <basic/sbxvar.hxx>
#include <svtools/imap.hxx>
#include <svtools/imapobj.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdpage.hxx>
#include <unosett.hxx>
#include <unostyle.hxx>
#include <fmtclds.hxx>
#include <fmtornt.hxx>
#include <fmthdft.hxx>
#include <fmtpdsc.hxx>
#include <fmtcntnt.hxx>
#include <fmtfsize.hxx>
#include <fmtfordr.hxx>
#include <fmtsrnd.hxx>
#include <fmtanchr.hxx>
#include <fmtlsplt.hxx>
#include <fmtrowsplt.hxx>
#include <fmtftntx.hxx>
#include <fmteiro.hxx>
#include <fmturl.hxx>
#include <fmtcnct.hxx>
#include <node.hxx>
#include <section.hxx>
#include <fmtline.hxx>
#include <tgrditem.hxx>
#include <hfspacingitem.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <pagefrm.hxx>
#include <rootfrm.hxx>
#include <cntfrm.hxx>
#include <crsrsh.hxx>
#include <pam.hxx>
#include <dflyobj.hxx>
#include <dcontact.hxx>
#include <flyfrm.hxx>
#include <frmtool.hxx>
#include <flyfrms.hxx>
#include <pagedesc.hxx>
#include <grfatr.hxx>
#include <ndnotxt.hxx>
#include <docary.hxx>
#include <node2lay.hxx>
#include <fmtclbl.hxx>
#include <swunohelper.hxx>
#include <unoframe.hxx>
#include <unotextbodyhf.hxx>
#include <SwStyleNameMapper.hxx>
#include <editeng/brshitem.hxx>
#include <svtools/grfmgr.hxx>
#include <cmdid.h>
#include <unomid.h>
#include <comcore.hrc>
#include <svx/svdundo.hxx> // #111827#
#include <sortedobjs.hxx>
#include <HandleAnchorNodeChg.hxx>
#include <svl/cjkoptions.hxx>
#include <switerator.hxx>
#include <pagedeschint.hxx>
using namespace ::com::sun::star;
using ::rtl::OUString;
SV_IMPL_PTRARR(SwColumns,SwColumn*)
TYPEINIT1(SwFmtVertOrient, SfxPoolItem);
TYPEINIT1(SwFmtHoriOrient, SfxPoolItem);
TYPEINIT2(SwFmtHeader, SfxPoolItem, SwClient );
TYPEINIT2(SwFmtFooter, SfxPoolItem, SwClient );
TYPEINIT2(SwFmtPageDesc, SfxPoolItem, SwClient );
TYPEINIT1_AUTOFACTORY(SwFmtLineNumber, SfxPoolItem);
/* -----------------19.05.98 09:26-------------------
* Umwandlung fuer QueryValue
* --------------------------------------------------*/
sal_Int16 lcl_RelToINT(sal_Int16 eRelation)
{
sal_Int16 nRet = text::RelOrientation::FRAME;
switch(eRelation)
{
case text::RelOrientation::PRINT_AREA: nRet = text::RelOrientation::PRINT_AREA; break;
case text::RelOrientation::CHAR: nRet = text::RelOrientation::CHAR; break;
case text::RelOrientation::PAGE_LEFT: nRet = text::RelOrientation::PAGE_LEFT; break;
case text::RelOrientation::PAGE_RIGHT: nRet = text::RelOrientation::PAGE_RIGHT; break;
case text::RelOrientation::FRAME_LEFT: nRet = text::RelOrientation::FRAME_LEFT; break;
case text::RelOrientation::FRAME_RIGHT: nRet = text::RelOrientation::FRAME_RIGHT; break;
case text::RelOrientation::PAGE_FRAME: nRet = text::RelOrientation::PAGE_FRAME; break;
case text::RelOrientation::PAGE_PRINT_AREA: nRet = text::RelOrientation::PAGE_PRINT_AREA; break;
// OD 13.11.2003 #i22341#
case text::RelOrientation::TEXT_LINE: nRet = text::RelOrientation::TEXT_LINE; break;
default: break;
}
return nRet;
}
sal_Int16 lcl_IntToRelation(const uno::Any& rVal)
{
sal_Int16 eRet = text::RelOrientation::FRAME;
sal_Int16 nVal = 0;
rVal >>= nVal;
switch(nVal)
{
case text::RelOrientation::PRINT_AREA: eRet = text::RelOrientation::PRINT_AREA ; break;
case text::RelOrientation::CHAR: eRet = text::RelOrientation::CHAR ; break;
case text::RelOrientation::PAGE_LEFT: eRet = text::RelOrientation::PAGE_LEFT ; break;
case text::RelOrientation::PAGE_RIGHT: eRet = text::RelOrientation::PAGE_RIGHT ; break;
case text::RelOrientation::FRAME_LEFT: eRet = text::RelOrientation::FRAME_LEFT ; break;
case text::RelOrientation::FRAME_RIGHT: eRet = text::RelOrientation::FRAME_RIGHT ; break;
case text::RelOrientation::PAGE_FRAME: eRet = text::RelOrientation::PAGE_FRAME ; break;
case text::RelOrientation::PAGE_PRINT_AREA: eRet = text::RelOrientation::PAGE_PRINT_AREA ; break;
// OD 13.11.2003 #i22341#
case text::RelOrientation::TEXT_LINE: eRet = text::RelOrientation::TEXT_LINE; break;
}
return eRet;
}
void DelHFFormat( SwClient *pToRemove, SwFrmFmt *pFmt )
{
//Wenn der Client der letzte ist der das Format benutzt, so muss dieses
//vernichtet werden. Zuvor muss jedoch ggf. die Inhaltssection vernichtet
//werden.
SwDoc* pDoc = pFmt->GetDoc();
pFmt->Remove( pToRemove );
if( pDoc->IsInDtor() )
{
delete pFmt;
return;
}
//Nur noch Frms angemeldet?
sal_Bool bDel = sal_True;
{
// Klammer, weil im DTOR SwClientIter das Flag bTreeChg zurueck
// gesetzt wird. Unguenstig, wenn das Format vorher zerstoert wird.
SwClientIter aIter( *pFmt ); // TODO
SwClient *pLast = aIter.GoStart();
if( pLast )
do {
bDel = pLast->IsA( TYPE(SwFrm) )
|| SwXHeadFootText::IsXHeadFootText(pLast);
} while( bDel && 0 != ( pLast = ++aIter ));
}
if ( bDel )
{
//Wenn in einem der Nodes noch ein Crsr angemeldet ist, muss das
//ParkCrsr einer (beliebigen) Shell gerufen werden.
SwFmtCntnt& rCnt = (SwFmtCntnt&)pFmt->GetCntnt();
if ( rCnt.GetCntntIdx() )
{
SwNode *pNode = 0;
{
// --> OD 2008-10-07 #i92993#
// Begin with start node of page header/footer to assure that
// complete content is checked for cursors and the complete content
// is deleted on below made method call <pDoc->DeleteSection(pNode)>
// SwNodeIndex aIdx( *rCnt.GetCntntIdx(), 1 );
SwNodeIndex aIdx( *rCnt.GetCntntIdx(), 0 );
// <--
//Wenn in einem der Nodes noch ein Crsr angemeldet ist, muss das
//ParkCrsr einer (beliebigen) Shell gerufen werden.
pNode = & aIdx.GetNode();
sal_uInt32 nEnd = pNode->EndOfSectionIndex();
while ( aIdx < nEnd )
{
if ( pNode->IsCntntNode() &&
((SwCntntNode*)pNode)->GetDepends() )
{
SwCrsrShell *pShell = SwIterator<SwCrsrShell,SwCntntNode>::FirstElement( *(SwCntntNode*)pNode );
if( pShell )
{
pShell->ParkCrsr( aIdx );
aIdx = nEnd-1;
}
}
aIdx++;
pNode = & aIdx.GetNode();
}
}
rCnt.SetNewCntntIdx( (const SwNodeIndex*)0 );
// beim Loeschen von Header/Footer-Formaten IMMER das Undo
// abschalten! (Bug 31069)
::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
ASSERT( pNode, "Ein grosses Problem." );
pDoc->DeleteSection( pNode );
}
delete pFmt;
}
}
// class SwFmtFrmSize
// Implementierung teilweise inline im hxx
SwFmtFrmSize::SwFmtFrmSize( SwFrmSize eSize, SwTwips nWidth, SwTwips nHeight )
: SfxPoolItem( RES_FRM_SIZE ),
aSize( nWidth, nHeight ),
eFrmHeightType( eSize ),
eFrmWidthType( ATT_FIX_SIZE )
{
nWidthPercent = nHeightPercent = 0;
}
SwFmtFrmSize& SwFmtFrmSize::operator=( const SwFmtFrmSize& rCpy )
{
aSize = rCpy.GetSize();
eFrmHeightType = rCpy.GetHeightSizeType();
eFrmWidthType = rCpy.GetWidthSizeType();
nHeightPercent = rCpy.GetHeightPercent();
nWidthPercent = rCpy.GetWidthPercent();
return *this;
}
int SwFmtFrmSize::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return( eFrmHeightType == ((SwFmtFrmSize&)rAttr).eFrmHeightType &&
eFrmWidthType == ((SwFmtFrmSize&)rAttr).eFrmWidthType &&
aSize == ((SwFmtFrmSize&)rAttr).GetSize()&&
nWidthPercent == ((SwFmtFrmSize&)rAttr).GetWidthPercent() &&
nHeightPercent == ((SwFmtFrmSize&)rAttr).GetHeightPercent() );
}
SfxPoolItem* SwFmtFrmSize::Clone( SfxItemPool* ) const
{
return new SwFmtFrmSize( *this );
}
/* -----------------24.04.98 11:36-------------------
*
* --------------------------------------------------*/
sal_Bool SwFmtFrmSize::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
switch ( nMemberId )
{
case MID_FRMSIZE_SIZE:
{
awt::Size aTmp;
aTmp.Height = TWIP_TO_MM100(aSize.Height());
aTmp.Width = TWIP_TO_MM100(aSize.Width());
rVal.setValue(&aTmp, ::getCppuType((const awt::Size*)0));
}
break;
case MID_FRMSIZE_REL_HEIGHT:
rVal <<= (sal_Int16)(GetHeightPercent() != 0xFF ? GetHeightPercent() : 0);
break;
case MID_FRMSIZE_REL_WIDTH:
rVal <<= (sal_Int16)(GetWidthPercent() != 0xFF ? GetWidthPercent() : 0);
break;
case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
{
sal_Bool bTmp = 0xFF == GetHeightPercent();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
{
sal_Bool bTmp = 0xFF == GetWidthPercent();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_FRMSIZE_WIDTH :
rVal <<= (sal_Int32)TWIP_TO_MM100(aSize.Width());
break;
case MID_FRMSIZE_HEIGHT:
// #95848# returned size should never be zero.
// (there was a bug that allowed for setting height to 0.
// Thus there some documents existing with that not allowed
// attribut value which may cause problems on import.)
rVal <<= (sal_Int32)TWIP_TO_MM100(aSize.Height() < MINLAY ? MINLAY : aSize.Height() );
break;
case MID_FRMSIZE_SIZE_TYPE:
rVal <<= (sal_Int16)GetHeightSizeType();
break;
case MID_FRMSIZE_IS_AUTO_HEIGHT:
{
sal_Bool bTmp = ATT_FIX_SIZE != GetHeightSizeType();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_FRMSIZE_WIDTH_TYPE:
rVal <<= (sal_Int16)GetWidthSizeType();
break;
}
return sal_True;
}
/* -----------------24.04.98 11:36-------------------
*
* --------------------------------------------------*/
sal_Bool SwFmtFrmSize::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_FRMSIZE_SIZE:
{
awt::Size aVal;
if(!(rVal >>= aVal))
bRet = sal_False;
else
{
Size aTmp(aVal.Width, aVal.Height);
if(bConvert)
{
aTmp.Height() = MM100_TO_TWIP(aTmp.Height());
aTmp.Width() = MM100_TO_TWIP(aTmp.Width());
}
if(aTmp.Height() && aTmp.Width())
aSize = aTmp;
else
bRet = sal_False;
}
}
break;
case MID_FRMSIZE_REL_HEIGHT:
{
sal_Int16 nSet = 0;
rVal >>= nSet;
if(nSet >= 0 && nSet <= 0xfe)
SetHeightPercent((sal_uInt8)nSet);
else
bRet = sal_False;
}
break;
case MID_FRMSIZE_REL_WIDTH:
{
sal_Int16 nSet = 0;
rVal >>= nSet;
if(nSet >= 0 && nSet <= 0xfe)
SetWidthPercent((sal_uInt8)nSet);
else
bRet = sal_False;
}
break;
case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
{
sal_Bool bSet = *(sal_Bool*)rVal.getValue();
if(bSet)
SetHeightPercent(0xff);
else if( 0xff == GetHeightPercent() )
SetHeightPercent( 0 );
}
break;
case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
{
sal_Bool bSet = *(sal_Bool*)rVal.getValue();
if(bSet)
SetWidthPercent(0xff);
else if( 0xff == GetWidthPercent() )
SetWidthPercent(0);
}
break;
case MID_FRMSIZE_WIDTH :
{
sal_Int32 nWd = 0;
if(rVal >>= nWd)
{
if(bConvert)
nWd = MM100_TO_TWIP(nWd);
if(nWd < MINLAY)
nWd = MINLAY;
aSize.Width() = nWd;
}
else
bRet = sal_False;
}
break;
case MID_FRMSIZE_HEIGHT:
{
sal_Int32 nHg = 0;
if(rVal >>= nHg)
{
if(bConvert)
nHg = MM100_TO_TWIP(nHg);
if(nHg < MINLAY)
nHg = MINLAY;
aSize.Height() = nHg;
}
else
bRet = sal_False;
}
break;
case MID_FRMSIZE_SIZE_TYPE:
{
sal_Int16 nType = 0;
if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
{
SetHeightSizeType((SwFrmSize)nType);
}
else
bRet = sal_False;
}
break;
case MID_FRMSIZE_IS_AUTO_HEIGHT:
{
sal_Bool bSet = *(sal_Bool*)rVal.getValue();
SetHeightSizeType(bSet ? ATT_VAR_SIZE : ATT_FIX_SIZE);
}
break;
case MID_FRMSIZE_WIDTH_TYPE:
{
sal_Int16 nType = 0;
if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
{
SetWidthSizeType((SwFrmSize)nType);
}
else
bRet = sal_False;
}
break;
default:
bRet = sal_False;
}
return bRet;
}
// class SwFmtFillOrder
// Implementierung teilweise inline im hxx
SwFmtFillOrder::SwFmtFillOrder( SwFillOrder nFO )
: SfxEnumItem( RES_FILL_ORDER, sal_uInt16(nFO) )
{}
SfxPoolItem* SwFmtFillOrder::Clone( SfxItemPool* ) const
{
return new SwFmtFillOrder( GetFillOrder() );
}
sal_uInt16 SwFmtFillOrder::GetValueCount() const
{
return SW_FILL_ORDER_END - SW_FILL_ORDER_BEGIN;
}
// class SwFmtHeader
// Implementierung teilweise inline im hxx
SwFmtHeader::SwFmtHeader( SwFrmFmt *pHeaderFmt )
: SfxPoolItem( RES_HEADER ),
SwClient( pHeaderFmt ),
bActive( pHeaderFmt ? sal_True : sal_False )
{
}
SwFmtHeader::SwFmtHeader( const SwFmtHeader &rCpy )
: SfxPoolItem( RES_HEADER ),
SwClient( (SwModify*)rCpy.GetRegisteredIn() ),
bActive( rCpy.IsActive() )
{
}
SwFmtHeader::SwFmtHeader( sal_Bool bOn )
: SfxPoolItem( RES_HEADER ),
SwClient( 0 ),
bActive( bOn )
{
}
SwFmtHeader::~SwFmtHeader()
{
if ( GetHeaderFmt() )
DelHFFormat( this, GetHeaderFmt() );
}
int SwFmtHeader::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( GetRegisteredIn() == ((SwFmtHeader&)rAttr).GetRegisteredIn() &&
bActive == ((SwFmtHeader&)rAttr).IsActive() );
}
SfxPoolItem* SwFmtHeader::Clone( SfxItemPool* ) const
{
return new SwFmtHeader( *this );
}
void SwFmtHeader::RegisterToFormat( SwFmt& rFmt )
{
rFmt.Add(this);
}
// class SwFmtFooter
// Implementierung teilweise inline im hxx
SwFmtFooter::SwFmtFooter( SwFrmFmt *pFooterFmt )
: SfxPoolItem( RES_FOOTER ),
SwClient( pFooterFmt ),
bActive( pFooterFmt ? sal_True : sal_False )
{
}
SwFmtFooter::SwFmtFooter( const SwFmtFooter &rCpy )
: SfxPoolItem( RES_FOOTER ),
SwClient( (SwModify*)rCpy.GetRegisteredIn() ),
bActive( rCpy.IsActive() )
{
}
SwFmtFooter::SwFmtFooter( sal_Bool bOn )
: SfxPoolItem( RES_FOOTER ),
SwClient( 0 ),
bActive( bOn )
{
}
SwFmtFooter::~SwFmtFooter()
{
if ( GetFooterFmt() )
DelHFFormat( this, GetFooterFmt() );
}
void SwFmtFooter::RegisterToFormat( SwFmt& rFmt )
{
rFmt.Add(this);
}
int SwFmtFooter::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( GetRegisteredIn() == ((SwFmtFooter&)rAttr).GetRegisteredIn() &&
bActive == ((SwFmtFooter&)rAttr).IsActive() );
}
SfxPoolItem* SwFmtFooter::Clone( SfxItemPool* ) const
{
return new SwFmtFooter( *this );
}
// class SwFmtCntnt
// Implementierung teilweise inline im hxx
SwFmtCntnt::SwFmtCntnt( const SwFmtCntnt &rCpy )
: SfxPoolItem( RES_CNTNT )
{
pStartNode = rCpy.GetCntntIdx() ?
new SwNodeIndex( *rCpy.GetCntntIdx() ) : 0;
}
SwFmtCntnt::SwFmtCntnt( const SwStartNode *pStartNd )
: SfxPoolItem( RES_CNTNT )
{
pStartNode = pStartNd ? new SwNodeIndex( *pStartNd ) : 0;
}
SwFmtCntnt::~SwFmtCntnt()
{
delete pStartNode;
}
void SwFmtCntnt::SetNewCntntIdx( const SwNodeIndex *pIdx )
{
delete pStartNode;
pStartNode = pIdx ? new SwNodeIndex( *pIdx ) : 0;
}
int SwFmtCntnt::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
if( (long)pStartNode ^ (long)((SwFmtCntnt&)rAttr).pStartNode )
return 0;
if( pStartNode )
return ( *pStartNode == *((SwFmtCntnt&)rAttr).GetCntntIdx() );
return 1;
}
SfxPoolItem* SwFmtCntnt::Clone( SfxItemPool* ) const
{
return new SwFmtCntnt( *this );
}
// class SwFmtPageDesc
// Implementierung teilweise inline im hxx
SwFmtPageDesc::SwFmtPageDesc( const SwFmtPageDesc &rCpy )
: SfxPoolItem( RES_PAGEDESC ),
SwClient( (SwPageDesc*)rCpy.GetPageDesc() ),
nNumOffset( rCpy.nNumOffset ),
nDescNameIdx( rCpy.nDescNameIdx ),
pDefinedIn( 0 )
{
}
SwFmtPageDesc::SwFmtPageDesc( const SwPageDesc *pDesc )
: SfxPoolItem( RES_PAGEDESC ),
SwClient( (SwPageDesc*)pDesc ),
nNumOffset( 0 ),
nDescNameIdx( 0xFFFF ), // IDX_NO_VALUE
pDefinedIn( 0 )
{
}
SwFmtPageDesc::~SwFmtPageDesc() {}
bool SwFmtPageDesc::KnowsPageDesc() const
{
return (GetRegisteredIn() != 0);
}
int SwFmtPageDesc::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( pDefinedIn == ((SwFmtPageDesc&)rAttr).pDefinedIn ) &&
( nNumOffset == ((SwFmtPageDesc&)rAttr).nNumOffset ) &&
( GetPageDesc() == ((SwFmtPageDesc&)rAttr).GetPageDesc() );
}
SfxPoolItem* SwFmtPageDesc::Clone( SfxItemPool* ) const
{
return new SwFmtPageDesc( *this );
}
void SwFmtPageDesc::SwClientNotify( const SwModify&, const SfxHint& rHint )
{
const SwPageDescHint* pHint = dynamic_cast<const SwPageDescHint*>(&rHint);
if ( pHint )
{
// mba: shouldn't that be broadcasted also?
SwFmtPageDesc aDfltDesc( pHint->GetPageDesc() );
SwPageDesc* pDesc = pHint->GetPageDesc();
const SwModify* pMod = GetDefinedIn();
if ( pMod )
{
if( pMod->ISA( SwCntntNode ) )
((SwCntntNode*)pMod)->SetAttr( aDfltDesc );
else if( pMod->ISA( SwFmt ))
((SwFmt*)pMod)->SetFmtAttr( aDfltDesc );
else
{
DBG_ERROR( "What kind of SwModify is this?" );
RegisterToPageDesc( *pDesc );
}
}
else
// there could be an Undo-copy
RegisterToPageDesc( *pDesc );
}
}
void SwFmtPageDesc::RegisterToPageDesc( SwPageDesc& rDesc )
{
rDesc.Add( this );
}
void SwFmtPageDesc::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
{
if( !pDefinedIn )
return;
const sal_uInt16 nWhichId = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
switch( nWhichId )
{
case RES_OBJECTDYING:
//Der Pagedesc, bei dem ich angemeldet bin stirbt, ich trage
//mich also bei meinem Format aus.
//Dabei werden ich Deletet!!!
if( IS_TYPE( SwFmt, pDefinedIn ))
#ifdef DBG_UTIL
{
sal_Bool bDel = ((SwFmt*)pDefinedIn)->ResetFmtAttr( RES_PAGEDESC );
ASSERT( bDel, ";-) FmtPageDesc nicht zerstoert." );
}
#else
((SwFmt*)pDefinedIn)->ResetFmtAttr( RES_PAGEDESC );
#endif
else if( IS_TYPE( SwCntntNode, pDefinedIn ))
#ifdef DBG_UTIL
{
sal_Bool bDel = ((SwCntntNode*)pDefinedIn)->ResetAttr( RES_PAGEDESC );
ASSERT( bDel, ";-) FmtPageDesc nicht zerstoert." );
}
#else
((SwCntntNode*)pDefinedIn)->ResetAttr( RES_PAGEDESC );
#endif
break;
default:
/* do nothing */;
}
}
sal_Bool SwFmtPageDesc::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_PAGEDESC_PAGENUMOFFSET:
rVal <<= (sal_Int16)GetNumOffset();
break;
case MID_PAGEDESC_PAGEDESCNAME:
{
const SwPageDesc* pDesc = GetPageDesc();
if( pDesc )
{
String aString;
SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True );
rVal <<= OUString( aString );
}
else
rVal.clear();
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtPageDesc::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_PAGEDESC_PAGENUMOFFSET:
{
sal_Int16 nOffset = 0;
if(rVal >>= nOffset)
SetNumOffset( nOffset );
else
bRet = sal_False;
}
break;
case MID_PAGEDESC_PAGEDESCNAME:
/* geht nicht, weil das Attribut eigentlich nicht den Namen
* sondern einen Pointer auf den PageDesc braucht (ist Client davon).
* Der Pointer waere aber ueber den Namen nur vom Dokument zu erfragen.
*/
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwFmtCol
// Implementierung teilweise inline im hxx
SwColumn::SwColumn() :
nWish ( 0 ),
nUpper( 0 ),
nLower( 0 ),
nLeft ( 0 ),
nRight( 0 )
{
}
sal_Bool SwColumn::operator==( const SwColumn &rCmp )
{
return (nWish == rCmp.GetWishWidth() &&
GetLeft() == rCmp.GetLeft() &&
GetRight() == rCmp.GetRight() &&
GetUpper() == rCmp.GetUpper() &&
GetLower() == rCmp.GetLower()) ? sal_True : sal_False;
}
SwFmtCol::SwFmtCol( const SwFmtCol& rCpy )
: SfxPoolItem( RES_COL ),
nLineWidth( rCpy.nLineWidth),
aLineColor( rCpy.aLineColor),
nLineHeight( rCpy.GetLineHeight() ),
eAdj( rCpy.GetLineAdj() ),
aColumns( (sal_Int8)rCpy.GetNumCols(), 1 ),
nWidth( rCpy.GetWishWidth() ),
aWidthAdjustValue( rCpy.aWidthAdjustValue ),
bOrtho( rCpy.IsOrtho() )
{
for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
{
SwColumn *pCol = new SwColumn( *rCpy.GetColumns()[i] );
aColumns.Insert( pCol, aColumns.Count() );
}
}
SwFmtCol::~SwFmtCol() {}
SwFmtCol& SwFmtCol::operator=( const SwFmtCol& rCpy )
{
nLineWidth = rCpy.nLineWidth;
aLineColor = rCpy.aLineColor;
nLineHeight = rCpy.GetLineHeight();
eAdj = rCpy.GetLineAdj();
nWidth = rCpy.GetWishWidth();
bOrtho = rCpy.IsOrtho();
aWidthAdjustValue = rCpy.aWidthAdjustValue;
if ( aColumns.Count() )
aColumns.DeleteAndDestroy( 0, aColumns.Count() );
for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
{
SwColumn *pCol = new SwColumn( *rCpy.GetColumns()[i] );
aColumns.Insert( pCol, aColumns.Count() );
}
return *this;
}
SwFmtCol::SwFmtCol()
: SfxPoolItem( RES_COL ),
nLineWidth(0),
nLineHeight( 100 ),
eAdj( COLADJ_NONE ),
nWidth( USHRT_MAX ),
aWidthAdjustValue( 0 ),
bOrtho( sal_True )
{
}
int SwFmtCol::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
const SwFmtCol &rCmp = (const SwFmtCol&)rAttr;
if( !(nLineWidth == rCmp.nLineWidth &&
aLineColor == rCmp.aLineColor &&
nLineHeight == rCmp.GetLineHeight() &&
eAdj == rCmp.GetLineAdj() &&
nWidth == rCmp.GetWishWidth() &&
bOrtho == rCmp.IsOrtho() &&
aColumns.Count() == rCmp.GetNumCols() &&
aWidthAdjustValue == rCmp.GetAdjustValue()
) )
return 0;
for ( sal_uInt16 i = 0; i < aColumns.Count(); ++i )
if ( !(*aColumns[i] == *rCmp.GetColumns()[i]) )
return 0;
return 1;
}
SfxPoolItem* SwFmtCol::Clone( SfxItemPool* ) const
{
return new SwFmtCol( *this );
}
sal_uInt16 SwFmtCol::GetGutterWidth( sal_Bool bMin ) const
{
sal_uInt16 nRet = 0;
if ( aColumns.Count() == 2 )
nRet = aColumns[0]->GetRight() + aColumns[1]->GetLeft();
else if ( aColumns.Count() > 2 )
{
sal_Bool bSet = sal_False;
for ( sal_uInt16 i = 1; i < aColumns.Count()-1; ++i )
{
const sal_uInt16 nTmp = aColumns[i]->GetRight() + aColumns[i+1]->GetLeft();
if ( bSet )
{
if ( nTmp != nRet )
{
if ( !bMin )
return USHRT_MAX;
if ( nRet > nTmp )
nRet = nTmp;
}
}
else
{ bSet = sal_True;
nRet = nTmp;
}
}
}
return nRet;
}
void SwFmtCol::SetGutterWidth( sal_uInt16 nNew, sal_uInt16 nAct )
{
if ( bOrtho )
Calc( nNew, nAct );
else
{
sal_uInt16 nHalf = nNew / 2;
for ( sal_uInt16 i = 0; i < aColumns.Count(); ++i )
{ SwColumn *pCol = aColumns[i];
pCol->SetLeft ( nHalf );
pCol->SetRight( nHalf );
if ( i == 0 )
pCol->SetLeft( 0 );
else if ( i == (aColumns.Count() - 1) )
pCol->SetRight( 0 );
}
}
}
void SwFmtCol::Init( sal_uInt16 nNumCols, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
{
//Loeschen scheint hier auf den erste Blick vielleicht etwas zu heftig;
//anderfalls muessten allerdings alle Werte der verbleibenden SwColumn's
//initialisiert werden.
if ( aColumns.Count() )
aColumns.DeleteAndDestroy( 0, aColumns.Count() );
for ( sal_uInt16 i = 0; i < nNumCols; ++i )
{ SwColumn *pCol = new SwColumn;
aColumns.Insert( pCol, i );
}
bOrtho = sal_True;
nWidth = USHRT_MAX;
if( nNumCols )
Calc( nGutterWidth, nAct );
}
void SwFmtCol::SetOrtho( sal_Bool bNew, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
{
bOrtho = bNew;
if ( bNew && aColumns.Count() )
Calc( nGutterWidth, nAct );
}
sal_uInt16 SwFmtCol::CalcColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
{
ASSERT( nCol < aColumns.Count(), ":-( ColumnsArr ueberindiziert." );
if ( nWidth != nAct )
{
long nW = aColumns[nCol]->GetWishWidth();
nW *= nAct;
nW /= nWidth;
return sal_uInt16(nW);
}
else
return aColumns[nCol]->GetWishWidth();
}
sal_uInt16 SwFmtCol::CalcPrtColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
{
ASSERT( nCol < aColumns.Count(), ":-( ColumnsArr ueberindiziert." );
sal_uInt16 nRet = CalcColWidth( nCol, nAct );
SwColumn *pCol = aColumns[nCol];
nRet = nRet - pCol->GetLeft();
nRet = nRet - pCol->GetRight();
return nRet;
}
void SwFmtCol::Calc( sal_uInt16 nGutterWidth, sal_uInt16 nAct )
{
if(!GetNumCols())
return;
//Erstmal die Spalten mit der Aktuellen Breite einstellen, dann die
//Wunschbreite der Spalten anhand der Gesamtwunschbreite hochrechnen.
const sal_uInt16 nGutterHalf = nGutterWidth ? nGutterWidth / 2 : 0;
//Breite der PrtAreas ist Gesamtbreite - Zwischenraeume / Anzahl
const sal_uInt16 nPrtWidth =
(nAct - ((GetNumCols()-1) * nGutterWidth)) / GetNumCols();
sal_uInt16 nAvail = nAct;
//Die erste Spalte ist PrtBreite + (Zwischenraumbreite/2)
const sal_uInt16 nLeftWidth = nPrtWidth + nGutterHalf;
SwColumn *pCol = aColumns[0];
pCol->SetWishWidth( nLeftWidth );
pCol->SetRight( nGutterHalf );
pCol->SetLeft ( 0 );
nAvail = nAvail - nLeftWidth;
//Spalte 2 bis n-1 ist PrtBreite + Zwischenraumbreite
const sal_uInt16 nMidWidth = nPrtWidth + nGutterWidth;
sal_uInt16 i;
for ( i = 1; i < GetNumCols()-1; ++i )
{
pCol = aColumns[i];
pCol->SetWishWidth( nMidWidth );
pCol->SetLeft ( nGutterHalf );
pCol->SetRight( nGutterHalf );
nAvail = nAvail - nMidWidth;
}
//Die Letzte Spalte entspricht wieder der ersten, um Rundungsfehler
//auszugleichen wird der letzten Spalte alles zugeschlagen was die
//anderen nicht verbraucht haben.
pCol = aColumns[aColumns.Count()-1];
pCol->SetWishWidth( nAvail );
pCol->SetLeft ( nGutterHalf );
pCol->SetRight( 0 );
//Umrechnen der aktuellen Breiten in Wunschbreiten.
for ( i = 0; i < aColumns.Count(); ++i )
{
pCol = aColumns[i];
long nTmp = pCol->GetWishWidth();
nTmp *= GetWishWidth();
nTmp /= nAct;
pCol->SetWishWidth( sal_uInt16(nTmp) );
}
}
sal_Bool SwFmtCol::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
{
DBG_ERROR("not implemented");
}
else
{
uno::Reference< text::XTextColumns > xCols = new SwXTextColumns(*this);
rVal.setValue(&xCols, ::getCppuType((uno::Reference< text::XTextColumns>*)0));
}
return sal_True;
}
sal_Bool SwFmtCol::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_False;
if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
{
DBG_ERROR("not implemented");
}
else
{
uno::Reference< text::XTextColumns > xCols;
rVal >>= xCols;
if(xCols.is())
{
uno::Sequence<text::TextColumn> aSetColumns = xCols->getColumns();
const text::TextColumn* pArray = aSetColumns.getConstArray();
aColumns.DeleteAndDestroy(0, aColumns.Count());
//max. Count ist hier 64K - das kann das Array aber nicht
sal_uInt16 nCount = Min( (sal_uInt16)aSetColumns.getLength(),
(sal_uInt16) 0x3fff );
sal_uInt16 nWidthSum = 0;
// #101224# one column is no column
//
if(nCount > 1)
for(sal_uInt16 i = 0; i < nCount; i++)
{
SwColumn* pCol = new SwColumn;
pCol->SetWishWidth( static_cast<sal_uInt16>(pArray[i].Width) );
nWidthSum = static_cast<sal_uInt16>(nWidthSum + pArray[i].Width);
pCol->SetLeft ( static_cast<sal_uInt16>(MM100_TO_TWIP(pArray[i].LeftMargin)) );
pCol->SetRight( static_cast<sal_uInt16>(MM100_TO_TWIP(pArray[i].RightMargin)) );
aColumns.Insert(pCol, i);
}
bRet = sal_True;
nWidth = nWidthSum;
bOrtho = sal_False;
uno::Reference<lang::XUnoTunnel> xNumTunnel(xCols, uno::UNO_QUERY);
SwXTextColumns* pSwColums = 0;
if(xNumTunnel.is())
{
pSwColums = reinterpret_cast< SwXTextColumns * >(
sal::static_int_cast< sal_IntPtr >(
xNumTunnel->getSomething( SwXTextColumns::getUnoTunnelId() )));
}
if(pSwColums)
{
bOrtho = pSwColums->IsAutomaticWidth();
nLineWidth = pSwColums->GetSepLineWidth();
aLineColor.SetColor(pSwColums->GetSepLineColor());
nLineHeight = pSwColums->GetSepLineHeightRelative();
if(!pSwColums->GetSepLineIsOn())
eAdj = COLADJ_NONE;
else switch(pSwColums->GetSepLineVertAlign())
{
case 0: eAdj = COLADJ_TOP; break; //VerticalAlignment_TOP
case 1: eAdj = COLADJ_CENTER;break; //VerticalAlignment_MIDDLE
case 2: eAdj = COLADJ_BOTTOM;break; //VerticalAlignment_BOTTOM
default: ASSERT( !this, "unknown alignment" ); break;
}
}
}
}
return bRet;
}
// class SwFmtSurround
// Implementierung teilweise inline im hxx
SwFmtSurround::SwFmtSurround( SwSurround eFly ) :
SfxEnumItem( RES_SURROUND, sal_uInt16( eFly ) )
{
bAnchorOnly = bContour = bOutside = sal_False;
}
SwFmtSurround::SwFmtSurround( const SwFmtSurround &rCpy ) :
SfxEnumItem( RES_SURROUND, rCpy.GetValue() )
{
bAnchorOnly = rCpy.bAnchorOnly;
bContour = rCpy.bContour;
bOutside = rCpy.bOutside;
}
int SwFmtSurround::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( GetValue() == ((SwFmtSurround&)rAttr).GetValue() &&
bAnchorOnly== ((SwFmtSurround&)rAttr).bAnchorOnly &&
bContour== ((SwFmtSurround&)rAttr).bContour &&
bOutside== ((SwFmtSurround&)rAttr).bOutside );
}
SfxPoolItem* SwFmtSurround::Clone( SfxItemPool* ) const
{
return new SwFmtSurround( *this );
}
sal_uInt16 SwFmtSurround::GetValueCount() const
{
return SURROUND_END - SURROUND_BEGIN;
}
sal_Bool SwFmtSurround::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_SURROUND_SURROUNDTYPE:
rVal <<= (text::WrapTextMode)GetSurround();
break;
case MID_SURROUND_ANCHORONLY:
{
sal_Bool bTmp = IsAnchorOnly();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_SURROUND_CONTOUR:
{
sal_Bool bTmp = IsContour();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_SURROUND_CONTOUROUTSIDE:
{
sal_Bool bTmp = IsOutside();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtSurround::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_SURROUND_SURROUNDTYPE:
{
sal_Int32 eVal = SWUnoHelper::GetEnumAsInt32( rVal );
if( eVal >= 0 && eVal < (sal_Int16)SURROUND_END )
SetValue( static_cast<sal_uInt16>(eVal) );
else {
//exception
;
}
}
break;
case MID_SURROUND_ANCHORONLY:
SetAnchorOnly( *(sal_Bool*)rVal.getValue() );
break;
case MID_SURROUND_CONTOUR:
SetContour( *(sal_Bool*)rVal.getValue() );
break;
case MID_SURROUND_CONTOUROUTSIDE:
SetOutside( *(sal_Bool*)rVal.getValue() );
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwFmtVertOrient
// Implementierung teilweise inline im hxx
SwFmtVertOrient::SwFmtVertOrient( SwTwips nY, sal_Int16 eVert,
sal_Int16 eRel )
: SfxPoolItem( RES_VERT_ORIENT ),
nYPos( nY ),
eOrient( eVert ),
eRelation( eRel )
{}
int SwFmtVertOrient::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( nYPos == ((SwFmtVertOrient&)rAttr).nYPos &&
eOrient == ((SwFmtVertOrient&)rAttr).eOrient &&
eRelation == ((SwFmtVertOrient&)rAttr).eRelation );
}
SfxPoolItem* SwFmtVertOrient::Clone( SfxItemPool* ) const
{
return new SwFmtVertOrient( nYPos, eOrient, eRelation );
}
sal_Bool SwFmtVertOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_VERTORIENT_ORIENT:
{
sal_Int16 nRet = text::VertOrientation::NONE;
switch( eOrient )
{
case text::VertOrientation::TOP : nRet = text::VertOrientation::TOP ;break;
case text::VertOrientation::CENTER : nRet = text::VertOrientation::CENTER ;break;
case text::VertOrientation::BOTTOM : nRet = text::VertOrientation::BOTTOM ;break;
case text::VertOrientation::CHAR_TOP : nRet = text::VertOrientation::CHAR_TOP ;break;
case text::VertOrientation::CHAR_CENTER: nRet = text::VertOrientation::CHAR_CENTER;break;
case text::VertOrientation::CHAR_BOTTOM: nRet = text::VertOrientation::CHAR_BOTTOM;break;
case text::VertOrientation::LINE_TOP : nRet = text::VertOrientation::LINE_TOP ;break;
case text::VertOrientation::LINE_CENTER: nRet = text::VertOrientation::LINE_CENTER;break;
case text::VertOrientation::LINE_BOTTOM: nRet = text::VertOrientation::LINE_BOTTOM;break;
default: break;
}
rVal <<= nRet;
}
break;
case MID_VERTORIENT_RELATION:
rVal <<= lcl_RelToINT(eRelation);
break;
case MID_VERTORIENT_POSITION:
rVal <<= (sal_Int32)TWIP_TO_MM100(GetPos());
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtVertOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_VERTORIENT_ORIENT:
{
sal_uInt16 nVal = 0;
rVal >>= nVal;
switch( nVal )
{
case text::VertOrientation::NONE: eOrient = text::VertOrientation::NONE; break;
case text::VertOrientation::TOP : eOrient = text::VertOrientation::TOP; break;
case text::VertOrientation::CENTER : eOrient = text::VertOrientation::CENTER; break;
case text::VertOrientation::BOTTOM : eOrient = text::VertOrientation::BOTTOM; break;
case text::VertOrientation::CHAR_TOP : eOrient = text::VertOrientation::CHAR_TOP; break;
case text::VertOrientation::CHAR_CENTER: eOrient = text::VertOrientation::CHAR_CENTER;break;
case text::VertOrientation::CHAR_BOTTOM: eOrient = text::VertOrientation::CHAR_BOTTOM;break;
case text::VertOrientation::LINE_TOP : eOrient = text::VertOrientation::LINE_TOP; break;
case text::VertOrientation::LINE_CENTER: eOrient = text::VertOrientation::LINE_CENTER;break;
case text::VertOrientation::LINE_BOTTOM: eOrient = text::VertOrientation::LINE_BOTTOM;break;
}
}
break;
case MID_VERTORIENT_RELATION:
{
eRelation = lcl_IntToRelation(rVal);
}
break;
case MID_VERTORIENT_POSITION:
{
sal_Int32 nVal = 0;
rVal >>= nVal;
if(bConvert)
nVal = MM100_TO_TWIP(nVal);
SetPos( nVal );
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwFmtHoriOrient
// Implementierung teilweise inline im hxx
SwFmtHoriOrient::SwFmtHoriOrient( SwTwips nX, sal_Int16 eHori,
sal_Int16 eRel, sal_Bool bPos )
: SfxPoolItem( RES_HORI_ORIENT ),
nXPos( nX ),
eOrient( eHori ),
eRelation( eRel ),
bPosToggle( bPos )
{}
int SwFmtHoriOrient::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return ( nXPos == ((SwFmtHoriOrient&)rAttr).nXPos &&
eOrient == ((SwFmtHoriOrient&)rAttr).eOrient &&
eRelation == ((SwFmtHoriOrient&)rAttr).eRelation &&
bPosToggle == ((SwFmtHoriOrient&)rAttr).bPosToggle );
}
SfxPoolItem* SwFmtHoriOrient::Clone( SfxItemPool* ) const
{
return new SwFmtHoriOrient( nXPos, eOrient, eRelation, bPosToggle );
}
sal_Bool SwFmtHoriOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_HORIORIENT_ORIENT:
{
sal_Int16 nRet = text::HoriOrientation::NONE;
switch( eOrient )
{
case text::HoriOrientation::RIGHT: nRet = text::HoriOrientation::RIGHT; break;
case text::HoriOrientation::CENTER : nRet = text::HoriOrientation::CENTER; break;
case text::HoriOrientation::LEFT : nRet = text::HoriOrientation::LEFT; break;
case text::HoriOrientation::INSIDE : nRet = text::HoriOrientation::INSIDE; break;
case text::HoriOrientation::OUTSIDE: nRet = text::HoriOrientation::OUTSIDE; break;
case text::HoriOrientation::FULL: nRet = text::HoriOrientation::FULL; break;
case text::HoriOrientation::LEFT_AND_WIDTH :
nRet = text::HoriOrientation::LEFT_AND_WIDTH;
break;
default:
break;
}
rVal <<= nRet;
}
break;
case MID_HORIORIENT_RELATION:
rVal <<= lcl_RelToINT(eRelation);
break;
case MID_HORIORIENT_POSITION:
rVal <<= (sal_Int32)TWIP_TO_MM100(GetPos());
break;
case MID_HORIORIENT_PAGETOGGLE:
{
sal_Bool bTmp = IsPosToggle();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtHoriOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_HORIORIENT_ORIENT:
{
sal_Int16 nVal = 0;
rVal >>= nVal;
switch( nVal )
{
case text::HoriOrientation::NONE: eOrient = text::HoriOrientation::NONE ; break;
case text::HoriOrientation::RIGHT: eOrient = text::HoriOrientation::RIGHT; break;
case text::HoriOrientation::CENTER : eOrient = text::HoriOrientation::CENTER; break;
case text::HoriOrientation::LEFT : eOrient = text::HoriOrientation::LEFT; break;
case text::HoriOrientation::INSIDE : eOrient = text::HoriOrientation::INSIDE; break;
case text::HoriOrientation::OUTSIDE: eOrient = text::HoriOrientation::OUTSIDE; break;
case text::HoriOrientation::FULL: eOrient = text::HoriOrientation::FULL; break;
case text::HoriOrientation::LEFT_AND_WIDTH:
eOrient = text::HoriOrientation::LEFT_AND_WIDTH;
break;
}
}
break;
case MID_HORIORIENT_RELATION:
{
eRelation = lcl_IntToRelation(rVal);
}
break;
case MID_HORIORIENT_POSITION:
{
sal_Int32 nVal = 0;
if(!(rVal >>= nVal))
bRet = sal_False;
if(bConvert)
nVal = MM100_TO_TWIP(nVal);
SetPos( nVal );
}
break;
case MID_HORIORIENT_PAGETOGGLE:
SetPosToggle( *(sal_Bool*)rVal.getValue());
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwFmtAnchor
// Implementierung teilweise inline im hxx
SwFmtAnchor::SwFmtAnchor( RndStdIds nRnd, sal_uInt16 nPage )
: SfxPoolItem( RES_ANCHOR ),
pCntntAnchor( 0 ),
nAnchorId( nRnd ),
nPageNum( nPage ),
// OD 2004-05-05 #i28701# - get always new increased order number
mnOrder( ++mnOrderCounter )
{}
SwFmtAnchor::SwFmtAnchor( const SwFmtAnchor &rCpy )
: SfxPoolItem( RES_ANCHOR ),
nAnchorId( rCpy.GetAnchorId() ),
nPageNum( rCpy.GetPageNum() ),
// OD 2004-05-05 #i28701# - get always new increased order number
mnOrder( ++mnOrderCounter )
{
pCntntAnchor = rCpy.GetCntntAnchor() ?
new SwPosition( *rCpy.GetCntntAnchor() ) : 0;
}
SwFmtAnchor::~SwFmtAnchor()
{
delete pCntntAnchor;
}
void SwFmtAnchor::SetAnchor( const SwPosition *pPos )
{
if ( pCntntAnchor )
delete pCntntAnchor;
pCntntAnchor = pPos ? new SwPosition( *pPos ) : 0;
//AM Absatz gebundene Flys sollten nie in den Absatz hineinzeigen.
if (pCntntAnchor &&
((FLY_AT_PARA == nAnchorId) || (FLY_AT_FLY == nAnchorId)))
{
pCntntAnchor->nContent.Assign( 0, 0 );
}
}
SwFmtAnchor& SwFmtAnchor::operator=(const SwFmtAnchor& rAnchor)
{
nAnchorId = rAnchor.GetAnchorId();
nPageNum = rAnchor.GetPageNum();
// OD 2004-05-05 #i28701# - get always new increased order number
mnOrder = ++mnOrderCounter;
delete pCntntAnchor;
pCntntAnchor = rAnchor.pCntntAnchor ?
new SwPosition(*(rAnchor.pCntntAnchor)) : 0;
return *this;
}
int SwFmtAnchor::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
// OD 2004-05-05 #i28701# - Note: <mnOrder> hasn't to be considered.
return ( nAnchorId == ((SwFmtAnchor&)rAttr).GetAnchorId() &&
nPageNum == ((SwFmtAnchor&)rAttr).GetPageNum() &&
//Anker vergleichen. Entweder zeigen beide auf das gleiche
//Attribut bzw. sind 0 oder die SwPosition* sind beide
//gueltig und die SwPositions sind gleich.
(pCntntAnchor == ((SwFmtAnchor&)rAttr).GetCntntAnchor() ||
(pCntntAnchor && ((SwFmtAnchor&)rAttr).GetCntntAnchor() &&
*pCntntAnchor == *((SwFmtAnchor&)rAttr).GetCntntAnchor())));
}
SfxPoolItem* SwFmtAnchor::Clone( SfxItemPool* ) const
{
return new SwFmtAnchor( *this );
}
// OD 2004-05-05 #i28701#
sal_uInt32 SwFmtAnchor::mnOrderCounter = 0;
// OD 2004-05-05 #i28701#
sal_uInt32 SwFmtAnchor::GetOrder() const
{
return mnOrder;
}
/*-----------------16.02.98 15:21-------------------
--------------------------------------------------*/
sal_Bool SwFmtAnchor::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_ANCHOR_ANCHORTYPE:
text::TextContentAnchorType eRet;
switch (GetAnchorId())
{
case FLY_AT_CHAR:
eRet = text::TextContentAnchorType_AT_CHARACTER;
break;
case FLY_AT_PAGE:
eRet = text::TextContentAnchorType_AT_PAGE;
break;
case FLY_AT_FLY:
eRet = text::TextContentAnchorType_AT_FRAME;
break;
case FLY_AS_CHAR:
eRet = text::TextContentAnchorType_AS_CHARACTER;
break;
//case FLY_AT_PARA:
default:
eRet = text::TextContentAnchorType_AT_PARAGRAPH;
}
rVal <<= eRet;
break;
case MID_ANCHOR_PAGENUM:
rVal <<= (sal_Int16)GetPageNum();
break;
case MID_ANCHOR_ANCHORFRAME:
{
if(pCntntAnchor && FLY_AT_FLY == nAnchorId)
{
SwFrmFmt* pFmt = pCntntAnchor->nNode.GetNode().GetFlyFmt();
if(pFmt)
{
uno::Reference<container::XNamed> xNamed = SwXFrames::GetObject( *pFmt, FLYCNTTYPE_FRM );
uno::Reference<text::XTextFrame> xRet(xNamed, uno::UNO_QUERY);
rVal <<= xRet;
}
}
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtAnchor::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_ANCHOR_ANCHORTYPE:
{
RndStdIds eAnchor;
switch( SWUnoHelper::GetEnumAsInt32( rVal ) )
{
case text::TextContentAnchorType_AS_CHARACTER:
eAnchor = FLY_AS_CHAR;
break;
case text::TextContentAnchorType_AT_PAGE:
eAnchor = FLY_AT_PAGE;
if( GetPageNum() > 0 && pCntntAnchor )
{
// If the anchor type is page and a valid page number
// has been set, the content position isn't required
// any longer.
delete pCntntAnchor;
pCntntAnchor = 0;
}
break;
case text::TextContentAnchorType_AT_FRAME:
eAnchor = FLY_AT_FLY;
break;
case text::TextContentAnchorType_AT_CHARACTER:
eAnchor = FLY_AT_CHAR;
break;
//case text::TextContentAnchorType_AT_PARAGRAPH:
default:
eAnchor = FLY_AT_PARA;
break;
}
SetType( eAnchor );
}
break;
case MID_ANCHOR_PAGENUM:
{
sal_Int16 nVal = 0;
if((rVal >>= nVal) && nVal > 0)
{
SetPageNum( nVal );
if ((FLY_AT_PAGE == GetAnchorId()) && pCntntAnchor)
{
// If the anchor type is page and a valid page number
// is set, the content paoition has to be deleted to not
// confuse the layout (frmtool.cxx). However, if the
// anchor type is not page, any content position will
// be kept.
delete pCntntAnchor;
pCntntAnchor = 0;
}
}
else
bRet = sal_False;
}
break;
case MID_ANCHOR_ANCHORFRAME:
//no break here!;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwFmtURL
// Implementierung teilweise inline im hxx
SwFmtURL::SwFmtURL() :
SfxPoolItem( RES_URL ),
pMap( 0 ),
bIsServerMap( sal_False )
{
}
SwFmtURL::SwFmtURL( const SwFmtURL &rURL) :
SfxPoolItem( RES_URL ),
sTargetFrameName( rURL.GetTargetFrameName() ),
sURL( rURL.GetURL() ),
sName( rURL.GetName() ),
bIsServerMap( rURL.IsServerMap() )
{
pMap = rURL.GetMap() ? new ImageMap( *rURL.GetMap() ) : 0;
}
SwFmtURL::~SwFmtURL()
{
if ( pMap )
delete pMap;
}
int SwFmtURL::operator==( const SfxPoolItem &rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
const SwFmtURL &rCmp = (SwFmtURL&)rAttr;
sal_Bool bRet = bIsServerMap == rCmp.IsServerMap() &&
sURL == rCmp.GetURL() &&
sTargetFrameName == rCmp.GetTargetFrameName() &&
sName == rCmp.GetName();
if ( bRet )
{
if ( pMap && rCmp.GetMap() )
bRet = *pMap == *rCmp.GetMap();
else
bRet = pMap == rCmp.GetMap();
}
return bRet;
}
SfxPoolItem* SwFmtURL::Clone( SfxItemPool* ) const
{
return new SwFmtURL( *this );
}
void SwFmtURL::SetURL( const XubString &rURL, sal_Bool bServerMap )
{
sURL = rURL;
bIsServerMap = bServerMap;
}
void SwFmtURL::SetMap( const ImageMap *pM )
{
if ( pMap )
delete pMap;
pMap = pM ? new ImageMap( *pM ) : 0;
}
extern const SvEventDescription* lcl_GetSupportedMacroItems();
sal_Bool SwFmtURL::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_URL_URL:
{
OUString sRet = GetURL();
rVal <<= sRet;
}
break;
case MID_URL_TARGET:
{
OUString sRet = GetTargetFrameName();
rVal <<= sRet;
}
break;
case MID_URL_HYPERLINKNAME:
rVal <<= OUString( GetName() );
break;
case MID_URL_CLIENTMAP:
{
uno::Reference< uno::XInterface > xInt;
if(pMap)
{
xInt = SvUnoImageMap_createInstance( *pMap, lcl_GetSupportedMacroItems() );
}
else
{
ImageMap aEmptyMap;
xInt = SvUnoImageMap_createInstance( aEmptyMap, lcl_GetSupportedMacroItems() );
}
uno::Reference< container::XIndexContainer > xCont(xInt, uno::UNO_QUERY);
rVal <<= xCont;
}
break;
case MID_URL_SERVERMAP:
{
sal_Bool bTmp = IsServerMap();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtURL::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_URL_URL:
{
OUString sTmp;
rVal >>= sTmp;
SetURL( sTmp, bIsServerMap );
}
break;
case MID_URL_TARGET:
{
OUString sTmp;
rVal >>= sTmp;
SetTargetFrameName( sTmp );
}
break;
case MID_URL_HYPERLINKNAME:
{
OUString sTmp;
rVal >>= sTmp;
SetName( sTmp );
}
break;
case MID_URL_CLIENTMAP:
{
uno::Reference<container::XIndexContainer> xCont;
if(!rVal.hasValue())
DELETEZ(pMap);
else if(rVal >>= xCont)
{
if(!pMap)
pMap = new ImageMap;
bRet = SvUnoImageMap_fillImageMap( xCont, *pMap );
}
else
bRet = sal_False;
}
break;
case MID_URL_SERVERMAP:
bIsServerMap = *(sal_Bool*)rVal.getValue();
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
// class SwNoReadOnly
SfxPoolItem* SwFmtEditInReadonly::Clone( SfxItemPool* ) const
{
return new SwFmtEditInReadonly( Which(), GetValue() );
}
// class SwFmtLayoutSplit
SfxPoolItem* SwFmtLayoutSplit::Clone( SfxItemPool* ) const
{
return new SwFmtLayoutSplit( GetValue() );
}
// class SwFmtRowSplit
SfxPoolItem* SwFmtRowSplit::Clone( SfxItemPool* ) const
{
return new SwFmtRowSplit( GetValue() );
}
// class SwFmtNoBalancedColumns
SfxPoolItem* SwFmtNoBalancedColumns::Clone( SfxItemPool* ) const
{
return new SwFmtNoBalancedColumns( GetValue() );
}
// class SwFmtFtnEndAtTxtEnd
sal_uInt16 SwFmtFtnEndAtTxtEnd::GetValueCount() const
{
return sal_uInt16( FTNEND_ATTXTEND_END );
}
SwFmtFtnEndAtTxtEnd& SwFmtFtnEndAtTxtEnd::operator=(
const SwFmtFtnEndAtTxtEnd& rAttr )
{
SfxEnumItem::SetValue( rAttr.GetValue() );
aFmt = rAttr.aFmt;
nOffset = rAttr.nOffset;
sPrefix = rAttr.sPrefix;
sSuffix = rAttr.sSuffix;
return *this;
}
int SwFmtFtnEndAtTxtEnd::operator==( const SfxPoolItem& rItem ) const
{
const SwFmtFtnEndAtTxtEnd& rAttr = (SwFmtFtnEndAtTxtEnd&)rItem;
return SfxEnumItem::operator==( rAttr ) &&
aFmt.GetNumberingType() == rAttr.aFmt.GetNumberingType() &&
nOffset == rAttr.nOffset &&
sPrefix == rAttr.sPrefix &&
sSuffix == rAttr.sSuffix;
}
sal_Bool SwFmtFtnEndAtTxtEnd::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_COLLECT :
{
sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND;
rVal.setValue(&bVal, ::getBooleanCppuType());
}
break;
case MID_RESTART_NUM :
{
sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ;
rVal.setValue(&bVal, ::getBooleanCppuType());
}
break;
case MID_NUM_START_AT: rVal <<= (sal_Int16) nOffset; break;
case MID_OWN_NUM :
{
sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT;
rVal.setValue(&bVal, ::getBooleanCppuType());
}
break;
case MID_NUM_TYPE : rVal <<= aFmt.GetNumberingType(); break;
case MID_PREFIX : rVal <<= OUString(sPrefix); break;
case MID_SUFFIX : rVal <<= OUString(sSuffix); break;
default: return sal_False;
}
return sal_True;
}
sal_Bool SwFmtFtnEndAtTxtEnd::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bRet = sal_True;
nMemberId &= ~CONVERT_TWIPS;
switch(nMemberId)
{
case MID_COLLECT :
{
sal_Bool bVal = *(sal_Bool*)rVal.getValue();
if(!bVal && GetValue() >= FTNEND_ATTXTEND)
SetValue(FTNEND_ATPGORDOCEND);
else if(bVal && GetValue() < FTNEND_ATTXTEND)
SetValue(FTNEND_ATTXTEND);
}
break;
case MID_RESTART_NUM :
{
sal_Bool bVal = *(sal_Bool*)rVal.getValue();
if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ)
SetValue(FTNEND_ATTXTEND);
else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMSEQ)
SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
}
break;
case MID_NUM_START_AT:
{
sal_Int16 nVal = 0;
rVal >>= nVal;
if(nVal >= 0)
nOffset = nVal;
else
bRet = sal_False;
}
break;
case MID_OWN_NUM :
{
sal_Bool bVal = *(sal_Bool*)rVal.getValue();
if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT)
SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMANDFMT)
SetValue(FTNEND_ATTXTEND_OWNNUMANDFMT);
}
break;
case MID_NUM_TYPE :
{
sal_Int16 nVal = 0;
rVal >>= nVal;
if(nVal >= 0 &&
(nVal <= SVX_NUM_ARABIC ||
SVX_NUM_CHARS_UPPER_LETTER_N == nVal ||
SVX_NUM_CHARS_LOWER_LETTER_N == nVal ))
aFmt.SetNumberingType(nVal);
else
bRet = sal_False;
}
break;
case MID_PREFIX :
{
OUString sVal; rVal >>= sVal;
sPrefix = sVal;
}
break;
case MID_SUFFIX :
{
OUString sVal; rVal >>= sVal;
sSuffix = sVal;
}
break;
default: bRet = sal_False;
}
return bRet;
}
// class SwFmtFtnAtTxtEnd
SfxPoolItem* SwFmtFtnAtTxtEnd::Clone( SfxItemPool* ) const
{
SwFmtFtnAtTxtEnd* pNew = new SwFmtFtnAtTxtEnd;
*pNew = *this;
return pNew;
}
// class SwFmtEndAtTxtEnd
SfxPoolItem* SwFmtEndAtTxtEnd::Clone( SfxItemPool* ) const
{
SwFmtEndAtTxtEnd* pNew = new SwFmtEndAtTxtEnd;
*pNew = *this;
return pNew;
}
//class SwFmtChain
int SwFmtChain::operator==( const SfxPoolItem &rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return GetPrev() == ((SwFmtChain&)rAttr).GetPrev() &&
GetNext() == ((SwFmtChain&)rAttr).GetNext();
}
SwFmtChain::SwFmtChain( const SwFmtChain &rCpy ) :
SfxPoolItem( RES_CHAIN )
{
SetPrev( rCpy.GetPrev() );
SetNext( rCpy.GetNext() );
}
SfxPoolItem* SwFmtChain::Clone( SfxItemPool* ) const
{
SwFmtChain *pRet = new SwFmtChain;
pRet->SetPrev( GetPrev() );
pRet->SetNext( GetNext() );
return pRet;
}
void SwFmtChain::SetPrev( SwFlyFrmFmt *pFmt )
{
if ( pFmt )
pFmt->Add( &aPrev );
else if ( aPrev.GetRegisteredIn() )
((SwModify*)aPrev.GetRegisteredIn())->Remove( &aPrev );
}
void SwFmtChain::SetNext( SwFlyFrmFmt *pFmt )
{
if ( pFmt )
pFmt->Add( &aNext );
else if ( aNext.GetRegisteredIn() )
((SwModify*)aNext.GetRegisteredIn())->Remove( &aNext );
}
sal_Bool SwFmtChain::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
XubString aRet;
switch ( nMemberId )
{
case MID_CHAIN_PREVNAME:
if ( GetPrev() )
aRet = GetPrev()->GetName();
break;
case MID_CHAIN_NEXTNAME:
if ( GetNext() )
aRet = GetNext()->GetName();
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
rVal <<= OUString(aRet);
return bRet;
}
//class SwFmtLineNumber
SwFmtLineNumber::SwFmtLineNumber() :
SfxPoolItem( RES_LINENUMBER )
{
nStartValue = 0;
bCountLines = sal_True;
}
SwFmtLineNumber::~SwFmtLineNumber()
{
}
int SwFmtLineNumber::operator==( const SfxPoolItem &rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return nStartValue == ((SwFmtLineNumber&)rAttr).GetStartValue() &&
bCountLines == ((SwFmtLineNumber&)rAttr).IsCount();
}
SfxPoolItem* SwFmtLineNumber::Clone( SfxItemPool* ) const
{
return new SwFmtLineNumber( *this );
}
sal_Bool SwFmtLineNumber::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_LINENUMBER_COUNT:
{
sal_Bool bTmp = IsCount();
rVal.setValue(&bTmp, ::getBooleanCppuType());
}
break;
case MID_LINENUMBER_STARTVALUE:
rVal <<= (sal_Int32)GetStartValue();
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
sal_Bool SwFmtLineNumber::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
// hier wird immer konvertiert!
nMemberId &= ~CONVERT_TWIPS;
sal_Bool bRet = sal_True;
switch ( nMemberId )
{
case MID_LINENUMBER_COUNT:
SetCountLines( *(sal_Bool*)rVal.getValue() );
break;
case MID_LINENUMBER_STARTVALUE:
{
sal_Int32 nVal = 0;
if(rVal >>= nVal)
SetStartValue( nVal );
else
bRet = sal_False;
}
break;
default:
ASSERT( !this, "unknown MemberId" );
bRet = sal_False;
}
return bRet;
}
/*************************************************************************
* class SwTextGridItem
*************************************************************************/
SwTextGridItem::SwTextGridItem()
: SfxPoolItem( RES_TEXTGRID ), aColor( COL_LIGHTGRAY ), nLines( 20 ),
nBaseHeight( 400 ), nRubyHeight( 200 ), eGridType( GRID_NONE ),
bRubyTextBelow( 0 ), bPrintGrid( 1 ), bDisplayGrid( 1 ),
nBaseWidth(400), bSnapToChars( 1 ), bSquaredMode(1)
{
}
SwTextGridItem::~SwTextGridItem()
{
}
int SwTextGridItem::operator==( const SfxPoolItem& rAttr ) const
{
ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
return eGridType == ((SwTextGridItem&)rAttr).GetGridType() &&
nLines == ((SwTextGridItem&)rAttr).GetLines() &&
nBaseHeight == ((SwTextGridItem&)rAttr).GetBaseHeight() &&
nRubyHeight == ((SwTextGridItem&)rAttr).GetRubyHeight() &&
bRubyTextBelow == ((SwTextGridItem&)rAttr).GetRubyTextBelow() &&
bDisplayGrid == ((SwTextGridItem&)rAttr).GetDisplayGrid() &&
bPrintGrid == ((SwTextGridItem&)rAttr).GetPrintGrid() &&
aColor == ((SwTextGridItem&)rAttr).GetColor() &&
nBaseWidth == ((SwTextGridItem&)rAttr).GetBaseWidth() &&
bSnapToChars == ((SwTextGridItem&)rAttr).GetSnapToChars() &&
bSquaredMode == ((SwTextGridItem&)rAttr).GetSquaredMode();
}
SfxPoolItem* SwTextGridItem::Clone( SfxItemPool* ) const
{
return new SwTextGridItem( *this );
}
SwTextGridItem& SwTextGridItem::operator=( const SwTextGridItem& rCpy )
{
aColor = rCpy.GetColor();
nLines = rCpy.GetLines();
nBaseHeight = rCpy.GetBaseHeight();
nRubyHeight = rCpy.GetRubyHeight();
eGridType = rCpy.GetGridType();
bRubyTextBelow = rCpy.GetRubyTextBelow();
bPrintGrid = rCpy.GetPrintGrid();
bDisplayGrid = rCpy.GetDisplayGrid();
nBaseWidth = rCpy.GetBaseWidth();
bSnapToChars = rCpy.GetSnapToChars();
bSquaredMode = rCpy.GetSquaredMode();
return *this;
}
sal_Bool SwTextGridItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
{
sal_Bool bRet = sal_True;
switch( nMemberId & ~CONVERT_TWIPS )
{
case MID_GRID_COLOR:
rVal <<= GetColor().GetColor();
break;
case MID_GRID_LINES:
rVal <<= GetLines();
break;
case MID_GRID_RUBY_BELOW:
rVal.setValue( &bRubyTextBelow, ::getBooleanCppuType() );
break;
case MID_GRID_PRINT:
rVal.setValue( &bPrintGrid, ::getBooleanCppuType() );
break;
case MID_GRID_DISPLAY:
rVal.setValue( &bDisplayGrid, ::getBooleanCppuType() );
break;
case MID_GRID_BASEHEIGHT:
DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0,
"This value needs TWIPS-MM100 conversion" );
rVal <<= (sal_Int32) TWIP_TO_MM100_UNSIGNED(nBaseHeight);
break;
case MID_GRID_BASEWIDTH:
DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0,
"This value needs TWIPS-MM100 conversion" );
rVal <<= (sal_Int32) TWIP_TO_MM100_UNSIGNED(nBaseWidth);
break;
case MID_GRID_RUBYHEIGHT:
DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0,
"This value needs TWIPS-MM100 conversion" );
rVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(nRubyHeight);
break;
case MID_GRID_TYPE:
switch( GetGridType() )
{
case GRID_NONE:
rVal <<= text::TextGridMode::NONE;
break;
case GRID_LINES_ONLY:
rVal <<= text::TextGridMode::LINES;
break;
case GRID_LINES_CHARS:
rVal <<= text::TextGridMode::LINES_AND_CHARS;
break;
default:
DBG_ERROR("unknown SwTextGrid value");
bRet = sal_False;
break;
}
break;
case MID_GRID_SNAPTOCHARS:
rVal.setValue( &bSnapToChars, ::getBooleanCppuType() );
break;
case MID_GRID_STANDARD_MODE:
{
sal_Bool bStandardMode = !bSquaredMode;
rVal.setValue( &bStandardMode, ::getBooleanCppuType() );
}
break;
default:
DBG_ERROR("Unknown SwTextGridItem member");
bRet = sal_False;
break;
}
return bRet;
}
sal_Bool SwTextGridItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
{
sal_Bool bRet = sal_True;
switch( nMemberId & ~CONVERT_TWIPS )
{
case MID_GRID_COLOR:
{
sal_Int32 nTmp = 0;
bRet = (rVal >>= nTmp);
if( bRet )
SetColor( Color(nTmp) );
}
break;
case MID_GRID_LINES:
{
sal_Int16 nTmp = 0;
bRet = (rVal >>= nTmp);
if( bRet && (nTmp >= 0) )
SetLines( (sal_uInt16)nTmp );
else
bRet = sal_False;
}
break;
case MID_GRID_RUBY_BELOW:
SetRubyTextBelow( *(sal_Bool*)rVal.getValue() );
break;
case MID_GRID_PRINT:
SetPrintGrid( *(sal_Bool*)rVal.getValue() );
break;
case MID_GRID_DISPLAY:
SetDisplayGrid( *(sal_Bool*)rVal.getValue() );
break;
case MID_GRID_BASEHEIGHT:
case MID_GRID_BASEWIDTH:
case MID_GRID_RUBYHEIGHT:
{
DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0,
"This value needs TWIPS-MM100 conversion" );
sal_Int32 nTmp = 0;
bRet = (rVal >>= nTmp);
nTmp = MM100_TO_TWIP( nTmp );
if( bRet && (nTmp >= 0) && ( nTmp <= USHRT_MAX) )
if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEHEIGHT )
SetBaseHeight( (sal_uInt16)nTmp );
else if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEWIDTH )
SetBaseWidth( (sal_uInt16)nTmp );
else
SetRubyHeight( (sal_uInt16)nTmp );
else
bRet = sal_False;
}
break;
case MID_GRID_TYPE:
{
sal_Int16 nTmp = 0;
bRet = (rVal >>= nTmp);
if( bRet )
{
switch( nTmp )
{
case text::TextGridMode::NONE:
SetGridType( GRID_NONE );
break;
case text::TextGridMode::LINES:
SetGridType( GRID_LINES_ONLY );
break;
case text::TextGridMode::LINES_AND_CHARS:
SetGridType( GRID_LINES_CHARS );
break;
default:
bRet = sal_False;
break;
}
}
break;
}
case MID_GRID_SNAPTOCHARS:
SetSnapToChars( *(sal_Bool*)rVal.getValue() );
break;
case MID_GRID_STANDARD_MODE:
{
sal_Bool bStandard = *(sal_Bool*)rVal.getValue();
SetSquaredMode( !bStandard );
break;
}
default:
DBG_ERROR("Unknown SwTextGridItem member");
bRet = sal_False;
}
return bRet;
}
void SwTextGridItem::SwitchPaperMode(sal_Bool bNew)
{
if( bNew == bSquaredMode )
{
//same paper mode, not switch
return;
}
// use default value when grid is disable
if( eGridType == GRID_NONE )
{
bSquaredMode = bNew;
Init();
return;
}
if( bSquaredMode )
{
//switch from "squared mode" to "standard mode"
nBaseWidth = nBaseHeight;
nBaseHeight = nBaseHeight + nRubyHeight;
nRubyHeight = 0;
}
else
{
//switch from "standard mode" to "squared mode"
nRubyHeight = nBaseHeight/3;
nBaseHeight = nBaseHeight - nRubyHeight;
nBaseWidth = nBaseHeight;
}
bSquaredMode = !bSquaredMode;
}
void SwTextGridItem::Init()
{
if( bSquaredMode )
{
nLines = 20;
nBaseHeight = 400;
nRubyHeight = 200;
eGridType = GRID_NONE;
bRubyTextBelow = 0;
bPrintGrid = 1;
bDisplayGrid = 1;
bSnapToChars = 1;
nBaseWidth = 400;
}
else
{
nLines = 44;
nBaseHeight = 312;
nRubyHeight = 0;
eGridType = GRID_NONE;
bRubyTextBelow = 0;
bPrintGrid = 1;
bDisplayGrid = 1;
nBaseWidth = 210;
bSnapToChars = 1;
//default grid type is line only in CJK env
//disable this function due to type area change
//if grid type change.
//if(SvtCJKOptions().IsAsianTypographyEnabled())
//{
// bDisplayGrid = 0;
// eGridType = GRID_LINES_ONLY;
//}
}
}
// class SwHeaderAndFooterEatSpacingItem
SfxPoolItem* SwHeaderAndFooterEatSpacingItem::Clone( SfxItemPool* ) const
{
return new SwHeaderAndFooterEatSpacingItem( Which(), GetValue() );
}
// class SwFrmFmt
// Implementierung teilweise inline im hxx
TYPEINIT1( SwFrmFmt, SwFmt );
IMPL_FIXEDMEMPOOL_NEWDEL_DLL( SwFrmFmt, 20, 20 )
void SwFrmFmt::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
{
SwFmtHeader *pH = 0;
SwFmtFooter *pF = 0;
sal_uInt16 nWhich = pNew ? pNew->Which() : 0;
if( RES_ATTRSET_CHG == nWhich )
{
((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState(
RES_HEADER, sal_False, (const SfxPoolItem**)&pH );
((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState(
RES_FOOTER, sal_False, (const SfxPoolItem**)&pF );
}
else if( RES_HEADER == nWhich )
pH = (SwFmtHeader*)pNew;
else if( RES_FOOTER == nWhich )
pF = (SwFmtFooter*)pNew;
if( pH && pH->IsActive() && !pH->GetHeaderFmt() )
{ //Hat er keinen, mach ich ihm einen
SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_HEADER, 0 );
pH->RegisterToFormat( *pFmt );
}
if( pF && pF->IsActive() && !pF->GetFooterFmt() )
{ //Hat er keinen, mach ich ihm einen
SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_FOOTER, 0 );
pF->RegisterToFormat( *pFmt );
}
// MIB 24.3.98: Modify der Basisklasse muss immer gerufen werden, z.B.
// wegen RESET_FMTWRITTEN.
// if ( GetDepends() )
SwFmt::Modify( pOld, pNew );
if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which()))
{ // invalidate cached uno object
SetXObject(uno::Reference<uno::XInterface>(0));
}
}
void SwFrmFmt::RegisterToFormat( SwFmt& rFmt )
{
rFmt.Add( this );
}
//Vernichtet alle Frms, die in aDepend angemeldet sind.
void SwFrmFmt::DelFrms()
{
SwIterator<SwFrm,SwFmt> aIter( *this );
SwFrm * pLast = aIter.First();
if( pLast )
do {
pLast->Cut();
delete pLast;
} while( 0 != ( pLast = aIter.Next() ));
}
void SwFrmFmt::MakeFrms()
{
ASSERT( !this, "Sorry not implemented." );
}
SwRect SwFrmFmt::FindLayoutRect( const sal_Bool bPrtArea, const Point* pPoint,
const sal_Bool bCalcFrm ) const
{
SwRect aRet;
SwFrm *pFrm = 0;
if( ISA( SwSectionFmt ) )
{
// dann den frame::Frame per Node2Layout besorgen
SwSectionNode* pSectNd = ((SwSectionFmt*)this)->GetSectionNode();
if( pSectNd )
{
SwNode2Layout aTmp( *pSectNd, pSectNd->GetIndex() - 1 );
pFrm = aTmp.NextFrm();
if( pFrm && !pFrm->KnowsFormat(*this) )
{
// die Section hat keinen eigenen frame::Frame, also falls
// jemand die tatsaechliche Groe?e braucht, so muss das
// noch implementier werden, in dem sich vom Ende noch
// der entsprechende frame::Frame besorgt wird.
// PROBLEM: was passiert bei SectionFrames, die auf unter-
// schiedlichen Seiten stehen??
if( bPrtArea )
aRet = pFrm->Prt();
else
{
aRet = pFrm->Frm();
--aRet.Pos().Y();
}
pFrm = 0; // das Rect ist ja jetzt fertig
}
}
}
else
{
sal_uInt16 nFrmType = RES_FLYFRMFMT == Which() ? FRM_FLY : USHRT_MAX;
pFrm = ::GetFrmOfModify( 0, *(SwModify*)this, nFrmType, pPoint,
0, bCalcFrm );
}
if( pFrm )
{
if( bPrtArea )
aRet = pFrm->Prt();
else
aRet = pFrm->Frm();
}
return aRet;
}
SwContact* SwFrmFmt::FindContactObj()
{
return SwIterator<SwContact,SwFmt>::FirstElement( *this );
}
SdrObject* SwFrmFmt::FindSdrObject()
{
// --> OD 2005-01-06 #i30669# - use method <FindContactObj()> instead of
// duplicated code.
SwContact* pFoundContact = FindContactObj();
return pFoundContact ? pFoundContact->GetMaster() : 0;
// <--
}
SdrObject* SwFrmFmt::FindRealSdrObject()
{
if( RES_FLYFRMFMT == Which() )
{
Point aNullPt;
SwFlyFrm* pFly = (SwFlyFrm*)::GetFrmOfModify( 0, *this, FRM_FLY,
&aNullPt, 0, sal_False );
return pFly ? pFly->GetVirtDrawObj() : 0;
}
return FindSdrObject();
}
sal_Bool SwFrmFmt::IsLowerOf( const SwFrmFmt& rFmt ) const
{
//Auch eine Verkettung von Innen nach aussen oder von aussen
//nach innen ist nicht zulaessig.
SwFlyFrm *pSFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(*this);
if( pSFly )
{
SwFlyFrm *pAskFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(rFmt);
if( pAskFly )
return pSFly->IsLowerOf( pAskFly );
}
// dann mal ueber die Node-Positionen versuchen
const SwFmtAnchor* pAnchor = &rFmt.GetAnchor();
if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) && pAnchor->GetCntntAnchor())
{
const SwSpzFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts();
const SwNode* pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode().
FindFlyStartNode();
while( pFlyNd )
{
// dann ueber den Anker nach oben "hangeln"
sal_uInt16 n;
for( n = 0; n < rFmts.Count(); ++n )
{
const SwFrmFmt* pFmt = rFmts[ n ];
const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
if( pIdx && pFlyNd == &pIdx->GetNode() )
{
if( pFmt == this )
return sal_True;
pAnchor = &pFmt->GetAnchor();
if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) ||
!pAnchor->GetCntntAnchor() )
{
return sal_False;
}
pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode().
FindFlyStartNode();
break;
}
}
if( n >= rFmts.Count() )
{
ASSERT( !this, "Fly-Section aber kein Format gefunden" );
return sal_False;
}
}
}
return sal_False;
}
// --> OD 2004-07-27 #i31698#
SwFrmFmt::tLayoutDir SwFrmFmt::GetLayoutDir() const
{
return SwFrmFmt::HORI_L2R;
}
void SwFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir )
{
// empty body, because default implementation does nothing
}
// <--
// --> OD 2004-08-06 #i28749#
sal_Int16 SwFrmFmt::GetPositionLayoutDir() const
{
return text::PositionLayoutDir::PositionInLayoutDirOfAnchor;
}
void SwFrmFmt::SetPositionLayoutDir( const sal_Int16 )
{
// empty body, because default implementation does nothing
}
// <--
String SwFrmFmt::GetDescription() const
{
return SW_RES(STR_FRAME);
}
// class SwFlyFrmFmt
// Implementierung teilweise inline im hxx
TYPEINIT1( SwFlyFrmFmt, SwFrmFmt );
IMPL_FIXEDMEMPOOL_NEWDEL( SwFlyFrmFmt, 10, 10 )
SwFlyFrmFmt::~SwFlyFrmFmt()
{
SwIterator<SwFlyFrm,SwFmt> aIter( *this );
SwFlyFrm * pLast = aIter.First();
if( pLast )
do {
delete pLast;
} while( 0 != ( pLast = aIter.Next() ));
SwIterator<SwFlyDrawContact,SwFmt> a2ndIter( *this );
SwFlyDrawContact* pC = a2ndIter.First();
if( pC )
do {
delete pC;
} while( 0 != ( pC = a2ndIter.Next() ));
}
//Erzeugen der Frms wenn das Format einen Absatzgebundenen Rahmen beschreibt.
//MA: 14. Feb. 94, Erzeugen der Frms auch fuer Seitengebundene Rahmen.
void SwFlyFrmFmt::MakeFrms()
{
// gibts ueberhaupt ein Layout ??
if( !GetDoc()->GetCurrentViewShell() )
return; //swmod 071108//swmod 071225
SwModify *pModify = 0;
// OD 24.07.2003 #111032# - create local copy of anchor attribute for possible changes.
SwFmtAnchor aAnchorAttr( GetAnchor() );
switch( aAnchorAttr.GetAnchorId() )
{
case FLY_AS_CHAR:
case FLY_AT_PARA:
case FLY_AT_CHAR:
if( aAnchorAttr.GetCntntAnchor() )
{
pModify = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
}
break;
case FLY_AT_FLY:
if( aAnchorAttr.GetCntntAnchor() )
{
//Erst einmal ueber den Inhalt suchen, weil konstant schnell. Kann
//Bei verketteten Rahmen aber auch schief gehen, weil dann evtl.
//niemals ein frame::Frame zu dem Inhalt existiert. Dann muss leider noch
//die Suche vom StartNode zum FrameFormat sein.
SwNodeIndex aIdx( aAnchorAttr.GetCntntAnchor()->nNode );
SwCntntNode *pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
// --> OD 2009-12-28 #i105535#
if ( pCNd == 0 )
{
pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
}
if ( pCNd )
// <--
{
if( SwIterator<SwFrm,SwCntntNode>::FirstElement( *pCNd ) )
{
pModify = pCNd;
}
}
// --> OD 2009-12-28 #i105535#
if ( pModify == 0 )
// <--
{
const SwNodeIndex &rIdx = aAnchorAttr.GetCntntAnchor()->nNode;
SwSpzFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts();
for( sal_uInt16 i = 0; i < rFmts.Count(); ++i )
{
SwFrmFmt* pFlyFmt = rFmts[i];
if( pFlyFmt->GetCntnt().GetCntntIdx() &&
rIdx == *pFlyFmt->GetCntnt().GetCntntIdx() )
{
pModify = pFlyFmt;
break;
}
}
}
}
break;
case FLY_AT_PAGE:
{
sal_uInt16 nPgNum = aAnchorAttr.GetPageNum();
SwPageFrm *pPage = (SwPageFrm*)GetDoc()->GetCurrentLayout()->Lower(); //swmod 080218
if( nPgNum == 0 && aAnchorAttr.GetCntntAnchor() )
{
SwCntntNode *pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
SwIterator<SwFrm,SwCntntNode> aIter( *pCNd );
for ( SwFrm* pFrm = aIter.First(); pFrm != NULL; pFrm = aIter.Next() )
{
pPage = pFrm->FindPageFrm();
if( pPage )
{
nPgNum = pPage->GetPhyPageNum();
aAnchorAttr.SetPageNum( nPgNum );
aAnchorAttr.SetAnchor( 0 );
SetFmtAttr( aAnchorAttr );
break;
}
}
}
while ( pPage )
{
if ( pPage->GetPhyPageNum() == nPgNum )
{
pPage->PlaceFly( 0, this );
break;
}
pPage = (SwPageFrm*)pPage->GetNext();
}
}
break;
default:
break;
}
if( pModify )
{
SwIterator<SwFrm,SwModify> aIter( *pModify );
for( SwFrm *pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
{
sal_Bool bAdd = !pFrm->IsCntntFrm() ||
!((SwCntntFrm*)pFrm)->IsFollow();
if ( FLY_AT_FLY == aAnchorAttr.GetAnchorId() && !pFrm->IsFlyFrm() )
{
// --> OD 2009-12-28 #i105535#
// fallback to anchor type at-paragraph, if no fly frame is found.
// pFrm = pFrm->FindFlyFrm();
SwFrm* pFlyFrm = pFrm->FindFlyFrm();
if ( pFlyFrm )
{
pFrm = pFlyFrm;
}
else
{
aAnchorAttr.SetType( FLY_AT_PARA );
SetFmtAttr( aAnchorAttr );
MakeFrms();
return;
}
// <--
}
if( pFrm->GetDrawObjs() )
{
// --> OD 2004-07-01 #i28701# - new type <SwSortedObjs>
SwSortedObjs &rObjs = *pFrm->GetDrawObjs();
for( sal_uInt16 i = 0; i < rObjs.Count(); ++i)
{
// --> OD 2004-07-01 #i28701# - consider changed type of
// <SwSortedObjs> entries.
SwAnchoredObject* pObj = rObjs[i];
if( pObj->ISA(SwFlyFrm) &&
(&pObj->GetFrmFmt()) == this )
{
bAdd = sal_False;
break;
}
}
}
if( bAdd )
{
SwFlyFrm *pFly = 0;
switch( aAnchorAttr.GetAnchorId() )
{
case FLY_AT_FLY:
pFly = new SwFlyLayFrm( this, pFrm, pFrm );
break;
case FLY_AT_PARA:
case FLY_AT_CHAR:
pFly = new SwFlyAtCntFrm( this, pFrm, pFrm );
break;
case FLY_AS_CHAR:
pFly = new SwFlyInCntFrm( this, pFrm, pFrm );
break;
default:
ASSERT( !this, "Neuer Ankertyp" )
break;
}
pFrm->AppendFly( pFly );
SwPageFrm *pPage = pFly->FindPageFrm();
if( pPage )
::RegistFlys( pPage, pFly );
}
}
}
}
SwFlyFrm* SwFlyFrmFmt::GetFrm( const Point* pPoint, const sal_Bool bCalcFrm ) const
{
return (SwFlyFrm*)::GetFrmOfModify( 0, *(SwModify*)this, FRM_FLY,
pPoint, 0, bCalcFrm );
}
SwAnchoredObject* SwFlyFrmFmt::GetAnchoredObj( const Point* pPoint, const sal_Bool bCalcFrm ) const
{
SwFlyFrm* pFlyFrm( GetFrm( pPoint, bCalcFrm ) );
if ( pFlyFrm )
{
return dynamic_cast<SwAnchoredObject*>(pFlyFrm);
}
else
{
return 0L;
}
}
sal_Bool SwFlyFrmFmt::GetInfo( SfxPoolItem& rInfo ) const
{
sal_Bool bRet = sal_True;
switch( rInfo.Which() )
{
case RES_CONTENT_VISIBLE:
{
((SwPtrMsgPoolItem&)rInfo).pObject = SwIterator<SwFrm,SwFmt>::FirstElement( *this );
}
bRet = sal_False;
break;
default:
bRet = SwFrmFmt::GetInfo( rInfo );
break;
}
return bRet;
}
// --> OD 2009-07-14 #i73249#
void SwFlyFrmFmt::SetObjTitle( const String& rTitle, bool bBroadcast )
{
SdrObject* pMasterObject = FindSdrObject();
ASSERT( pMasterObject,
"<SwNoTxtNode::SetObjTitle(..)> - missing <SdrObject> instance" );
if ( !pMasterObject )
{
return;
}
if( bBroadcast )
{
SwStringMsgPoolItem aOld( RES_TITLE_CHANGED, pMasterObject->GetTitle() );
SwStringMsgPoolItem aNew( RES_TITLE_CHANGED, rTitle );
pMasterObject->SetTitle( rTitle );
ModifyNotification( &aOld, &aNew );
}
else
{
pMasterObject->SetTitle( rTitle );
}
}
const String SwFlyFrmFmt::GetObjTitle() const
{
const SdrObject* pMasterObject = FindSdrObject();
ASSERT( pMasterObject,
"<SwFlyFrmFmt::GetObjTitle(..)> - missing <SdrObject> instance" );
if ( !pMasterObject )
{
return aEmptyStr;
}
return pMasterObject->GetTitle();
}
void SwFlyFrmFmt::SetObjDescription( const String& rDescription, bool bBroadcast )
{
SdrObject* pMasterObject = FindSdrObject();
ASSERT( pMasterObject,
"<SwFlyFrmFmt::SetDescription(..)> - missing <SdrObject> instance" );
if ( !pMasterObject )
{
return;
}
if( bBroadcast )
{
SwStringMsgPoolItem aOld( RES_DESCRIPTION_CHANGED, pMasterObject->GetDescription() );
SwStringMsgPoolItem aNew( RES_DESCRIPTION_CHANGED, rDescription );
pMasterObject->SetDescription( rDescription );
ModifyNotification( &aOld, &aNew );
}
else
{
pMasterObject->SetDescription( rDescription );
}
}
const String SwFlyFrmFmt::GetObjDescription() const
{
const SdrObject* pMasterObject = FindSdrObject();
ASSERT( pMasterObject,
"<SwNoTxtNode::GetDescription(..)> - missing <SdrObject> instance" );
if ( !pMasterObject )
{
return aEmptyStr;
}
return pMasterObject->GetDescription();
}
// <--
/** SwFlyFrmFmt::IsBackgroundTransparent - for #99657#
OD 22.08.2002 - overloading virtual method and its default implementation,
because format of fly frame provides transparent backgrounds.
Method determines, if background of fly frame is transparent.
@author OD
@return true, if background color is transparent, but not "no fill"
or the transparency of a existing background graphic is set.
*/
sal_Bool SwFlyFrmFmt::IsBackgroundTransparent() const
{
sal_Bool bReturn = sal_False;
/// NOTE: If background color is "no fill"/"auto fill" (COL_TRANSPARENT)
/// and there is no background graphic, it "inherites" the background
/// from its anchor.
if ( (GetBackground().GetColor().GetTransparency() != 0) &&
(GetBackground().GetColor() != COL_TRANSPARENT)
)
{
bReturn = sal_True;
}
else
{
const GraphicObject *pTmpGrf =
static_cast<const GraphicObject*>(GetBackground().GetGraphicObject());
if ( (pTmpGrf) &&
(pTmpGrf->GetAttr().GetTransparency() != 0)
)
{
bReturn = sal_True;
}
}
return bReturn;
}
/** SwFlyFrmFmt::IsBackgroundBrushInherited - for #103898#
OD 08.10.2002 - method to determine, if the brush for drawing the
background is "inherited" from its parent/grandparent.
This is the case, if no background graphic is set and the background
color is "no fill"/"auto fill"
NOTE: condition is "copied" from method <SwFrm::GetBackgroundBrush(..).
@author OD
@return true, if background brush is "inherited" from parent/grandparent
*/
sal_Bool SwFlyFrmFmt::IsBackgroundBrushInherited() const
{
sal_Bool bReturn = sal_False;
if ( (GetBackground().GetColor() == COL_TRANSPARENT) &&
!(GetBackground().GetGraphicObject()) )
{
bReturn = sal_True;
}
return bReturn;
}
// --> OD 2006-02-28 #125892#
SwHandleAnchorNodeChg::SwHandleAnchorNodeChg( SwFlyFrmFmt& _rFlyFrmFmt,
const SwFmtAnchor& _rNewAnchorFmt,
SwFlyFrm* _pKeepThisFlyFrm )
: mrFlyFrmFmt( _rFlyFrmFmt ),
mbAnchorNodeChanged( false )
{
const RndStdIds nNewAnchorType( _rNewAnchorFmt.GetAnchorId() );
if ( ((nNewAnchorType == FLY_AT_PARA) ||
(nNewAnchorType == FLY_AT_CHAR)) &&
_rNewAnchorFmt.GetCntntAnchor() &&
_rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() )
{
const SwFmtAnchor& aOldAnchorFmt( _rFlyFrmFmt.GetAnchor() );
if ( aOldAnchorFmt.GetAnchorId() == nNewAnchorType &&
aOldAnchorFmt.GetCntntAnchor() &&
aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() &&
aOldAnchorFmt.GetCntntAnchor()->nNode !=
_rNewAnchorFmt.GetCntntAnchor()->nNode )
{
// determine 'old' number of anchor frames
sal_uInt32 nOldNumOfAnchFrm( 0L );
SwIterator<SwFrm,SwCntntNode> aOldIter( *(aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) );
for( SwFrm* pOld = aOldIter.First(); pOld; pOld = aOldIter.Next() )
{
++nOldNumOfAnchFrm;
}
// determine 'new' number of anchor frames
sal_uInt32 nNewNumOfAnchFrm( 0L );
SwIterator<SwFrm,SwCntntNode> aNewIter( *(_rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) );
for( SwFrm* pNew = aNewIter.First(); pNew; pNew = aNewIter.Next() )
{
++nNewNumOfAnchFrm;
}
if ( nOldNumOfAnchFrm != nNewNumOfAnchFrm )
{
// delete existing fly frames except <_pKeepThisFlyFrm>
SwIterator<SwFrm,SwFmt> aIter( mrFlyFrmFmt );
SwFrm* pFrm = aIter.First();
if ( pFrm )
{
do {
if ( pFrm != _pKeepThisFlyFrm )
{
pFrm->Cut();
delete pFrm;
}
} while( 0 != ( pFrm = aIter.Next() ));
}
// indicate, that re-creation of fly frames necessary
mbAnchorNodeChanged = true;
}
}
}
}
SwHandleAnchorNodeChg::~SwHandleAnchorNodeChg()
{
if ( mbAnchorNodeChanged )
{
mrFlyFrmFmt.MakeFrms();
}
}
// <--
// class SwDrawFrmFmt
// Implementierung teilweise inline im hxx
TYPEINIT1( SwDrawFrmFmt, SwFrmFmt );
IMPL_FIXEDMEMPOOL_NEWDEL( SwDrawFrmFmt, 10, 10 )
SwDrawFrmFmt::~SwDrawFrmFmt()
{
SwContact *pContact = FindContactObj();
delete pContact;
}
void SwDrawFrmFmt::MakeFrms()
{
SwDrawContact *pContact = (SwDrawContact*)FindContactObj();
if ( pContact )
pContact->ConnectToLayout();
}
void SwDrawFrmFmt::DelFrms()
{
SwDrawContact *pContact = (SwDrawContact *)FindContactObj();
if ( pContact ) //fuer den Reader und andere Unabwaegbarkeiten.
pContact->DisconnectFromLayout();
}
// --> OD 2004-07-27 #i31698#
SwFrmFmt::tLayoutDir SwDrawFrmFmt::GetLayoutDir() const
{
return meLayoutDir;
}
void SwDrawFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir _eLayoutDir )
{
meLayoutDir = _eLayoutDir;
}
// <--
// --> OD 2004-08-06 #i28749#
sal_Int16 SwDrawFrmFmt::GetPositionLayoutDir() const
{
return mnPositionLayoutDir;
}
void SwDrawFrmFmt::SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir )
{
switch ( _nPositionLayoutDir )
{
case text::PositionLayoutDir::PositionInHoriL2R:
case text::PositionLayoutDir::PositionInLayoutDirOfAnchor:
{
mnPositionLayoutDir = _nPositionLayoutDir;
}
break;
default:
{
ASSERT( false,
"<SwDrawFrmFmt::SetPositionLayoutDir(..)> - invalid attribute value." );
}
}
}
// <--
String SwDrawFrmFmt::GetDescription() const
{
String aResult;
const SdrObject * pSdrObj = FindSdrObject();
if (pSdrObj)
{
if (pSdrObj != pSdrObjCached)
{
SdrObject * pSdrObjCopy = pSdrObj->Clone();
SdrUndoNewObj * pSdrUndo = new SdrUndoNewObj(*pSdrObjCopy);
sSdrObjCachedComment = pSdrUndo->GetComment();
delete pSdrUndo;
pSdrObjCached = pSdrObj;
}
aResult = sSdrObjCachedComment;
}
else
aResult = SW_RES(STR_GRAPHIC);
return aResult;
}
IMapObject* SwFrmFmt::GetIMapObject( const Point& rPoint,
const SwFlyFrm *pFly ) const
{
const SwFmtURL &rURL = GetURL();
if( !rURL.GetMap() )
return 0;
if( !pFly )
{
pFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement( *this );
if( !pFly )
return 0;
}
//Orignialgroesse fuer OLE und Grafik ist die TwipSize,
//ansonsten die Groesse vom FrmFmt des Fly.
const SwFrm *pRef;
SwNoTxtNode *pNd = 0;
Size aOrigSz;
if( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
{
pRef = pFly->Lower();
pNd = ((SwCntntFrm*)pRef)->GetNode()->GetNoTxtNode();
aOrigSz = pNd->GetTwipSize();
}
else
{
pRef = pFly;
aOrigSz = pFly->GetFmt()->GetFrmSize().GetSize();
}
if( aOrigSz.Width() != 0 && aOrigSz.Height() != 0 )
{
Point aPos( rPoint );
Size aActSz ( pRef == pFly ? pFly->Frm().SSize() : pRef->Prt().SSize() );
const MapMode aSrc ( MAP_TWIP );
const MapMode aDest( MAP_100TH_MM );
aOrigSz = OutputDevice::LogicToLogic( aOrigSz, aSrc, aDest );
aActSz = OutputDevice::LogicToLogic( aActSz, aSrc, aDest );
aPos -= pRef->Frm().Pos();
aPos -= pRef->Prt().Pos();
aPos = OutputDevice::LogicToLogic( aPos, aSrc, aDest );
sal_uInt32 nFlags = 0;
if ( pFly != pRef && pNd->IsGrfNode() )
{
const sal_uInt16 nMirror = pNd->GetSwAttrSet().
GetMirrorGrf().GetValue();
if ( RES_MIRROR_GRAPH_BOTH == nMirror )
nFlags = IMAP_MIRROR_HORZ | IMAP_MIRROR_VERT;
else if ( RES_MIRROR_GRAPH_VERT == nMirror )
nFlags = IMAP_MIRROR_VERT;
else if ( RES_MIRROR_GRAPH_HOR == nMirror )
nFlags = IMAP_MIRROR_HORZ;
}
return ((ImageMap*)rURL.GetMap())->GetHitIMapObject( aOrigSz,
aActSz, aPos, nFlags );
}
return 0;
}
sal_Bool SwFrmFmt::HasCaption() const
{
if(pCaptionFmt != NULL && pCaptionFmt->GetDepends())
return sal_True;
return sal_False;
}
void SwFrmFmt::SetCaptionFmt(SwFrmFmt * pFmt)
{
pCaptionFmt = pFmt;
}
SwFrmFmt* SwFrmFmt::GetCaptionFmt() const
{
return pCaptionFmt;
}