LCOV - code coverage report
Current view: top level - sw/source/core/layout - atrfrm.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 1614 0.0 %
Date: 2014-04-14 Functions: 0 230 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <com/sun/star/text/WrapTextMode.hpp>
      21             : #include <com/sun/star/text/TextContentAnchorType.hpp>
      22             : #include <com/sun/star/container/XIndexContainer.hpp>
      23             : #include <com/sun/star/text/TextGridMode.hpp>
      24             : #include <svtools/unoimap.hxx>
      25             : #include <svtools/imap.hxx>
      26             : #include <svtools/imapobj.hxx>
      27             : #include <unosett.hxx>
      28             : #include <unostyle.hxx>
      29             : #include <fmtclds.hxx>
      30             : #include <fmtornt.hxx>
      31             : #include <fmthdft.hxx>
      32             : #include <fmtpdsc.hxx>
      33             : #include <fmtcntnt.hxx>
      34             : #include <fmtfsize.hxx>
      35             : #include <fmtfordr.hxx>
      36             : #include <fmtsrnd.hxx>
      37             : #include <fmtlsplt.hxx>
      38             : #include <fmtrowsplt.hxx>
      39             : #include <fmtftntx.hxx>
      40             : #include <fmteiro.hxx>
      41             : #include <fmturl.hxx>
      42             : #include <fmtcnct.hxx>
      43             : #include <section.hxx>
      44             : #include <fmtline.hxx>
      45             : #include <tgrditem.hxx>
      46             : #include <hfspacingitem.hxx>
      47             : #include <IDocumentUndoRedo.hxx>
      48             : #include <pagefrm.hxx>
      49             : #include <rootfrm.hxx>
      50             : #include <cntfrm.hxx>
      51             : #include <crsrsh.hxx>
      52             : #include <dflyobj.hxx>
      53             : #include <dcontact.hxx>
      54             : #include <frmtool.hxx>
      55             : #include <flyfrms.hxx>
      56             : #include <pagedesc.hxx>
      57             : #include <grfatr.hxx>
      58             : #include <ndnotxt.hxx>
      59             : #include <docary.hxx>
      60             : #include <node2lay.hxx>
      61             : #include <fmtclbl.hxx>
      62             : #include <swunohelper.hxx>
      63             : #include <unoframe.hxx>
      64             : #include <unotextbodyhf.hxx>
      65             : #include <SwStyleNameMapper.hxx>
      66             : #include <editeng/brushitem.hxx>
      67             : #include <svtools/grfmgr.hxx>
      68             : #include <unomid.h>
      69             : #include <comcore.hrc>
      70             : #include <svx/svdundo.hxx>
      71             : #include <sortedobjs.hxx>
      72             : #include <HandleAnchorNodeChg.hxx>
      73             : #include <switerator.hxx>
      74             : #include <pagedeschint.hxx>
      75             : #ifndef NDEBUG
      76             : #include <ndtxt.hxx>
      77             : #endif
      78             : 
      79             : //UUUU
      80             : #include <fillattributes.hxx>
      81             : #include <svx/xfillit0.hxx>
      82             : #include <svl/itemiter.hxx>
      83             : 
      84             : using namespace ::com::sun::star;
      85             : 
      86           0 : TYPEINIT1(SwFmtVertOrient, SfxPoolItem);
      87           0 : TYPEINIT1(SwFmtHoriOrient, SfxPoolItem);
      88           0 : TYPEINIT2(SwFmtHeader,  SfxPoolItem, SwClient );
      89           0 : TYPEINIT2(SwFmtFooter,  SfxPoolItem, SwClient );
      90           0 : TYPEINIT2(SwFmtPageDesc,  SfxPoolItem, SwClient );
      91           0 : TYPEINIT1_AUTOFACTORY(SwFmtLineNumber, SfxPoolItem);
      92             : 
      93           0 : static sal_Int16 lcl_IntToRelation(const uno::Any& rVal)
      94             : {
      95           0 :     sal_Int16 nVal = text::RelOrientation::FRAME;
      96           0 :     if (!(rVal >>= nVal))
      97             :         SAL_WARN("sw.core", "lcl_IntToRelation: read from Any failed!");
      98           0 :     return nVal;
      99             : }
     100             : 
     101           0 : void DelHFFormat( SwClient *pToRemove, SwFrmFmt *pFmt )
     102             : {
     103             :     //If the client is the last one who uses this format, then we have to delete
     104             :     //it - before this is done, we may need to delete the content-section.
     105           0 :     SwDoc* pDoc = pFmt->GetDoc();
     106           0 :     pFmt->Remove( pToRemove );
     107           0 :     if( pDoc->IsInDtor() )
     108             :     {
     109           0 :         delete pFmt;
     110           0 :         return;
     111             :     }
     112             : 
     113             :     // Anything other than frames registered?
     114           0 :     bool bDel = true;
     115             :     {
     116             :         // nested scope because DTOR of SwClientIter resets the flag bTreeChg.
     117             :         // It's suboptimal if the format is deleted beforehand.
     118           0 :         SwClientIter aIter( *pFmt );        // TODO
     119           0 :         SwClient *pLast = aIter.GoStart();
     120           0 :         if( pLast )
     121           0 :             do {
     122           0 :                 bDel = pLast->IsA( TYPE(SwFrm) )
     123           0 :                     || SwXHeadFootText::IsXHeadFootText(pLast);
     124           0 :             } while( bDel && 0 != ( pLast = ++aIter ));
     125             :     }
     126             : 
     127           0 :     if ( bDel )
     128             :     {
     129             :         // If there is a Crsr registered in one of the nodes, we need to call the
     130             :         // ParkCrsr in an (arbitrary) shell.
     131           0 :         SwFmtCntnt& rCnt = (SwFmtCntnt&)pFmt->GetCntnt();
     132           0 :         if ( rCnt.GetCntntIdx() )
     133             :         {
     134           0 :             SwNode *pNode = 0;
     135             :             {
     136             :                 // #i92993#
     137             :                 // Begin with start node of page header/footer to assure that
     138             :                 // complete content is checked for cursors and the complete content
     139             :                 // is deleted on below made method call <pDoc->DeleteSection(pNode)>
     140           0 :                 SwNodeIndex aIdx( *rCnt.GetCntntIdx(), 0 );
     141             :                 // If there is a Crsr registered in one of the nodes, we need to call the
     142             :                 // ParkCrsr in an (arbitrary) shell.
     143           0 :                 pNode = & aIdx.GetNode();
     144           0 :                 sal_uInt32 nEnd = pNode->EndOfSectionIndex();
     145           0 :                 while ( aIdx < nEnd )
     146             :                 {
     147           0 :                     if ( pNode->IsCntntNode() &&
     148           0 :                          ((SwCntntNode*)pNode)->GetDepends() )
     149             :                     {
     150           0 :                         SwCrsrShell *pShell = SwIterator<SwCrsrShell,SwCntntNode>::FirstElement( *(SwCntntNode*)pNode );
     151           0 :                         if( pShell )
     152             :                         {
     153           0 :                             pShell->ParkCrsr( aIdx );
     154           0 :                                 aIdx = nEnd-1;
     155             :                         }
     156             :                     }
     157           0 :                     ++aIdx;
     158           0 :                     pNode = & aIdx.GetNode();
     159           0 :                 }
     160             :             }
     161           0 :             rCnt.SetNewCntntIdx( (const SwNodeIndex*)0 );
     162             : 
     163             :             // When deleting a header/footer-format, we ALWAYS need to disable
     164             :             // the undo function (Bug 31069)
     165           0 :             ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
     166             : 
     167             :             OSL_ENSURE( pNode, "A big problem." );
     168           0 :             pDoc->DeleteSection( pNode );
     169             :         }
     170           0 :         delete pFmt;
     171             :     }
     172             : }
     173             : 
     174             : //  class SwFmtFrmSize
     175             : //  Partially implemented inline in hxx
     176             : 
     177           0 : SwFmtFrmSize::SwFmtFrmSize( SwFrmSize eSize, SwTwips nWidth, SwTwips nHeight )
     178             :     : SfxPoolItem( RES_FRM_SIZE ),
     179             :     m_aSize( nWidth, nHeight ),
     180             :     m_eFrmHeightType( eSize ),
     181           0 :     m_eFrmWidthType( ATT_FIX_SIZE )
     182             : {
     183           0 :     m_nWidthPercent = m_eWidthPercentRelation = m_nHeightPercent = m_eHeightPercentRelation = 0;
     184           0 : }
     185             : 
     186           0 : SwFmtFrmSize& SwFmtFrmSize::operator=( const SwFmtFrmSize& rCpy )
     187             : {
     188           0 :     m_aSize = rCpy.GetSize();
     189           0 :     m_eFrmHeightType = rCpy.GetHeightSizeType();
     190           0 :     m_eFrmWidthType = rCpy.GetWidthSizeType();
     191           0 :     m_nHeightPercent = rCpy.GetHeightPercent();
     192           0 :     m_eHeightPercentRelation  = rCpy.GetHeightPercentRelation();
     193           0 :     m_nWidthPercent  = rCpy.GetWidthPercent();
     194           0 :     m_eWidthPercentRelation  = rCpy.GetWidthPercentRelation();
     195           0 :     return *this;
     196             : }
     197             : 
     198           0 : bool SwFmtFrmSize::operator==( const SfxPoolItem& rAttr ) const
     199             : {
     200             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
     201           0 :     return( m_eFrmHeightType  == ((SwFmtFrmSize&)rAttr).m_eFrmHeightType &&
     202           0 :             m_eFrmWidthType  == ((SwFmtFrmSize&)rAttr).m_eFrmWidthType &&
     203           0 :             m_aSize           == ((SwFmtFrmSize&)rAttr).GetSize()&&
     204           0 :             m_nWidthPercent   == ((SwFmtFrmSize&)rAttr).GetWidthPercent() &&
     205           0 :             m_eWidthPercentRelation == ((SwFmtFrmSize&)rAttr).GetWidthPercentRelation() &&
     206           0 :             m_nHeightPercent  == ((SwFmtFrmSize&)rAttr).GetHeightPercent() &&
     207           0 :             m_eHeightPercentRelation == ((SwFmtFrmSize&)rAttr).GetHeightPercentRelation() );
     208             : }
     209             : 
     210           0 : SfxPoolItem*  SwFmtFrmSize::Clone( SfxItemPool* ) const
     211             : {
     212           0 :     return new SwFmtFrmSize( *this );
     213             : }
     214             : 
     215           0 : bool SwFmtFrmSize::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
     216             : {
     217             :     // here we convert always!
     218           0 :     nMemberId &= ~CONVERT_TWIPS;
     219           0 :     switch ( nMemberId )
     220             :     {
     221             :         case MID_FRMSIZE_SIZE:
     222             :         {
     223           0 :             awt::Size aTmp;
     224           0 :             aTmp.Height = convertTwipToMm100(m_aSize.Height());
     225           0 :             aTmp.Width = convertTwipToMm100(m_aSize.Width());
     226           0 :             rVal.setValue(&aTmp, ::getCppuType((const awt::Size*)0));
     227             :         }
     228           0 :         break;
     229             :         case MID_FRMSIZE_REL_HEIGHT:
     230           0 :             rVal <<= (sal_Int16)(GetHeightPercent() != 0xFF ? GetHeightPercent() : 0);
     231           0 :         break;
     232             :         case MID_FRMSIZE_REL_HEIGHT_RELATION:
     233           0 :             rVal <<= GetHeightPercentRelation();
     234           0 :         break;
     235             :         case MID_FRMSIZE_REL_WIDTH:
     236           0 :             rVal <<= (sal_Int16)(GetWidthPercent() != 0xFF ? GetWidthPercent() : 0);
     237           0 :         break;
     238             :         case MID_FRMSIZE_REL_WIDTH_RELATION:
     239           0 :             rVal <<= GetWidthPercentRelation();
     240           0 :         break;
     241             :         case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
     242             :         {
     243           0 :             sal_Bool bTmp = 0xFF == GetHeightPercent();
     244           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
     245             :         }
     246           0 :         break;
     247             :         case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
     248             :         {
     249           0 :             sal_Bool bTmp = 0xFF == GetWidthPercent();
     250           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
     251             :         }
     252           0 :         break;
     253             :         case MID_FRMSIZE_WIDTH :
     254           0 :             rVal <<= (sal_Int32)convertTwipToMm100(m_aSize.Width());
     255           0 :         break;
     256             :         case MID_FRMSIZE_HEIGHT:
     257             :             // #95848# returned size should never be zero.
     258             :             // (there was a bug that allowed for setting height to 0.
     259             :             // Thus there some documents existing with that not allowed
     260             :             // attribut value which may cause problems on import.)
     261           0 :             rVal <<= (sal_Int32)convertTwipToMm100(m_aSize.Height() < MINLAY ? MINLAY : m_aSize.Height() );
     262           0 :         break;
     263             :         case MID_FRMSIZE_SIZE_TYPE:
     264           0 :             rVal <<= (sal_Int16)GetHeightSizeType();
     265           0 :         break;
     266             :         case MID_FRMSIZE_IS_AUTO_HEIGHT:
     267             :         {
     268           0 :             sal_Bool bTmp = ATT_FIX_SIZE != GetHeightSizeType();
     269           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
     270             :         }
     271           0 :         break;
     272             :         case MID_FRMSIZE_WIDTH_TYPE:
     273           0 :             rVal <<= (sal_Int16)GetWidthSizeType();
     274           0 :         break;
     275             :     }
     276           0 :     return true;
     277             : }
     278             : 
     279           0 : bool SwFmtFrmSize::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
     280             : {
     281           0 :     bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
     282           0 :     nMemberId &= ~CONVERT_TWIPS;
     283           0 :     bool bRet = true;
     284           0 :     switch ( nMemberId )
     285             :     {
     286             :         case MID_FRMSIZE_SIZE:
     287             :         {
     288           0 :             awt::Size aVal;
     289           0 :             if(!(rVal >>= aVal))
     290           0 :                 bRet = false;
     291             :             else
     292             :             {
     293           0 :                 Size aTmp(aVal.Width, aVal.Height);
     294           0 :                 if(bConvert)
     295             :                 {
     296           0 :                     aTmp.Height() = convertMm100ToTwip(aTmp.Height());
     297           0 :                     aTmp.Width() = convertMm100ToTwip(aTmp.Width());
     298             :                 }
     299           0 :                 if(aTmp.Height() && aTmp.Width())
     300           0 :                     m_aSize = aTmp;
     301             :                 else
     302           0 :                     bRet = false;
     303             :             }
     304             :         }
     305           0 :         break;
     306             :         case MID_FRMSIZE_REL_HEIGHT:
     307             :         {
     308           0 :             sal_Int16 nSet = 0;
     309           0 :             rVal >>= nSet;
     310           0 :             if(nSet >= 0 && nSet <= 0xfe)
     311           0 :                 SetHeightPercent((sal_uInt8)nSet);
     312             :             else
     313           0 :                 bRet = false;
     314             :         }
     315           0 :         break;
     316             :         case MID_FRMSIZE_REL_HEIGHT_RELATION:
     317             :         {
     318           0 :             sal_Int16 eSet = 0;
     319           0 :             rVal >>= eSet;
     320           0 :             SetHeightPercentRelation(eSet);
     321             :         }
     322           0 :         break;
     323             :         case MID_FRMSIZE_REL_WIDTH:
     324             :         {
     325           0 :             sal_Int16 nSet = 0;
     326           0 :             rVal >>= nSet;
     327           0 :             if(nSet >= 0 && nSet <= 0xfe)
     328           0 :                 SetWidthPercent((sal_uInt8)nSet);
     329             :             else
     330           0 :                 bRet = false;
     331             :         }
     332           0 :         break;
     333             :         case MID_FRMSIZE_REL_WIDTH_RELATION:
     334             :         {
     335           0 :             sal_Int16 eSet = 0;
     336           0 :             rVal >>= eSet;
     337           0 :             SetWidthPercentRelation(eSet);
     338             :         }
     339           0 :         break;
     340             :         case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH:
     341             :         {
     342           0 :             sal_Bool bSet = *(sal_Bool*)rVal.getValue();
     343           0 :             if(bSet)
     344           0 :                 SetHeightPercent(0xff);
     345           0 :             else if( 0xff == GetHeightPercent() )
     346           0 :                 SetHeightPercent( 0 );
     347             :         }
     348           0 :         break;
     349             :         case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT:
     350             :         {
     351           0 :             sal_Bool bSet = *(sal_Bool*)rVal.getValue();
     352           0 :             if(bSet)
     353           0 :                 SetWidthPercent(0xff);
     354           0 :             else if( 0xff == GetWidthPercent() )
     355           0 :                 SetWidthPercent(0);
     356             :         }
     357           0 :         break;
     358             :         case MID_FRMSIZE_WIDTH :
     359             :         {
     360           0 :             sal_Int32 nWd = 0;
     361           0 :             if(rVal >>= nWd)
     362             :             {
     363           0 :                 if(bConvert)
     364           0 :                     nWd = convertMm100ToTwip(nWd);
     365           0 :                 if(nWd < MINLAY)
     366           0 :                    nWd = MINLAY;
     367           0 :                 m_aSize.Width() = nWd;
     368             :             }
     369             :             else
     370           0 :                 bRet = false;
     371             :         }
     372           0 :         break;
     373             :         case MID_FRMSIZE_HEIGHT:
     374             :         {
     375           0 :             sal_Int32 nHg = 0;
     376           0 :             if(rVal >>= nHg)
     377             :             {
     378           0 :                 if(bConvert)
     379           0 :                     nHg = convertMm100ToTwip(nHg);
     380           0 :                 if(nHg < MINLAY)
     381           0 :                     nHg = MINLAY;
     382           0 :                 m_aSize.Height() = nHg;
     383             :             }
     384             :             else
     385           0 :                 bRet = false;
     386             :         }
     387           0 :         break;
     388             :         case MID_FRMSIZE_SIZE_TYPE:
     389             :         {
     390           0 :             sal_Int16 nType = 0;
     391           0 :             if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
     392             :             {
     393           0 :                 SetHeightSizeType((SwFrmSize)nType);
     394             :             }
     395             :             else
     396           0 :                 bRet = false;
     397             :         }
     398           0 :         break;
     399             :         case MID_FRMSIZE_IS_AUTO_HEIGHT:
     400             :         {
     401           0 :             sal_Bool bSet = *(sal_Bool*)rVal.getValue();
     402           0 :             SetHeightSizeType(bSet ? ATT_VAR_SIZE : ATT_FIX_SIZE);
     403             :         }
     404           0 :         break;
     405             :         case MID_FRMSIZE_WIDTH_TYPE:
     406             :         {
     407           0 :             sal_Int16 nType = 0;
     408           0 :             if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE )
     409             :             {
     410           0 :                 SetWidthSizeType((SwFrmSize)nType);
     411             :             }
     412             :             else
     413           0 :                 bRet = false;
     414             :         }
     415           0 :         break;
     416             :         default:
     417           0 :             bRet = false;
     418             :     }
     419           0 :     return bRet;
     420             : }
     421             : 
     422             : //  class SwFmtFillOrder
     423             : //  Partially implemented inline in hxx
     424             : 
     425           0 : SwFmtFillOrder::SwFmtFillOrder( SwFillOrder nFO )
     426           0 :     : SfxEnumItem( RES_FILL_ORDER, sal_uInt16(nFO) )
     427           0 : {}
     428             : 
     429           0 : SfxPoolItem*  SwFmtFillOrder::Clone( SfxItemPool* ) const
     430             : {
     431           0 :     return new SwFmtFillOrder( GetFillOrder() );
     432             : }
     433             : 
     434           0 : sal_uInt16  SwFmtFillOrder::GetValueCount() const
     435             : {
     436           0 :     return SW_FILL_ORDER_END - SW_FILL_ORDER_BEGIN;
     437             : }
     438             : 
     439             : //  class SwFmtHeader
     440             : //  Partially implemented inline in hxx
     441             : 
     442           0 : SwFmtHeader::SwFmtHeader( SwFrmFmt *pHeaderFmt )
     443             :     : SfxPoolItem( RES_HEADER ),
     444             :     SwClient( pHeaderFmt ),
     445           0 :     bActive( pHeaderFmt ? sal_True : sal_False )
     446             : {
     447           0 : }
     448             : 
     449           0 : SwFmtHeader::SwFmtHeader( const SwFmtHeader &rCpy )
     450             :     : SfxPoolItem( RES_HEADER ),
     451           0 :     SwClient( (SwModify*)rCpy.GetRegisteredIn() ),
     452           0 :     bActive( rCpy.IsActive() )
     453             : {
     454           0 : }
     455             : 
     456           0 : SwFmtHeader::SwFmtHeader( sal_Bool bOn )
     457             :     : SfxPoolItem( RES_HEADER ),
     458             :     SwClient( 0 ),
     459           0 :     bActive( bOn )
     460             : {
     461           0 : }
     462             : 
     463           0 :  SwFmtHeader::~SwFmtHeader()
     464             : {
     465           0 :     if ( GetHeaderFmt() )
     466           0 :         DelHFFormat( this, GetHeaderFmt() );
     467           0 : }
     468             : 
     469           0 : bool SwFmtHeader::operator==( const SfxPoolItem& rAttr ) const
     470             : {
     471             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
     472           0 :     return ( GetRegisteredIn() == ((SwFmtHeader&)rAttr).GetRegisteredIn() &&
     473           0 :              bActive == ((SwFmtHeader&)rAttr).IsActive() );
     474             : }
     475             : 
     476           0 : SfxPoolItem*  SwFmtHeader::Clone( SfxItemPool* ) const
     477             : {
     478           0 :     return new SwFmtHeader( *this );
     479             : }
     480             : 
     481           0 : void SwFmtHeader::RegisterToFormat( SwFmt& rFmt )
     482             : {
     483           0 :     rFmt.Add(this);
     484           0 : }
     485             : 
     486             : //  class SwFmtFooter
     487             : //  Partially implemented inline in hxx
     488             : 
     489           0 : SwFmtFooter::SwFmtFooter( SwFrmFmt *pFooterFmt )
     490             :     : SfxPoolItem( RES_FOOTER ),
     491             :     SwClient( pFooterFmt ),
     492           0 :     bActive( pFooterFmt ? sal_True : sal_False )
     493             : {
     494           0 : }
     495             : 
     496           0 : SwFmtFooter::SwFmtFooter( const SwFmtFooter &rCpy )
     497             :     : SfxPoolItem( RES_FOOTER ),
     498           0 :     SwClient( (SwModify*)rCpy.GetRegisteredIn() ),
     499           0 :     bActive( rCpy.IsActive() )
     500             : {
     501           0 : }
     502             : 
     503           0 : SwFmtFooter::SwFmtFooter( sal_Bool bOn )
     504             :     : SfxPoolItem( RES_FOOTER ),
     505             :     SwClient( 0 ),
     506           0 :     bActive( bOn )
     507             : {
     508           0 : }
     509             : 
     510           0 :  SwFmtFooter::~SwFmtFooter()
     511             : {
     512           0 :     if ( GetFooterFmt() )
     513           0 :         DelHFFormat( this, GetFooterFmt() );
     514           0 : }
     515             : 
     516           0 : void SwFmtFooter::RegisterToFormat( SwFmt& rFmt )
     517             : {
     518           0 :     rFmt.Add(this);
     519           0 : }
     520             : 
     521           0 : bool SwFmtFooter::operator==( const SfxPoolItem& rAttr ) const
     522             : {
     523             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
     524           0 :     return ( GetRegisteredIn() == ((SwFmtFooter&)rAttr).GetRegisteredIn() &&
     525           0 :              bActive == ((SwFmtFooter&)rAttr).IsActive() );
     526             : }
     527             : 
     528           0 : SfxPoolItem*  SwFmtFooter::Clone( SfxItemPool* ) const
     529             : {
     530           0 :     return new SwFmtFooter( *this );
     531             : }
     532             : 
     533             : //  class SwFmtCntnt
     534             : //  Partially implemented inline in hxx
     535             : 
     536           0 : SwFmtCntnt::SwFmtCntnt( const SwFmtCntnt &rCpy )
     537           0 :     : SfxPoolItem( RES_CNTNT )
     538             : {
     539           0 :     pStartNode = rCpy.GetCntntIdx() ?
     540           0 :                     new SwNodeIndex( *rCpy.GetCntntIdx() ) : 0;
     541           0 : }
     542             : 
     543           0 : SwFmtCntnt::SwFmtCntnt( const SwStartNode *pStartNd )
     544           0 :     : SfxPoolItem( RES_CNTNT )
     545             : {
     546           0 :     pStartNode = pStartNd ? new SwNodeIndex( *pStartNd ) : 0;
     547           0 : }
     548             : 
     549           0 :  SwFmtCntnt::~SwFmtCntnt()
     550             : {
     551           0 :     delete pStartNode;
     552           0 : }
     553             : 
     554           0 : void SwFmtCntnt::SetNewCntntIdx( const SwNodeIndex *pIdx )
     555             : {
     556           0 :     delete pStartNode;
     557           0 :     pStartNode = pIdx ? new SwNodeIndex( *pIdx ) : 0;
     558           0 : }
     559             : 
     560           0 : bool SwFmtCntnt::operator==( const SfxPoolItem& rAttr ) const
     561             : {
     562             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
     563           0 :     if( (sal_IntPtr)pStartNode ^ (sal_IntPtr)((SwFmtCntnt&)rAttr).pStartNode )
     564           0 :         return false;
     565           0 :     if( pStartNode )
     566           0 :         return ( *pStartNode == *((SwFmtCntnt&)rAttr).GetCntntIdx() );
     567           0 :     return true;
     568             : }
     569             : 
     570           0 : SfxPoolItem*  SwFmtCntnt::Clone( SfxItemPool* ) const
     571             : {
     572           0 :     return new SwFmtCntnt( *this );
     573             : }
     574             : 
     575             : //  class SwFmtPageDesc
     576             : //  Partially implemented inline in hxx
     577             : 
     578           0 : SwFmtPageDesc::SwFmtPageDesc( const SwFmtPageDesc &rCpy )
     579             :     : SfxPoolItem( RES_PAGEDESC ),
     580           0 :     SwClient( (SwPageDesc*)rCpy.GetPageDesc() ),
     581             :     oNumOffset( rCpy.oNumOffset ),
     582             :     nDescNameIdx( rCpy.nDescNameIdx ),
     583           0 :     pDefinedIn( 0 )
     584             : {
     585           0 : }
     586             : 
     587           0 : SwFmtPageDesc::SwFmtPageDesc( const SwPageDesc *pDesc )
     588             :     : SfxPoolItem( RES_PAGEDESC ),
     589             :     SwClient( (SwPageDesc*)pDesc ),
     590             :     nDescNameIdx( 0xFFFF ), // IDX_NO_VALUE
     591           0 :     pDefinedIn( 0 )
     592             : {
     593           0 : }
     594             : 
     595           0 : SwFmtPageDesc &SwFmtPageDesc::operator=(const SwFmtPageDesc &rCpy)
     596             : {
     597           0 :     if (rCpy.GetPageDesc())
     598           0 :         RegisterToPageDesc(*const_cast<SwPageDesc*>(rCpy.GetPageDesc()));
     599           0 :     oNumOffset = rCpy.oNumOffset;
     600           0 :     nDescNameIdx = rCpy.nDescNameIdx;
     601           0 :     pDefinedIn = 0;
     602             : 
     603           0 :     return *this;
     604             : }
     605             : 
     606           0 :  SwFmtPageDesc::~SwFmtPageDesc() {}
     607             : 
     608           0 : bool SwFmtPageDesc::KnowsPageDesc() const
     609             : {
     610           0 :     return (GetRegisteredIn() != 0);
     611             : }
     612             : 
     613           0 : bool SwFmtPageDesc::operator==( const SfxPoolItem& rAttr ) const
     614             : {
     615             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
     616           0 :     return  ( pDefinedIn == ((SwFmtPageDesc&)rAttr).pDefinedIn ) &&
     617           0 :             ( oNumOffset == ((SwFmtPageDesc&)rAttr).oNumOffset ) &&
     618           0 :             ( GetPageDesc() == ((SwFmtPageDesc&)rAttr).GetPageDesc() );
     619             : }
     620             : 
     621           0 : SfxPoolItem*  SwFmtPageDesc::Clone( SfxItemPool* ) const
     622             : {
     623           0 :     return new SwFmtPageDesc( *this );
     624             : }
     625             : 
     626           0 : void SwFmtPageDesc::SwClientNotify( const SwModify&, const SfxHint& rHint )
     627             : {
     628           0 :     const SwPageDescHint* pHint = dynamic_cast<const SwPageDescHint*>(&rHint);
     629           0 :     if ( pHint )
     630             :     {
     631             :         // mba: shouldn't that be broadcasted also?
     632           0 :         SwFmtPageDesc aDfltDesc( pHint->GetPageDesc() );
     633           0 :         SwPageDesc* pDesc = pHint->GetPageDesc();
     634           0 :         const SwModify* pMod = GetDefinedIn();
     635           0 :         if ( pMod )
     636             :         {
     637           0 :             if( pMod->ISA( SwCntntNode ) )
     638           0 :                 ((SwCntntNode*)pMod)->SetAttr( aDfltDesc );
     639           0 :             else if( pMod->ISA( SwFmt ))
     640           0 :                 ((SwFmt*)pMod)->SetFmtAttr( aDfltDesc );
     641             :             else
     642             :             {
     643             :                 OSL_FAIL( "What kind of SwModify is this?" );
     644           0 :                 RegisterToPageDesc( *pDesc );
     645             :             }
     646             :         }
     647             :         else
     648             :             // there could be an Undo-copy
     649           0 :             RegisterToPageDesc( *pDesc );
     650             :     }
     651           0 : }
     652             : 
     653           0 : void SwFmtPageDesc::RegisterToPageDesc( SwPageDesc& rDesc )
     654             : {
     655           0 :     rDesc.Add( this );
     656           0 : }
     657             : 
     658           0 : void SwFmtPageDesc::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
     659             : {
     660           0 :     if( !pDefinedIn )
     661           0 :         return;
     662             : 
     663           0 :     const sal_uInt16 nWhichId = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
     664           0 :     switch( nWhichId )
     665             :     {
     666             :         case RES_OBJECTDYING:
     667             :                 //The Pagedesc where I'm registered dies, therefore I unregister
     668             :                 //from that format. During this I get deleted!
     669           0 :             if( IS_TYPE( SwFmt, pDefinedIn ))
     670             :             {
     671             :                 bool const bResult =
     672           0 :                     static_cast<SwFmt*>(pDefinedIn)->ResetFmtAttr(RES_PAGEDESC);
     673             :                 OSL_ENSURE( bResult, "FmtPageDesc not deleted" );
     674             :                 (void) bResult; // unused in non-debug
     675             :             }
     676           0 :             else if( IS_TYPE( SwCntntNode, pDefinedIn ))
     677             :             {
     678             :                 bool const bResult = static_cast<SwCntntNode*>(pDefinedIn)
     679           0 :                         ->ResetAttr(RES_PAGEDESC);
     680             :                 OSL_ENSURE( bResult, "FmtPageDesc not deleted" );
     681             :                 (void) bResult; // unused in non-debug
     682             :             }
     683           0 :             break;
     684             : 
     685             :         default:
     686             :             /* do nothing */;
     687             :     }
     688             : }
     689             : 
     690           0 : bool SwFmtPageDesc::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
     691             : {
     692             :     // here we convert always!
     693           0 :     nMemberId &= ~CONVERT_TWIPS;
     694           0 :     bool    bRet = true;
     695           0 :     switch ( nMemberId )
     696             :     {
     697             :         case MID_PAGEDESC_PAGENUMOFFSET:
     698             :             {
     699           0 :                 ::boost::optional<sal_uInt16> oOffset = GetNumOffset();
     700           0 :                 if (oOffset)
     701             :                 {
     702           0 :                     rVal <<= (sal_Int16)oOffset.get();
     703             :                 }
     704             :                 else
     705             :                 {
     706           0 :                     rVal.clear();
     707           0 :                 }
     708             :             }
     709           0 :             break;
     710             : 
     711             :         case MID_PAGEDESC_PAGEDESCNAME:
     712             :             {
     713           0 :                 const SwPageDesc* pDesc = GetPageDesc();
     714           0 :                 if( pDesc )
     715             :                 {
     716           0 :                     OUString aString;
     717           0 :                     SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, true );
     718           0 :                     rVal <<= aString;
     719             :                 }
     720             :                 else
     721           0 :                     rVal.clear();
     722             :             }
     723           0 :             break;
     724             :         default:
     725             :             OSL_ENSURE( !this, "unknown MemberId" );
     726           0 :             bRet = false;
     727             :     }
     728           0 :     return bRet;
     729             : }
     730             : 
     731           0 : bool SwFmtPageDesc::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
     732             : {
     733             :     // here we convert always!
     734           0 :     nMemberId &= ~CONVERT_TWIPS;
     735           0 :     bool bRet = true;
     736           0 :     switch ( nMemberId )
     737             :     {
     738             :         case MID_PAGEDESC_PAGENUMOFFSET:
     739             :         {
     740           0 :             sal_Int16 nOffset = 0;
     741           0 :             if (!rVal.hasValue())
     742             :             {
     743           0 :                 SetNumOffset(boost::none);
     744             :             }
     745           0 :             else if (rVal >>= nOffset)
     746           0 :                 SetNumOffset( nOffset );
     747             :             else
     748           0 :                 bRet = false;
     749             :         }
     750           0 :         break;
     751             : 
     752             :         case MID_PAGEDESC_PAGEDESCNAME:
     753             :             /* Doesn't work, because the attribute doesn't need the name but a
     754             :              * pointer to the PageDesc (it's a client of it). The pointer can
     755             :              * only be requested from the document using the name.
     756             :              */
     757             :         default:
     758             :             OSL_ENSURE( !this, "unknown MemberId" );
     759           0 :             bRet = false;
     760             :     }
     761           0 :     return bRet;
     762             : }
     763             : 
     764             : //  class SwFmtCol
     765             : //  Partially implemented inline in hxx
     766             : 
     767           0 : SwColumn::SwColumn() :
     768             :     nWish ( 0 ),
     769             :     nUpper( 0 ),
     770             :     nLower( 0 ),
     771             :     nLeft ( 0 ),
     772           0 :     nRight( 0 )
     773             : {
     774           0 : }
     775             : 
     776           0 : sal_Bool SwColumn::operator==( const SwColumn &rCmp ) const
     777             : {
     778           0 :     return (nWish    == rCmp.GetWishWidth() &&
     779           0 :             GetLeft()  == rCmp.GetLeft() &&
     780           0 :             GetRight() == rCmp.GetRight() &&
     781           0 :             GetUpper() == rCmp.GetUpper() &&
     782           0 :             GetLower() == rCmp.GetLower()) ? sal_True : sal_False;
     783             : }
     784             : 
     785           0 : SwFmtCol::SwFmtCol( const SwFmtCol& rCpy )
     786             :     : SfxPoolItem( RES_COL ),
     787             :     eLineStyle( rCpy.eLineStyle ),
     788             :     nLineWidth( rCpy.nLineWidth),
     789             :     aLineColor( rCpy.aLineColor),
     790           0 :     nLineHeight( rCpy.GetLineHeight() ),
     791           0 :     eAdj( rCpy.GetLineAdj() ),
     792           0 :     aColumns( (sal_Int8)rCpy.GetNumCols() ),
     793           0 :     nWidth( rCpy.GetWishWidth() ),
     794             :     aWidthAdjustValue( rCpy.aWidthAdjustValue ),
     795           0 :     bOrtho( rCpy.IsOrtho() )
     796             : {
     797           0 :     for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
     798             :     {
     799           0 :         SwColumn *pCol = new SwColumn( rCpy.GetColumns()[i] );
     800           0 :         aColumns.push_back( pCol );
     801             :     }
     802           0 : }
     803             : 
     804           0 : SwFmtCol::~SwFmtCol() {}
     805             : 
     806           0 : SwFmtCol& SwFmtCol::operator=( const SwFmtCol& rCpy )
     807             : {
     808           0 :     eLineStyle  = rCpy.eLineStyle;
     809           0 :     nLineWidth  = rCpy.nLineWidth;
     810           0 :     aLineColor  = rCpy.aLineColor;
     811           0 :     nLineHeight = rCpy.GetLineHeight();
     812           0 :     eAdj        = rCpy.GetLineAdj();
     813           0 :     nWidth      = rCpy.GetWishWidth();
     814           0 :     aWidthAdjustValue = rCpy.aWidthAdjustValue;
     815           0 :     bOrtho      = rCpy.IsOrtho();
     816             : 
     817           0 :     if ( !aColumns.empty() )
     818           0 :         aColumns.clear();
     819           0 :     for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i )
     820             :     {
     821           0 :         SwColumn *pCol = new SwColumn( rCpy.GetColumns()[i] );
     822           0 :         aColumns.push_back( pCol );
     823             :     }
     824           0 :     return *this;
     825             : }
     826             : 
     827           0 : SwFmtCol::SwFmtCol()
     828             :     : SfxPoolItem( RES_COL )
     829             :     , eLineStyle( table::BorderLineStyle::NONE)
     830             :     ,
     831             :     nLineWidth(0),
     832             :     nLineHeight( 100 ),
     833             :     eAdj( COLADJ_NONE ),
     834             :     nWidth( USHRT_MAX ),
     835             :     aWidthAdjustValue( 0 ),
     836           0 :     bOrtho( sal_True )
     837             : {
     838           0 : }
     839             : 
     840           0 : bool SwFmtCol::operator==( const SfxPoolItem& rAttr ) const
     841             : {
     842             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "no equal attributes" );
     843           0 :     const SwFmtCol &rCmp = (const SwFmtCol&)rAttr;
     844           0 :     if( !(eLineStyle        == rCmp.eLineStyle  &&
     845           0 :           nLineWidth        == rCmp.nLineWidth  &&
     846           0 :           aLineColor        == rCmp.aLineColor  &&
     847           0 :           nLineHeight        == rCmp.GetLineHeight() &&
     848           0 :           eAdj               == rCmp.GetLineAdj() &&
     849           0 :           nWidth             == rCmp.GetWishWidth() &&
     850           0 :           bOrtho             == rCmp.IsOrtho() &&
     851           0 :           aColumns.size() == rCmp.GetNumCols() &&
     852           0 :           aWidthAdjustValue == rCmp.GetAdjustValue()
     853           0 :          ) )
     854           0 :         return false;
     855             : 
     856           0 :     for ( sal_uInt16 i = 0; i < aColumns.size(); ++i )
     857           0 :         if ( !(aColumns[i] == rCmp.GetColumns()[i]) )
     858           0 :             return false;
     859             : 
     860           0 :     return true;
     861             : }
     862             : 
     863           0 : SfxPoolItem*  SwFmtCol::Clone( SfxItemPool* ) const
     864             : {
     865           0 :     return new SwFmtCol( *this );
     866             : }
     867             : 
     868           0 : sal_uInt16 SwFmtCol::GetGutterWidth( sal_Bool bMin ) const
     869             : {
     870           0 :     sal_uInt16 nRet = 0;
     871           0 :     if ( aColumns.size() == 2 )
     872           0 :         nRet = aColumns[0].GetRight() + aColumns[1].GetLeft();
     873           0 :     else if ( aColumns.size() > 2 )
     874             :     {
     875           0 :         bool bSet = false;
     876           0 :         for ( sal_uInt16 i = 1; i < aColumns.size()-1; ++i )
     877             :         {
     878           0 :             const sal_uInt16 nTmp = aColumns[i].GetRight() + aColumns[i+1].GetLeft();
     879           0 :             if ( bSet )
     880             :             {
     881           0 :                 if ( nTmp != nRet )
     882             :                 {
     883           0 :                     if ( !bMin )
     884           0 :                         return USHRT_MAX;
     885           0 :                     if ( nRet > nTmp )
     886           0 :                         nRet = nTmp;
     887             :                 }
     888             :             }
     889             :             else
     890           0 :             {   bSet = true;
     891           0 :                 nRet = nTmp;
     892             :             }
     893             :         }
     894             :     }
     895           0 :     return nRet;
     896             : }
     897             : 
     898           0 : void SwFmtCol::SetGutterWidth( sal_uInt16 nNew, sal_uInt16 nAct )
     899             : {
     900           0 :     if ( bOrtho )
     901           0 :         Calc( nNew, nAct );
     902             :     else
     903             :     {
     904           0 :         sal_uInt16 nHalf = nNew / 2;
     905           0 :         for ( sal_uInt16 i = 0; i < aColumns.size(); ++i )
     906           0 :         {   SwColumn *pCol = &aColumns[i];
     907           0 :             pCol->SetLeft ( nHalf );
     908           0 :             pCol->SetRight( nHalf );
     909           0 :             if ( i == 0 )
     910           0 :                 pCol->SetLeft( 0 );
     911           0 :             else if ( i == (aColumns.size() - 1) )
     912           0 :                 pCol->SetRight( 0 );
     913             :         }
     914             :     }
     915           0 : }
     916             : 
     917           0 : void SwFmtCol::Init( sal_uInt16 nNumCols, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
     918             : {
     919             :     // Deleting seems to be a bit radical on the first sight; but otherwise we
     920             :     // have to initialize all values of the remaining SwCloumns.
     921           0 :     if ( !aColumns.empty() )
     922           0 :         aColumns.clear();
     923           0 :     for ( sal_uInt16 i = 0; i < nNumCols; ++i )
     924           0 :     {   SwColumn *pCol = new SwColumn;
     925           0 :         aColumns.push_back( pCol );
     926             :     }
     927           0 :     bOrtho = sal_True;
     928           0 :     nWidth = USHRT_MAX;
     929           0 :     if( nNumCols )
     930           0 :         Calc( nGutterWidth, nAct );
     931           0 : }
     932             : 
     933           0 : void SwFmtCol::SetOrtho( sal_Bool bNew, sal_uInt16 nGutterWidth, sal_uInt16 nAct )
     934             : {
     935           0 :     bOrtho = bNew;
     936           0 :     if ( bNew && !aColumns.empty() )
     937           0 :         Calc( nGutterWidth, nAct );
     938           0 : }
     939             : 
     940           0 : sal_uInt16 SwFmtCol::CalcColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
     941             : {
     942             :     assert(nCol < aColumns.size());
     943           0 :     if ( nWidth != nAct )
     944             :     {
     945           0 :         long nW = aColumns[nCol].GetWishWidth();
     946           0 :         nW *= nAct;
     947           0 :         nW /= nWidth;
     948           0 :         return sal_uInt16(nW);
     949             :     }
     950             :     else
     951           0 :         return aColumns[nCol].GetWishWidth();
     952             : }
     953             : 
     954           0 : sal_uInt16 SwFmtCol::CalcPrtColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const
     955             : {
     956             :     assert(nCol < aColumns.size());
     957           0 :     sal_uInt16 nRet = CalcColWidth( nCol, nAct );
     958           0 :     const SwColumn *pCol = &aColumns[nCol];
     959           0 :     nRet = nRet - pCol->GetLeft();
     960           0 :     nRet = nRet - pCol->GetRight();
     961           0 :     return nRet;
     962             : }
     963             : 
     964           0 : void SwFmtCol::Calc( sal_uInt16 nGutterWidth, sal_uInt16 nAct )
     965             : {
     966           0 :     if(!GetNumCols())
     967           0 :         return;
     968             :     //First set the column widths with the current width, then calculate the
     969             :     //column's requested width using the requested total width.
     970             : 
     971           0 :     const sal_uInt16 nGutterHalf = nGutterWidth ? nGutterWidth / 2 : 0;
     972             : 
     973             :     //Width of PrtAreas is totalwidth - spacings / count
     974             :     const sal_uInt16 nPrtWidth =
     975           0 :                 (nAct - ((GetNumCols()-1) * nGutterWidth)) / GetNumCols();
     976           0 :     sal_uInt16 nAvail = nAct;
     977             : 
     978             :     //The fist column is PrtWidth + (gap width / 2)
     979           0 :     const sal_uInt16 nLeftWidth = nPrtWidth + nGutterHalf;
     980           0 :     SwColumn *pCol = &aColumns.front();
     981           0 :     pCol->SetWishWidth( nLeftWidth );
     982           0 :     pCol->SetRight( nGutterHalf );
     983           0 :     pCol->SetLeft ( 0 );
     984           0 :     nAvail = nAvail - nLeftWidth;
     985             : 
     986             :     //Column 2 to n-1 is PrtWidth + gap width
     987           0 :     const sal_uInt16 nMidWidth = nPrtWidth + nGutterWidth;
     988             :     sal_uInt16 i;
     989             : 
     990           0 :     for ( i = 1; i < GetNumCols()-1; ++i )
     991             :     {
     992           0 :         pCol = &aColumns[i];
     993           0 :         pCol->SetWishWidth( nMidWidth );
     994           0 :         pCol->SetLeft ( nGutterHalf );
     995           0 :         pCol->SetRight( nGutterHalf );
     996           0 :         nAvail = nAvail - nMidWidth;
     997             :     }
     998             : 
     999             :     //The last column is equivalent to the first one - to compensate rounding
    1000             :     //errors we add the remaining space of the other columns to the last one.
    1001           0 :     pCol = &aColumns.back();
    1002           0 :     pCol->SetWishWidth( nAvail );
    1003           0 :     pCol->SetLeft ( nGutterHalf );
    1004           0 :     pCol->SetRight( 0 );
    1005             : 
    1006             :     //Convert the current width to the requested width.
    1007           0 :     for ( i = 0; i < aColumns.size(); ++i )
    1008             :     {
    1009           0 :         pCol = &aColumns[i];
    1010           0 :         long nTmp = pCol->GetWishWidth();
    1011           0 :         nTmp *= GetWishWidth();
    1012           0 :         nTmp /= nAct;
    1013           0 :         pCol->SetWishWidth( sal_uInt16(nTmp) );
    1014             :     }
    1015             : }
    1016             : 
    1017           0 : bool SwFmtCol::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1018             : {
    1019             :     // here we convert always!
    1020           0 :     nMemberId &= ~CONVERT_TWIPS;
    1021           0 :     if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
    1022             :     {
    1023             :         OSL_FAIL("not implemented");
    1024             :     }
    1025             :     else
    1026             :     {
    1027           0 :         uno::Reference< text::XTextColumns >  xCols = new SwXTextColumns(*this);
    1028           0 :         rVal.setValue(&xCols, ::getCppuType((uno::Reference< text::XTextColumns>*)0));
    1029             :     }
    1030           0 :     return true;
    1031             : }
    1032             : 
    1033           0 : bool SwFmtCol::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1034             : {
    1035             :     // here we convert always!
    1036           0 :     nMemberId &= ~CONVERT_TWIPS;
    1037           0 :     bool bRet = false;
    1038           0 :     if(MID_COLUMN_SEPARATOR_LINE == nMemberId)
    1039             :     {
    1040             :         OSL_FAIL("not implemented");
    1041             :     }
    1042             :     else
    1043             :     {
    1044           0 :         uno::Reference< text::XTextColumns > xCols;
    1045           0 :         rVal >>= xCols;
    1046           0 :         if(xCols.is())
    1047             :         {
    1048           0 :             uno::Sequence<text::TextColumn> aSetColumns = xCols->getColumns();
    1049           0 :             const text::TextColumn* pArray = aSetColumns.getConstArray();
    1050           0 :             aColumns.clear();
    1051             :             //max count is 64k here - this is something the array can't do
    1052           0 :             sal_uInt16 nCount = std::min( (sal_uInt16)aSetColumns.getLength(),
    1053           0 :                                      (sal_uInt16) 0x3fff );
    1054           0 :             sal_uInt16 nWidthSum = 0;
    1055             :             // #101224# one column is no column
    1056             : 
    1057           0 :             if(nCount > 1)
    1058           0 :                 for(sal_uInt16 i = 0; i < nCount; i++)
    1059             :                 {
    1060           0 :                     SwColumn* pCol = new SwColumn;
    1061           0 :                     pCol->SetWishWidth( static_cast<sal_uInt16>(pArray[i].Width) );
    1062           0 :                     nWidthSum = static_cast<sal_uInt16>(nWidthSum + pArray[i].Width);
    1063           0 :                     pCol->SetLeft ( static_cast<sal_uInt16>(convertMm100ToTwip(pArray[i].LeftMargin)) );
    1064           0 :                     pCol->SetRight( static_cast<sal_uInt16>(convertMm100ToTwip(pArray[i].RightMargin)) );
    1065           0 :                     aColumns.insert(aColumns.begin() + i, pCol);
    1066             :                 }
    1067           0 :             bRet = true;
    1068           0 :             nWidth = nWidthSum;
    1069           0 :             bOrtho = sal_False;
    1070             : 
    1071           0 :             uno::Reference<lang::XUnoTunnel> xNumTunnel(xCols, uno::UNO_QUERY);
    1072           0 :             SwXTextColumns* pSwColums = 0;
    1073           0 :             if(xNumTunnel.is())
    1074             :             {
    1075             :                 pSwColums = reinterpret_cast< SwXTextColumns * >(
    1076             :                     sal::static_int_cast< sal_IntPtr >(
    1077           0 :                     xNumTunnel->getSomething( SwXTextColumns::getUnoTunnelId() )));
    1078             :             }
    1079           0 :             if(pSwColums)
    1080             :             {
    1081           0 :                 bOrtho = pSwColums->IsAutomaticWidth();
    1082           0 :                 nLineWidth = pSwColums->GetSepLineWidth();
    1083           0 :                 aLineColor.SetColor(pSwColums->GetSepLineColor());
    1084           0 :                 nLineHeight = pSwColums->GetSepLineHeightRelative();
    1085           0 :                 switch ( pSwColums->GetSepLineStyle() )
    1086             :                 {
    1087             :                     default:
    1088           0 :                     case 0: eLineStyle = table::BorderLineStyle::NONE; break;
    1089           0 :                     case 1: eLineStyle = table::BorderLineStyle::SOLID; break;
    1090           0 :                     case 2: eLineStyle = table::BorderLineStyle::DOTTED; break;
    1091           0 :                     case 3: eLineStyle = table::BorderLineStyle::DASHED; break;
    1092             :                 }
    1093           0 :                 if(!pSwColums->GetSepLineIsOn())
    1094           0 :                     eAdj = COLADJ_NONE;
    1095           0 :                 else switch(pSwColums->GetSepLineVertAlign())
    1096             :                 {
    1097           0 :                     case 0: eAdj = COLADJ_TOP;  break;  //VerticalAlignment_TOP
    1098           0 :                     case 1: eAdj = COLADJ_CENTER;break; //VerticalAlignment_MIDDLE
    1099           0 :                     case 2: eAdj = COLADJ_BOTTOM;break; //VerticalAlignment_BOTTOM
    1100           0 :                     default: OSL_ENSURE( !this, "unknown alignment" ); break;
    1101             :                 }
    1102           0 :             }
    1103           0 :         }
    1104             :     }
    1105           0 :     return bRet;
    1106             : }
    1107             : 
    1108             : //  class SwFmtSurround
    1109             : //  Partially implemented inline in hxx
    1110             : 
    1111           0 : SwFmtSurround::SwFmtSurround( SwSurround eFly ) :
    1112           0 :     SfxEnumItem( RES_SURROUND, sal_uInt16( eFly ) )
    1113             : {
    1114           0 :     bAnchorOnly = bContour = bOutside = sal_False;
    1115           0 : }
    1116             : 
    1117           0 : SwFmtSurround::SwFmtSurround( const SwFmtSurround &rCpy ) :
    1118           0 :     SfxEnumItem( RES_SURROUND, rCpy.GetValue() )
    1119             : {
    1120           0 :     bAnchorOnly = rCpy.bAnchorOnly;
    1121           0 :     bContour = rCpy.bContour;
    1122           0 :     bOutside = rCpy.bOutside;
    1123           0 : }
    1124             : 
    1125           0 : bool SwFmtSurround::operator==( const SfxPoolItem& rAttr ) const
    1126             : {
    1127             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    1128           0 :     return ( GetValue() == ((SwFmtSurround&)rAttr).GetValue() &&
    1129           0 :              bAnchorOnly== ((SwFmtSurround&)rAttr).bAnchorOnly &&
    1130           0 :              bContour== ((SwFmtSurround&)rAttr).bContour &&
    1131           0 :              bOutside== ((SwFmtSurround&)rAttr).bOutside );
    1132             : }
    1133             : 
    1134           0 : SfxPoolItem*  SwFmtSurround::Clone( SfxItemPool* ) const
    1135             : {
    1136           0 :     return new SwFmtSurround( *this );
    1137             : }
    1138             : 
    1139           0 : sal_uInt16  SwFmtSurround::GetValueCount() const
    1140             : {
    1141           0 :     return SURROUND_END - SURROUND_BEGIN;
    1142             : }
    1143             : 
    1144           0 : bool SwFmtSurround::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1145             : {
    1146             :     // here we convert always!
    1147           0 :     nMemberId &= ~CONVERT_TWIPS;
    1148           0 :     bool bRet = true;
    1149           0 :     switch ( nMemberId )
    1150             :     {
    1151             :         case MID_SURROUND_SURROUNDTYPE:
    1152           0 :                 rVal <<= (text::WrapTextMode)GetSurround();
    1153           0 :         break;
    1154             :         case MID_SURROUND_ANCHORONLY:
    1155             :         {
    1156           0 :             sal_Bool bTmp = IsAnchorOnly();
    1157           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    1158             :         }
    1159           0 :                 break;
    1160             :         case MID_SURROUND_CONTOUR:
    1161             :         {
    1162           0 :             sal_Bool bTmp = IsContour();
    1163           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    1164             :         }
    1165           0 :                 break;
    1166             :         case MID_SURROUND_CONTOUROUTSIDE:
    1167             :         {
    1168           0 :             sal_Bool bTmp = IsOutside();
    1169           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    1170             :         }
    1171           0 :                 break;
    1172             :         default:
    1173             :             OSL_ENSURE( !this, "unknown MemberId" );
    1174           0 :             bRet = false;
    1175             :     }
    1176           0 :     return bRet;
    1177             : }
    1178             : 
    1179           0 : bool SwFmtSurround::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1180             : {
    1181             :     // here we convert always!
    1182           0 :     nMemberId &= ~CONVERT_TWIPS;
    1183           0 :     bool bRet = true;
    1184           0 :     switch ( nMemberId )
    1185             :     {
    1186             :         case MID_SURROUND_SURROUNDTYPE:
    1187             :         {
    1188           0 :             sal_Int32 eVal = SWUnoHelper::GetEnumAsInt32( rVal );
    1189           0 :             if( eVal >= 0 && eVal < (sal_Int16)SURROUND_END )
    1190           0 :                 SetValue( static_cast<sal_uInt16>(eVal) );
    1191             :             else {
    1192             :                 //exception
    1193             :                 ;
    1194             :             }
    1195             :         }
    1196           0 :         break;
    1197             : 
    1198             :         case MID_SURROUND_ANCHORONLY:
    1199           0 :             SetAnchorOnly( *(sal_Bool*)rVal.getValue() );
    1200           0 :             break;
    1201             :         case MID_SURROUND_CONTOUR:
    1202           0 :             SetContour( *(sal_Bool*)rVal.getValue() );
    1203           0 :             break;
    1204             :         case MID_SURROUND_CONTOUROUTSIDE:
    1205           0 :             SetOutside( *(sal_Bool*)rVal.getValue() );
    1206           0 :             break;
    1207             :         default:
    1208             :             OSL_ENSURE( !this, "unknown MemberId" );
    1209           0 :             bRet = false;
    1210             :     }
    1211           0 :     return bRet;
    1212             : }
    1213             : 
    1214           0 : SvStream& SwFmtVertOrient::Store(SvStream &rStream, sal_uInt16 /*version*/) const
    1215             : {
    1216             : #if SAL_TYPES_SIZEOFLONG == 8
    1217             :     rStream.WriteInt64(nYPos);
    1218             : #else
    1219           0 :     rStream.WriteInt32(nYPos);
    1220             : #endif
    1221           0 :     rStream.WriteInt16( eOrient ).WriteInt16( eRelation );
    1222           0 :     return rStream;
    1223             : }
    1224             : 
    1225           0 : SfxPoolItem* SwFmtVertOrient::Create(SvStream &rStream, sal_uInt16 /*itemVersion*/) const
    1226             : {
    1227           0 :     SwTwips yPos(0);
    1228           0 :     sal_Int16 orient(0);
    1229           0 :     sal_Int16 relation(0);
    1230             :     // compatibility hack for Table Auto Format: SwTwips is "long" :(
    1231             :     // (this means that the file format is platform dependent)
    1232             : #if SAL_TYPES_SIZEOFLONG == 8
    1233             :     rStream.ReadInt64(yPos);
    1234             : #else
    1235             :     sal_Int32 n;
    1236           0 :     rStream.ReadInt32(n);
    1237           0 :     yPos = n;
    1238             : #endif
    1239           0 :     rStream.ReadInt16( orient ).ReadInt16( relation );
    1240             : 
    1241           0 :     return new SwFmtVertOrient(yPos, orient, relation);
    1242             : }
    1243             : 
    1244             : //  class SwFmtVertOrient
    1245             : //  Partially implemented inline in hxx
    1246             : 
    1247           0 : SwFmtVertOrient::SwFmtVertOrient( SwTwips nY, sal_Int16 eVert,
    1248             :                                   sal_Int16 eRel )
    1249             :     : SfxPoolItem( RES_VERT_ORIENT ),
    1250             :     nYPos( nY ),
    1251             :     eOrient( eVert ),
    1252           0 :     eRelation( eRel )
    1253           0 : {}
    1254             : 
    1255           0 : bool SwFmtVertOrient::operator==( const SfxPoolItem& rAttr ) const
    1256             : {
    1257             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "not the same attributes" );
    1258           0 :     return ( nYPos     == ((SwFmtVertOrient&)rAttr).nYPos &&
    1259           0 :              eOrient   == ((SwFmtVertOrient&)rAttr).eOrient &&
    1260           0 :              eRelation == ((SwFmtVertOrient&)rAttr).eRelation );
    1261             : }
    1262             : 
    1263           0 : SfxPoolItem*  SwFmtVertOrient::Clone( SfxItemPool* ) const
    1264             : {
    1265           0 :     return new SwFmtVertOrient( nYPos, eOrient, eRelation );
    1266             : }
    1267             : 
    1268           0 : bool SwFmtVertOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1269             : {
    1270             :     // here we convert always!
    1271           0 :     nMemberId &= ~CONVERT_TWIPS;
    1272           0 :     bool bRet = true;
    1273           0 :     switch ( nMemberId )
    1274             :     {
    1275             :         case MID_VERTORIENT_ORIENT:
    1276             :         {
    1277           0 :             rVal <<= (sal_Int16)eOrient;
    1278             :         }
    1279           0 :         break;
    1280             :         case MID_VERTORIENT_RELATION:
    1281           0 :                 rVal <<= (sal_Int16)eRelation;
    1282           0 :         break;
    1283             :         case MID_VERTORIENT_POSITION:
    1284           0 :                 rVal <<= (sal_Int32)convertTwipToMm100(GetPos());
    1285           0 :                 break;
    1286             :         default:
    1287             :             OSL_ENSURE( !this, "unknown MemberId" );
    1288           0 :             bRet = false;
    1289             :     }
    1290           0 :     return bRet;
    1291             : }
    1292             : 
    1293           0 : bool SwFmtVertOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1294             : {
    1295           0 :     bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
    1296           0 :     nMemberId &= ~CONVERT_TWIPS;
    1297           0 :     bool bRet = true;
    1298           0 :     switch ( nMemberId )
    1299             :     {
    1300             :         case MID_VERTORIENT_ORIENT:
    1301             :         {
    1302           0 :             sal_uInt16 nVal = text::VertOrientation::NONE;
    1303           0 :             rVal >>= nVal;
    1304           0 :             eOrient = nVal;
    1305             :         }
    1306           0 :         break;
    1307             :         case MID_VERTORIENT_RELATION:
    1308             :         {
    1309           0 :             eRelation = lcl_IntToRelation(rVal);
    1310             :         }
    1311           0 :         break;
    1312             :         case MID_VERTORIENT_POSITION:
    1313             :         {
    1314           0 :             sal_Int32 nVal = 0;
    1315           0 :             rVal >>= nVal;
    1316           0 :             if(bConvert)
    1317           0 :                 nVal = convertMm100ToTwip(nVal);
    1318           0 :             SetPos( nVal );
    1319             :         }
    1320           0 :         break;
    1321             :         default:
    1322             :             OSL_ENSURE( !this, "unknown MemberId" );
    1323           0 :             bRet = false;
    1324             :     }
    1325           0 :     return bRet;
    1326             : }
    1327             : 
    1328             : //  class SwFmtHoriOrient
    1329             : //  Partially implemented inline in hxx
    1330             : 
    1331           0 : SwFmtHoriOrient::SwFmtHoriOrient( SwTwips nX, sal_Int16 eHori,
    1332             :                               sal_Int16 eRel, sal_Bool bPos )
    1333             :     : SfxPoolItem( RES_HORI_ORIENT ),
    1334             :     nXPos( nX ),
    1335             :     eOrient( eHori ),
    1336             :     eRelation( eRel ),
    1337           0 :     bPosToggle( bPos )
    1338           0 : {}
    1339             : 
    1340           0 : bool SwFmtHoriOrient::operator==( const SfxPoolItem& rAttr ) const
    1341             : {
    1342             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    1343           0 :     return ( nXPos == ((SwFmtHoriOrient&)rAttr).nXPos &&
    1344           0 :              eOrient == ((SwFmtHoriOrient&)rAttr).eOrient &&
    1345           0 :              eRelation == ((SwFmtHoriOrient&)rAttr).eRelation &&
    1346           0 :              bPosToggle == ((SwFmtHoriOrient&)rAttr).bPosToggle );
    1347             : }
    1348             : 
    1349           0 : SfxPoolItem*  SwFmtHoriOrient::Clone( SfxItemPool* ) const
    1350             : {
    1351           0 :     return new SwFmtHoriOrient( nXPos, eOrient, eRelation, bPosToggle );
    1352             : }
    1353             : 
    1354           0 : bool SwFmtHoriOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1355             : {
    1356             :     // here we convert always!
    1357           0 :     nMemberId &= ~CONVERT_TWIPS;
    1358           0 :     bool bRet = true;
    1359           0 :     switch ( nMemberId )
    1360             :     {
    1361             :         case MID_HORIORIENT_ORIENT:
    1362             :         {
    1363           0 :             rVal <<= (sal_Int16)eOrient;
    1364             :         }
    1365           0 :         break;
    1366             :         case MID_HORIORIENT_RELATION:
    1367           0 :             rVal <<= (sal_Int16)eRelation;
    1368           0 :         break;
    1369             :         case MID_HORIORIENT_POSITION:
    1370           0 :                 rVal <<= (sal_Int32)convertTwipToMm100(GetPos());
    1371           0 :                 break;
    1372             :         case MID_HORIORIENT_PAGETOGGLE:
    1373             :         {
    1374           0 :             sal_Bool bTmp = IsPosToggle();
    1375           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    1376             :         }
    1377           0 :                 break;
    1378             :         default:
    1379             :             OSL_ENSURE( !this, "unknown MemberId" );
    1380           0 :             bRet = false;
    1381             :     }
    1382           0 :     return bRet;
    1383             : }
    1384             : 
    1385           0 : bool SwFmtHoriOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1386             : {
    1387           0 :     bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
    1388           0 :     nMemberId &= ~CONVERT_TWIPS;
    1389           0 :     bool bRet = true;
    1390           0 :     switch ( nMemberId )
    1391             :     {
    1392             :         case MID_HORIORIENT_ORIENT:
    1393             :         {
    1394           0 :             sal_Int16 nVal = text::HoriOrientation::NONE;
    1395           0 :             rVal >>= nVal;
    1396           0 :             eOrient = nVal;
    1397             :         }
    1398           0 :         break;
    1399             :         case MID_HORIORIENT_RELATION:
    1400             :         {
    1401           0 :             eRelation = lcl_IntToRelation(rVal);
    1402             :         }
    1403           0 :         break;
    1404             :         case MID_HORIORIENT_POSITION:
    1405             :         {
    1406           0 :             sal_Int32 nVal = 0;
    1407           0 :             if(!(rVal >>= nVal))
    1408           0 :                 bRet = false;
    1409           0 :             if(bConvert)
    1410           0 :                 nVal = convertMm100ToTwip(nVal);
    1411           0 :             SetPos( nVal );
    1412             :         }
    1413           0 :         break;
    1414             :         case MID_HORIORIENT_PAGETOGGLE:
    1415           0 :                 SetPosToggle( *(sal_Bool*)rVal.getValue());
    1416           0 :             break;
    1417             :         default:
    1418             :             OSL_ENSURE( !this, "unknown MemberId" );
    1419           0 :             bRet = false;
    1420             :     }
    1421           0 :     return bRet;
    1422             : }
    1423             : 
    1424             : //  class SwFmtAnchor
    1425             : //  Partially implemented inline in hxx
    1426             : 
    1427           0 : SwFmtAnchor::SwFmtAnchor( RndStdIds nRnd, sal_uInt16 nPage )
    1428             :     : SfxPoolItem( RES_ANCHOR ),
    1429             :     nAnchorId( nRnd ),
    1430             :     nPageNum( nPage ),
    1431             :     // OD 2004-05-05 #i28701# - get always new increased order number
    1432           0 :     mnOrder( ++mnOrderCounter )
    1433           0 : {}
    1434             : 
    1435           0 : SwFmtAnchor::SwFmtAnchor( const SwFmtAnchor &rCpy )
    1436             :     : SfxPoolItem( RES_ANCHOR )
    1437           0 :     , m_pCntntAnchor( (rCpy.GetCntntAnchor())
    1438           0 :             ?  new SwPosition( *rCpy.GetCntntAnchor() ) : 0 )
    1439           0 :     , nAnchorId( rCpy.GetAnchorId() )
    1440           0 :     , nPageNum( rCpy.GetPageNum() )
    1441             :     // OD 2004-05-05 #i28701# - get always new increased order number
    1442           0 :     , mnOrder( ++mnOrderCounter )
    1443             : {
    1444           0 : }
    1445             : 
    1446           0 : SwFmtAnchor::~SwFmtAnchor()
    1447             : {
    1448           0 : }
    1449             : 
    1450           0 : void SwFmtAnchor::SetAnchor( const SwPosition *pPos )
    1451             : {
    1452             :     // anchor only to paragraphs, or start nodes in case of FLY_AT_FLY
    1453             :     // also allow table node, this is used when a table is selected and is converted to a frame by the UI
    1454             :     assert(!pPos
    1455             :             || ((FLY_AT_FLY == nAnchorId) &&
    1456             :                     dynamic_cast<SwStartNode*>(&pPos->nNode.GetNode()))
    1457             :             || (FLY_AT_PARA == nAnchorId && dynamic_cast<SwTableNode*>(&pPos->nNode.GetNode()))
    1458             :             || dynamic_cast<SwTxtNode*>(&pPos->nNode.GetNode()));
    1459           0 :     m_pCntntAnchor .reset( (pPos) ? new SwPosition( *pPos ) : 0 );
    1460             :     // Flys anchored AT paragraph should not point into the paragraph content
    1461           0 :     if (m_pCntntAnchor &&
    1462           0 :         ((FLY_AT_PARA == nAnchorId) || (FLY_AT_FLY == nAnchorId)))
    1463             :     {
    1464           0 :         m_pCntntAnchor->nContent.Assign( 0, 0 );
    1465             :     }
    1466           0 : }
    1467             : 
    1468           0 : SwFmtAnchor& SwFmtAnchor::operator=(const SwFmtAnchor& rAnchor)
    1469             : {
    1470           0 :     nAnchorId  = rAnchor.GetAnchorId();
    1471           0 :     nPageNum   = rAnchor.GetPageNum();
    1472             :     // OD 2004-05-05 #i28701# - get always new increased order number
    1473           0 :     mnOrder = ++mnOrderCounter;
    1474             : 
    1475           0 :     m_pCntntAnchor.reset( (rAnchor.GetCntntAnchor())
    1476           0 :         ? new SwPosition(*(rAnchor.GetCntntAnchor()))
    1477           0 :         : 0 );
    1478           0 :     return *this;
    1479             : }
    1480             : 
    1481           0 : bool SwFmtAnchor::operator==( const SfxPoolItem& rAttr ) const
    1482             : {
    1483             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    1484           0 :     SwFmtAnchor const& rFmtAnchor(static_cast<SwFmtAnchor const&>(rAttr));
    1485             :     // OD 2004-05-05 #i28701# - Note: <mnOrder> hasn't to be considered.
    1486           0 :     return ( nAnchorId == rFmtAnchor.GetAnchorId() &&
    1487           0 :              nPageNum == rFmtAnchor.GetPageNum()   &&
    1488             :                 // compare anchor: either both do not point into a textnode or
    1489             :                 // both do (valid m_pCntntAnchor) and the positions are equal
    1490           0 :              ((m_pCntntAnchor.get() == rFmtAnchor.m_pCntntAnchor.get()) ||
    1491           0 :               (m_pCntntAnchor && rFmtAnchor.GetCntntAnchor() &&
    1492           0 :                (*m_pCntntAnchor == *rFmtAnchor.GetCntntAnchor()))));
    1493             : }
    1494             : 
    1495           0 : SfxPoolItem*  SwFmtAnchor::Clone( SfxItemPool* ) const
    1496             : {
    1497           0 :     return new SwFmtAnchor( *this );
    1498             : }
    1499             : 
    1500             : // OD 2004-05-05 #i28701#
    1501             : sal_uInt32 SwFmtAnchor::mnOrderCounter = 0;
    1502             : 
    1503             : // OD 2004-05-05 #i28701#
    1504           0 : sal_uInt32 SwFmtAnchor::GetOrder() const
    1505             : {
    1506           0 :     return mnOrder;
    1507             : }
    1508             : 
    1509           0 : bool SwFmtAnchor::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1510             : {
    1511             :     // here we convert always!
    1512           0 :     nMemberId &= ~CONVERT_TWIPS;
    1513           0 :     bool bRet = true;
    1514           0 :     switch ( nMemberId )
    1515             :     {
    1516             :         case MID_ANCHOR_ANCHORTYPE:
    1517             : 
    1518             :             text::TextContentAnchorType eRet;
    1519           0 :             switch (GetAnchorId())
    1520             :             {
    1521             :                 case  FLY_AT_CHAR:
    1522           0 :                     eRet = text::TextContentAnchorType_AT_CHARACTER;
    1523           0 :                     break;
    1524             :                 case  FLY_AT_PAGE:
    1525           0 :                     eRet = text::TextContentAnchorType_AT_PAGE;
    1526           0 :                     break;
    1527             :                 case  FLY_AT_FLY:
    1528           0 :                     eRet = text::TextContentAnchorType_AT_FRAME;
    1529           0 :                     break;
    1530             :                 case  FLY_AS_CHAR:
    1531           0 :                     eRet = text::TextContentAnchorType_AS_CHARACTER;
    1532           0 :                     break;
    1533             :                 //case  FLY_AT_PARA:
    1534             :                 default:
    1535           0 :                     eRet = text::TextContentAnchorType_AT_PARAGRAPH;
    1536             :             }
    1537           0 :             rVal <<= eRet;
    1538           0 :         break;
    1539             :         case MID_ANCHOR_PAGENUM:
    1540           0 :             rVal <<= (sal_Int16)GetPageNum();
    1541           0 :         break;
    1542             :         case MID_ANCHOR_ANCHORFRAME:
    1543             :         {
    1544           0 :             if (m_pCntntAnchor && FLY_AT_FLY == nAnchorId)
    1545             :             {
    1546           0 :                 SwFrmFmt* pFmt = m_pCntntAnchor->nNode.GetNode().GetFlyFmt();
    1547           0 :                 if(pFmt)
    1548             :                 {
    1549           0 :                     uno::Reference<container::XNamed> xNamed = SwXFrames::GetObject( *pFmt, FLYCNTTYPE_FRM );
    1550           0 :                     uno::Reference<text::XTextFrame> xRet(xNamed, uno::UNO_QUERY);
    1551           0 :                     rVal <<= xRet;
    1552             :                 }
    1553             :             }
    1554             :         }
    1555           0 :         break;
    1556             :         default:
    1557             :             OSL_ENSURE( !this, "unknown MemberId" );
    1558           0 :             bRet = false;
    1559             :     }
    1560           0 :     return bRet;
    1561             : }
    1562             : 
    1563           0 : bool SwFmtAnchor::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1564             : {
    1565             :     // here we convert always!
    1566           0 :     nMemberId &= ~CONVERT_TWIPS;
    1567           0 :     bool bRet = true;
    1568           0 :     switch ( nMemberId )
    1569             :     {
    1570             :         case MID_ANCHOR_ANCHORTYPE:
    1571             :         {
    1572             :             RndStdIds   eAnchor;
    1573           0 :             switch( SWUnoHelper::GetEnumAsInt32( rVal ) )
    1574             :             {
    1575             :                 case  text::TextContentAnchorType_AS_CHARACTER:
    1576           0 :                     eAnchor = FLY_AS_CHAR;
    1577           0 :                     break;
    1578             :                 case  text::TextContentAnchorType_AT_PAGE:
    1579           0 :                     eAnchor = FLY_AT_PAGE;
    1580           0 :                     if( GetPageNum() > 0 )
    1581             :                     {
    1582             :                         // If the anchor type is page and a valid page number
    1583             :                         // has been set, the content position isn't required
    1584             :                         // any longer.
    1585           0 :                         m_pCntntAnchor.reset();
    1586             :                     }
    1587           0 :                     break;
    1588             :                 case  text::TextContentAnchorType_AT_FRAME:
    1589           0 :                     eAnchor = FLY_AT_FLY;
    1590           0 :                     break;
    1591             :                 case  text::TextContentAnchorType_AT_CHARACTER:
    1592           0 :                     eAnchor = FLY_AT_CHAR;
    1593           0 :                     break;
    1594             :                 //case  text::TextContentAnchorType_AT_PARAGRAPH:
    1595             :                 default:
    1596           0 :                     eAnchor = FLY_AT_PARA;
    1597           0 :                     break;
    1598             :             }
    1599           0 :             SetType( eAnchor );
    1600             :         }
    1601           0 :         break;
    1602             :         case MID_ANCHOR_PAGENUM:
    1603             :         {
    1604           0 :             sal_Int16 nVal = 0;
    1605           0 :             if((rVal >>= nVal) && nVal > 0)
    1606             :             {
    1607           0 :                 SetPageNum( nVal );
    1608           0 :                 if (FLY_AT_PAGE == GetAnchorId())
    1609             :                 {
    1610             :                     // If the anchor type is page and a valid page number
    1611             :                     // is set, the content paoition has to be deleted to not
    1612             :                     // confuse the layout (frmtool.cxx). However, if the
    1613             :                     // anchor type is not page, any content position will
    1614             :                     // be kept.
    1615           0 :                     m_pCntntAnchor.reset();
    1616             :                 }
    1617             :             }
    1618             :             else
    1619           0 :                 bRet = false;
    1620             :         }
    1621           0 :         break;
    1622             :         case MID_ANCHOR_ANCHORFRAME:
    1623             :         //no break here!;
    1624             :         default:
    1625             :             OSL_ENSURE( !this, "unknown MemberId" );
    1626           0 :             bRet = false;
    1627             :     }
    1628           0 :     return bRet;
    1629             : }
    1630             : 
    1631             : //  class SwFmtURL
    1632             : //  Partially implemented inline in hxx
    1633             : 
    1634           0 : SwFmtURL::SwFmtURL() :
    1635             :     SfxPoolItem( RES_URL ),
    1636             :     pMap( 0 ),
    1637           0 :     bIsServerMap( false )
    1638             : {
    1639           0 : }
    1640             : 
    1641           0 : SwFmtURL::SwFmtURL( const SwFmtURL &rURL) :
    1642             :     SfxPoolItem( RES_URL ),
    1643             :     sTargetFrameName( rURL.GetTargetFrameName() ),
    1644             :     sURL( rURL.GetURL() ),
    1645             :     sName( rURL.GetName() ),
    1646           0 :     bIsServerMap( rURL.IsServerMap() )
    1647             : {
    1648           0 :     pMap = rURL.GetMap() ? new ImageMap( *rURL.GetMap() ) : 0;
    1649           0 : }
    1650             : 
    1651           0 : SwFmtURL::~SwFmtURL()
    1652             : {
    1653           0 :     delete pMap;
    1654           0 : }
    1655             : 
    1656           0 : bool SwFmtURL::operator==( const SfxPoolItem &rAttr ) const
    1657             : {
    1658             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "not the same attributes" );
    1659           0 :     const SwFmtURL &rCmp = (SwFmtURL&)rAttr;
    1660           0 :     bool bRet = bIsServerMap     == rCmp.IsServerMap() &&
    1661           0 :                 sURL             == rCmp.GetURL() &&
    1662           0 :                 sTargetFrameName == rCmp.GetTargetFrameName() &&
    1663           0 :                 sName            == rCmp.GetName();
    1664           0 :     if ( bRet )
    1665             :     {
    1666           0 :         if ( pMap && rCmp.GetMap() )
    1667           0 :             bRet = *pMap == *rCmp.GetMap();
    1668             :         else
    1669           0 :             bRet = pMap == rCmp.GetMap();
    1670             :     }
    1671           0 :     return bRet;
    1672             : }
    1673             : 
    1674           0 : SfxPoolItem* SwFmtURL::Clone( SfxItemPool* ) const
    1675             : {
    1676           0 :     return new SwFmtURL( *this );
    1677             : }
    1678             : 
    1679           0 : void SwFmtURL::SetURL(const OUString &rURL, bool bServerMap)
    1680             : {
    1681           0 :     sURL = rURL;
    1682           0 :     bIsServerMap = bServerMap;
    1683           0 : }
    1684             : 
    1685           0 : void SwFmtURL::SetMap( const ImageMap *pM )
    1686             : {
    1687           0 :     delete pMap;
    1688           0 :     pMap = pM ? new ImageMap( *pM ) : 0;
    1689           0 : }
    1690             : 
    1691             : extern const SvEventDescription* sw_GetSupportedMacroItems();
    1692             : 
    1693           0 : bool SwFmtURL::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1694             : {
    1695             :     // here we convert always!
    1696           0 :     nMemberId &= ~CONVERT_TWIPS;
    1697           0 :     bool bRet = true;
    1698           0 :     switch ( nMemberId )
    1699             :     {
    1700             :         case MID_URL_URL:
    1701           0 :             rVal <<= GetURL();
    1702           0 :         break;
    1703             :         case MID_URL_TARGET:
    1704           0 :             rVal <<= GetTargetFrameName();
    1705           0 :         break;
    1706             :         case MID_URL_HYPERLINKNAME:
    1707           0 :             rVal <<= GetName();
    1708           0 :             break;
    1709             :         case MID_URL_CLIENTMAP:
    1710             :         {
    1711           0 :             uno::Reference< uno::XInterface > xInt;
    1712           0 :             if(pMap)
    1713             :             {
    1714           0 :                 xInt = SvUnoImageMap_createInstance( *pMap, sw_GetSupportedMacroItems() );
    1715             :             }
    1716             :             else
    1717             :             {
    1718           0 :                 ImageMap aEmptyMap;
    1719           0 :                 xInt = SvUnoImageMap_createInstance( aEmptyMap, sw_GetSupportedMacroItems() );
    1720             :             }
    1721           0 :             uno::Reference< container::XIndexContainer > xCont(xInt, uno::UNO_QUERY);
    1722           0 :             rVal <<= xCont;
    1723             :         }
    1724           0 :         break;
    1725             :         case MID_URL_SERVERMAP:
    1726             :         {
    1727           0 :             sal_Bool bTmp = IsServerMap();
    1728           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    1729             :         }
    1730           0 :             break;
    1731             :         default:
    1732             :             OSL_ENSURE( !this, "unknown MemberId" );
    1733           0 :             bRet = false;
    1734             :     }
    1735           0 :     return bRet;
    1736             : }
    1737             : 
    1738           0 : bool SwFmtURL::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1739             : {
    1740             :     // here we convert always!
    1741           0 :     nMemberId &= ~CONVERT_TWIPS;
    1742           0 :     bool bRet = true;
    1743           0 :     switch ( nMemberId )
    1744             :     {
    1745             :         case MID_URL_URL:
    1746             :         {
    1747           0 :             OUString sTmp;
    1748           0 :             rVal >>= sTmp;
    1749           0 :             SetURL( sTmp, bIsServerMap );
    1750             :         }
    1751           0 :         break;
    1752             :         case MID_URL_TARGET:
    1753             :         {
    1754           0 :             OUString sTmp;
    1755           0 :             rVal >>= sTmp;
    1756           0 :             SetTargetFrameName( sTmp );
    1757             :         }
    1758           0 :         break;
    1759             :         case MID_URL_HYPERLINKNAME:
    1760             :         {
    1761           0 :             OUString sTmp;
    1762           0 :             rVal >>= sTmp;
    1763           0 :             SetName( sTmp );
    1764             :         }
    1765           0 :         break;
    1766             :         case MID_URL_CLIENTMAP:
    1767             :         {
    1768           0 :             uno::Reference<container::XIndexContainer> xCont;
    1769           0 :             if(!rVal.hasValue())
    1770           0 :                 DELETEZ(pMap);
    1771           0 :             else if(rVal >>= xCont)
    1772             :             {
    1773           0 :                 if(!pMap)
    1774           0 :                     pMap = new ImageMap;
    1775           0 :                 bRet = SvUnoImageMap_fillImageMap( xCont, *pMap );
    1776             :             }
    1777             :             else
    1778           0 :                 bRet = false;
    1779             :         }
    1780           0 :         break;
    1781             :         case MID_URL_SERVERMAP:
    1782           0 :             bIsServerMap = *(sal_Bool*)rVal.getValue();
    1783           0 :             break;
    1784             :         default:
    1785             :             OSL_ENSURE( !this, "unknown MemberId" );
    1786           0 :             bRet = false;
    1787             :     }
    1788           0 :     return bRet;
    1789             : }
    1790             : 
    1791             : // class SwFmtEditInReadonly
    1792             : 
    1793           0 : SfxPoolItem* SwFmtEditInReadonly::Clone( SfxItemPool* ) const
    1794             : {
    1795           0 :     return new SwFmtEditInReadonly( Which(), GetValue() );
    1796             : }
    1797             : 
    1798             : // class SwFmtLayoutSplit
    1799             : 
    1800           0 : SfxPoolItem* SwFmtLayoutSplit::Clone( SfxItemPool* ) const
    1801             : {
    1802           0 :     return new SwFmtLayoutSplit( GetValue() );
    1803             : }
    1804             : 
    1805             : // class SwFmtRowSplit
    1806             : 
    1807           0 : SfxPoolItem* SwFmtRowSplit::Clone( SfxItemPool* ) const
    1808             : {
    1809           0 :     return new SwFmtRowSplit( GetValue() );
    1810             : }
    1811             : 
    1812             : // class SwFmtNoBalancedColumns
    1813             : 
    1814           0 : SfxPoolItem* SwFmtNoBalancedColumns::Clone( SfxItemPool* ) const
    1815             : {
    1816           0 :     return new SwFmtNoBalancedColumns( GetValue() );
    1817             : }
    1818             : 
    1819             : // class SwFmtFtnEndAtTxtEnd
    1820             : 
    1821           0 : sal_uInt16 SwFmtFtnEndAtTxtEnd::GetValueCount() const
    1822             : {
    1823           0 :     return sal_uInt16( FTNEND_ATTXTEND_END );
    1824             : }
    1825             : 
    1826           0 : SwFmtFtnEndAtTxtEnd& SwFmtFtnEndAtTxtEnd::operator=(
    1827             :                         const SwFmtFtnEndAtTxtEnd& rAttr )
    1828             : {
    1829           0 :     SfxEnumItem::SetValue( rAttr.GetValue() );
    1830           0 :     aFmt = rAttr.aFmt;
    1831           0 :     nOffset = rAttr.nOffset;
    1832           0 :     sPrefix = rAttr.sPrefix;
    1833           0 :     sSuffix = rAttr.sSuffix;
    1834           0 :     return *this;
    1835             : }
    1836             : 
    1837           0 : bool SwFmtFtnEndAtTxtEnd::operator==( const SfxPoolItem& rItem ) const
    1838             : {
    1839           0 :     const SwFmtFtnEndAtTxtEnd& rAttr = (SwFmtFtnEndAtTxtEnd&)rItem;
    1840           0 :     return SfxEnumItem::operator==( rAttr ) &&
    1841           0 :             aFmt.GetNumberingType() == rAttr.aFmt.GetNumberingType() &&
    1842           0 :             nOffset == rAttr.nOffset &&
    1843           0 :             sPrefix == rAttr.sPrefix &&
    1844           0 :             sSuffix == rAttr.sSuffix;
    1845             : }
    1846             : 
    1847           0 : bool SwFmtFtnEndAtTxtEnd::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    1848             : {
    1849           0 :     nMemberId &= ~CONVERT_TWIPS;
    1850           0 :     switch(nMemberId)
    1851             :     {
    1852             :         case MID_COLLECT     :
    1853             :         {
    1854           0 :             sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND;
    1855           0 :             rVal.setValue(&bVal, ::getBooleanCppuType());
    1856             :         }
    1857           0 :         break;
    1858             :         case MID_RESTART_NUM :
    1859             :         {
    1860           0 :             sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ;
    1861           0 :             rVal.setValue(&bVal, ::getBooleanCppuType());
    1862             :         }
    1863           0 :         break;
    1864           0 :         case MID_NUM_START_AT: rVal <<= (sal_Int16) nOffset; break;
    1865             :         case MID_OWN_NUM     :
    1866             :         {
    1867           0 :             sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT;
    1868           0 :             rVal.setValue(&bVal, ::getBooleanCppuType());
    1869             :         }
    1870           0 :         break;
    1871           0 :         case MID_NUM_TYPE    : rVal <<= aFmt.GetNumberingType(); break;
    1872           0 :         case MID_PREFIX      : rVal <<= OUString(sPrefix); break;
    1873           0 :         case MID_SUFFIX      : rVal <<= OUString(sSuffix); break;
    1874           0 :         default: return false;
    1875             :     }
    1876           0 :     return true;
    1877             : }
    1878             : 
    1879           0 : bool SwFmtFtnEndAtTxtEnd::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    1880             : {
    1881           0 :     bool bRet = true;
    1882           0 :     nMemberId &= ~CONVERT_TWIPS;
    1883           0 :     switch(nMemberId)
    1884             :     {
    1885             :         case MID_COLLECT     :
    1886             :         {
    1887           0 :             sal_Bool bVal = *(sal_Bool*)rVal.getValue();
    1888           0 :             if(!bVal && GetValue() >= FTNEND_ATTXTEND)
    1889           0 :                 SetValue(FTNEND_ATPGORDOCEND);
    1890           0 :             else if(bVal && GetValue() < FTNEND_ATTXTEND)
    1891           0 :                 SetValue(FTNEND_ATTXTEND);
    1892             :         }
    1893           0 :         break;
    1894             :         case MID_RESTART_NUM :
    1895             :         {
    1896           0 :             sal_Bool bVal = *(sal_Bool*)rVal.getValue();
    1897           0 :             if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ)
    1898           0 :                 SetValue(FTNEND_ATTXTEND);
    1899           0 :             else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMSEQ)
    1900           0 :                 SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
    1901             :         }
    1902           0 :         break;
    1903             :         case MID_NUM_START_AT:
    1904             :         {
    1905           0 :             sal_Int16 nVal = 0;
    1906           0 :             rVal >>= nVal;
    1907           0 :             if(nVal >= 0)
    1908           0 :                 nOffset = nVal;
    1909             :             else
    1910           0 :                 bRet = false;
    1911             :         }
    1912           0 :         break;
    1913             :         case MID_OWN_NUM     :
    1914             :         {
    1915           0 :             sal_Bool bVal = *(sal_Bool*)rVal.getValue();
    1916           0 :             if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT)
    1917           0 :                 SetValue(FTNEND_ATTXTEND_OWNNUMSEQ);
    1918           0 :             else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMANDFMT)
    1919           0 :                 SetValue(FTNEND_ATTXTEND_OWNNUMANDFMT);
    1920             :         }
    1921           0 :         break;
    1922             :         case MID_NUM_TYPE    :
    1923             :         {
    1924           0 :             sal_Int16 nVal = 0;
    1925           0 :             rVal >>= nVal;
    1926           0 :             if(nVal >= 0 &&
    1927           0 :                 (nVal <= SVX_NUM_ARABIC ||
    1928           0 :                     SVX_NUM_CHARS_UPPER_LETTER_N == nVal ||
    1929           0 :                         SVX_NUM_CHARS_LOWER_LETTER_N == nVal ))
    1930           0 :                 aFmt.SetNumberingType(nVal);
    1931             :             else
    1932           0 :                 bRet = false;
    1933             :         }
    1934           0 :         break;
    1935             :         case MID_PREFIX      :
    1936             :         {
    1937           0 :             OUString sVal; rVal >>= sVal;
    1938           0 :             sPrefix = sVal;
    1939             :         }
    1940           0 :         break;
    1941             :         case MID_SUFFIX      :
    1942             :         {
    1943           0 :             OUString sVal; rVal >>= sVal;
    1944           0 :             sSuffix = sVal;
    1945             :         }
    1946           0 :         break;
    1947           0 :         default: bRet = false;
    1948             :     }
    1949           0 :     return bRet;
    1950             : }
    1951             : 
    1952             : // class SwFmtFtnAtTxtEnd
    1953             : 
    1954           0 : SfxPoolItem* SwFmtFtnAtTxtEnd::Clone( SfxItemPool* ) const
    1955             : {
    1956           0 :     SwFmtFtnAtTxtEnd* pNew = new SwFmtFtnAtTxtEnd;
    1957           0 :     *pNew = *this;
    1958           0 :     return pNew;
    1959             : }
    1960             : 
    1961             : // class SwFmtEndAtTxtEnd
    1962             : 
    1963           0 : SfxPoolItem* SwFmtEndAtTxtEnd::Clone( SfxItemPool* ) const
    1964             : {
    1965           0 :     SwFmtEndAtTxtEnd* pNew = new SwFmtEndAtTxtEnd;
    1966           0 :     *pNew = *this;
    1967           0 :     return pNew;
    1968             : }
    1969             : 
    1970             : //class SwFmtChain
    1971             : 
    1972           0 : bool SwFmtChain::operator==( const SfxPoolItem &rAttr ) const
    1973             : {
    1974             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    1975             : 
    1976           0 :     return GetPrev() == ((SwFmtChain&)rAttr).GetPrev() &&
    1977           0 :            GetNext() == ((SwFmtChain&)rAttr).GetNext();
    1978             : }
    1979             : 
    1980           0 : SwFmtChain::SwFmtChain( const SwFmtChain &rCpy ) :
    1981           0 :     SfxPoolItem( RES_CHAIN )
    1982             : {
    1983           0 :     SetPrev( rCpy.GetPrev() );
    1984           0 :     SetNext( rCpy.GetNext() );
    1985           0 : }
    1986             : 
    1987           0 : SfxPoolItem* SwFmtChain::Clone( SfxItemPool* ) const
    1988             : {
    1989           0 :     SwFmtChain *pRet = new SwFmtChain;
    1990           0 :     pRet->SetPrev( GetPrev() );
    1991           0 :     pRet->SetNext( GetNext() );
    1992           0 :     return pRet;
    1993             : }
    1994             : 
    1995           0 : void SwFmtChain::SetPrev( SwFlyFrmFmt *pFmt )
    1996             : {
    1997           0 :     if ( pFmt )
    1998           0 :         pFmt->Add( &aPrev );
    1999           0 :     else if ( aPrev.GetRegisteredIn() )
    2000           0 :         ((SwModify*)aPrev.GetRegisteredIn())->Remove( &aPrev );
    2001           0 : }
    2002             : 
    2003           0 : void SwFmtChain::SetNext( SwFlyFrmFmt *pFmt )
    2004             : {
    2005           0 :     if ( pFmt )
    2006           0 :         pFmt->Add( &aNext );
    2007           0 :     else if ( aNext.GetRegisteredIn() )
    2008           0 :         ((SwModify*)aNext.GetRegisteredIn())->Remove( &aNext );
    2009           0 : }
    2010             : 
    2011           0 : bool SwFmtChain::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    2012             : {
    2013             :     // here we convert always!
    2014           0 :     nMemberId &= ~CONVERT_TWIPS;
    2015           0 :     bool   bRet = true;
    2016           0 :     OUString aRet;
    2017           0 :     switch ( nMemberId )
    2018             :     {
    2019             :         case MID_CHAIN_PREVNAME:
    2020           0 :             if ( GetPrev() )
    2021           0 :                 aRet = GetPrev()->GetName();
    2022           0 :             break;
    2023             :         case MID_CHAIN_NEXTNAME:
    2024           0 :             if ( GetNext() )
    2025           0 :                 aRet = GetNext()->GetName();
    2026           0 :             break;
    2027             :         default:
    2028             :             OSL_ENSURE( !this, "unknown MemberId" );
    2029           0 :             bRet = false;
    2030             :     }
    2031           0 :     rVal <<= aRet;
    2032           0 :     return bRet;
    2033             : }
    2034             : 
    2035             : //class SwFmtLineNumber
    2036             : 
    2037           0 : SwFmtLineNumber::SwFmtLineNumber() :
    2038           0 :     SfxPoolItem( RES_LINENUMBER )
    2039             : {
    2040           0 :     nStartValue = 0;
    2041           0 :     bCountLines = sal_True;
    2042           0 : }
    2043             : 
    2044           0 : SwFmtLineNumber::~SwFmtLineNumber()
    2045             : {
    2046           0 : }
    2047             : 
    2048           0 : bool SwFmtLineNumber::operator==( const SfxPoolItem &rAttr ) const
    2049             : {
    2050             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    2051             : 
    2052           0 :     return nStartValue  == ((SwFmtLineNumber&)rAttr).GetStartValue() &&
    2053           0 :            bCountLines  == ((SwFmtLineNumber&)rAttr).IsCount();
    2054             : }
    2055             : 
    2056           0 : SfxPoolItem* SwFmtLineNumber::Clone( SfxItemPool* ) const
    2057             : {
    2058           0 :     return new SwFmtLineNumber( *this );
    2059             : }
    2060             : 
    2061           0 : bool SwFmtLineNumber::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    2062             : {
    2063             :     // here we convert always!
    2064           0 :     nMemberId &= ~CONVERT_TWIPS;
    2065           0 :     bool bRet = true;
    2066           0 :     switch ( nMemberId )
    2067             :     {
    2068             :         case MID_LINENUMBER_COUNT:
    2069             :         {
    2070           0 :             sal_Bool bTmp = IsCount();
    2071           0 :             rVal.setValue(&bTmp, ::getBooleanCppuType());
    2072             :         }
    2073           0 :         break;
    2074             :         case MID_LINENUMBER_STARTVALUE:
    2075           0 :             rVal <<= (sal_Int32)GetStartValue();
    2076           0 :             break;
    2077             :         default:
    2078             :             OSL_ENSURE( !this, "unknown MemberId" );
    2079           0 :             bRet = false;
    2080             :     }
    2081           0 :     return bRet;
    2082             : }
    2083             : 
    2084           0 : bool SwFmtLineNumber::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    2085             : {
    2086             :     // here we convert always!
    2087           0 :     nMemberId &= ~CONVERT_TWIPS;
    2088           0 :     bool bRet = true;
    2089           0 :     switch ( nMemberId )
    2090             :     {
    2091             :         case MID_LINENUMBER_COUNT:
    2092           0 :             SetCountLines( *(sal_Bool*)rVal.getValue() );
    2093           0 :             break;
    2094             :         case MID_LINENUMBER_STARTVALUE:
    2095             :         {
    2096           0 :             sal_Int32 nVal = 0;
    2097           0 :             if(rVal >>= nVal)
    2098           0 :                 SetStartValue( nVal );
    2099             :             else
    2100           0 :                 bRet = false;
    2101             :         }
    2102           0 :         break;
    2103             :         default:
    2104             :             OSL_ENSURE( !this, "unknown MemberId" );
    2105           0 :             bRet = false;
    2106             :     }
    2107           0 :     return bRet;
    2108             : }
    2109             : 
    2110             : // class SwTextGridItem
    2111             : 
    2112           0 : SwTextGridItem::SwTextGridItem()
    2113             :     : SfxPoolItem( RES_TEXTGRID ), m_aColor( COL_LIGHTGRAY ), m_nLines( 20 )
    2114             :     , m_nBaseHeight( 400 ), m_nRubyHeight( 200 ), m_eGridType( GRID_NONE )
    2115             :     , m_bRubyTextBelow( 0 ), m_bPrintGrid( 1 ), m_bDisplayGrid( 1 )
    2116           0 :     , m_nBaseWidth(400), m_bSnapToChars( 1 ), m_bSquaredMode(1)
    2117             : {
    2118           0 : }
    2119             : 
    2120           0 : SwTextGridItem::~SwTextGridItem()
    2121             : {
    2122           0 : }
    2123             : 
    2124           0 : bool SwTextGridItem::operator==( const SfxPoolItem& rAttr ) const
    2125             : {
    2126             :     OSL_ENSURE( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
    2127           0 :     SwTextGridItem const& rOther(static_cast<SwTextGridItem const&>(rAttr));
    2128           0 :     return m_eGridType == rOther.GetGridType()
    2129           0 :         && m_nLines == rOther.GetLines()
    2130           0 :         && m_nBaseHeight == rOther.GetBaseHeight()
    2131           0 :         && m_nRubyHeight == rOther.GetRubyHeight()
    2132           0 :         && m_bRubyTextBelow == rOther.GetRubyTextBelow()
    2133           0 :         && m_bDisplayGrid == rOther.GetDisplayGrid()
    2134           0 :         && m_bPrintGrid == rOther.GetPrintGrid()
    2135           0 :         && m_aColor == rOther.GetColor()
    2136           0 :         && m_nBaseWidth == rOther.GetBaseWidth()
    2137           0 :         && m_bSnapToChars == rOther.GetSnapToChars()
    2138           0 :         && m_bSquaredMode == rOther.GetSquaredMode();
    2139             : }
    2140             : 
    2141           0 : SfxPoolItem* SwTextGridItem::Clone( SfxItemPool* ) const
    2142             : {
    2143           0 :     return new SwTextGridItem( *this );
    2144             : }
    2145             : 
    2146           0 : SwTextGridItem& SwTextGridItem::operator=( const SwTextGridItem& rCpy )
    2147             : {
    2148           0 :     m_aColor = rCpy.GetColor();
    2149           0 :     m_nLines = rCpy.GetLines();
    2150           0 :     m_nBaseHeight = rCpy.GetBaseHeight();
    2151           0 :     m_nRubyHeight = rCpy.GetRubyHeight();
    2152           0 :     m_eGridType = rCpy.GetGridType();
    2153           0 :     m_bRubyTextBelow = rCpy.GetRubyTextBelow();
    2154           0 :     m_bPrintGrid = rCpy.GetPrintGrid();
    2155           0 :     m_bDisplayGrid = rCpy.GetDisplayGrid();
    2156           0 :     m_nBaseWidth = rCpy.GetBaseWidth();
    2157           0 :     m_bSnapToChars = rCpy.GetSnapToChars();
    2158           0 :     m_bSquaredMode = rCpy.GetSquaredMode();
    2159             : 
    2160           0 :     return *this;
    2161             : }
    2162             : 
    2163           0 : bool SwTextGridItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
    2164             : {
    2165           0 :     bool bRet = true;
    2166             : 
    2167           0 :     switch( nMemberId & ~CONVERT_TWIPS )
    2168             :     {
    2169             :         case MID_GRID_COLOR:
    2170           0 :             rVal <<= GetColor().GetColor();
    2171           0 :             break;
    2172             :         case MID_GRID_LINES:
    2173           0 :             rVal <<= GetLines();
    2174           0 :             break;
    2175             :         case MID_GRID_RUBY_BELOW:
    2176           0 :             rVal.setValue( &m_bRubyTextBelow, ::getBooleanCppuType() );
    2177           0 :             break;
    2178             :         case MID_GRID_PRINT:
    2179           0 :             rVal.setValue( &m_bPrintGrid, ::getBooleanCppuType() );
    2180           0 :             break;
    2181             :         case MID_GRID_DISPLAY:
    2182           0 :             rVal.setValue( &m_bDisplayGrid, ::getBooleanCppuType() );
    2183           0 :             break;
    2184             :         case MID_GRID_BASEHEIGHT:
    2185             :             OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
    2186             :                         "This value needs TWIPS-MM100 conversion" );
    2187           0 :             rVal <<= (sal_Int32) convertTwipToMm100(m_nBaseHeight);
    2188           0 :             break;
    2189             :         case MID_GRID_BASEWIDTH:
    2190             :             OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
    2191             :                         "This value needs TWIPS-MM100 conversion" );
    2192           0 :             rVal <<= (sal_Int32) convertTwipToMm100(m_nBaseWidth);
    2193           0 :             break;
    2194             :         case MID_GRID_RUBYHEIGHT:
    2195             :             OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
    2196             :                         "This value needs TWIPS-MM100 conversion" );
    2197           0 :             rVal <<= (sal_Int32)convertTwipToMm100(m_nRubyHeight);
    2198           0 :             break;
    2199             :         case MID_GRID_TYPE:
    2200           0 :             switch( GetGridType() )
    2201             :             {
    2202             :                 case GRID_NONE:
    2203           0 :                     rVal <<= text::TextGridMode::NONE;
    2204           0 :                     break;
    2205             :                 case GRID_LINES_ONLY:
    2206           0 :                     rVal <<= text::TextGridMode::LINES;
    2207           0 :                     break;
    2208             :                 case GRID_LINES_CHARS:
    2209           0 :                     rVal <<= text::TextGridMode::LINES_AND_CHARS;
    2210           0 :                     break;
    2211             :                 default:
    2212             :                     OSL_FAIL("unknown SwTextGrid value");
    2213           0 :                     bRet = false;
    2214           0 :                     break;
    2215             :             }
    2216           0 :             break;
    2217             :         case MID_GRID_SNAPTOCHARS:
    2218           0 :             rVal.setValue( &m_bSnapToChars, ::getBooleanCppuType() );
    2219           0 :             break;
    2220             :         case MID_GRID_STANDARD_MODE:
    2221             :             {
    2222           0 :                 sal_Bool bStandardMode = !m_bSquaredMode;
    2223           0 :                 rVal.setValue( &bStandardMode, ::getBooleanCppuType() );
    2224             :             }
    2225           0 :             break;
    2226             :         default:
    2227             :             OSL_FAIL("Unknown SwTextGridItem member");
    2228           0 :             bRet = false;
    2229           0 :             break;
    2230             :     }
    2231             : 
    2232           0 :     return bRet;
    2233             : }
    2234             : 
    2235           0 : bool SwTextGridItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
    2236             : {
    2237           0 :     bool bRet = true;
    2238           0 :     switch( nMemberId & ~CONVERT_TWIPS )
    2239             :     {
    2240             :         case MID_GRID_COLOR:
    2241             :         {
    2242           0 :             sal_Int32 nTmp = 0;
    2243           0 :             bRet = (rVal >>= nTmp);
    2244           0 :             if( bRet )
    2245           0 :                 SetColor( Color(nTmp) );
    2246             :         }
    2247           0 :         break;
    2248             :         case MID_GRID_LINES:
    2249             :         {
    2250           0 :             sal_Int16 nTmp = 0;
    2251           0 :             bRet = (rVal >>= nTmp);
    2252           0 :             if( bRet && (nTmp >= 0) )
    2253           0 :                 SetLines( (sal_uInt16)nTmp );
    2254             :             else
    2255           0 :                 bRet = false;
    2256             :         }
    2257           0 :         break;
    2258             :         case MID_GRID_RUBY_BELOW:
    2259           0 :             SetRubyTextBelow( *(sal_Bool*)rVal.getValue() );
    2260           0 :             break;
    2261             :         case MID_GRID_PRINT:
    2262           0 :             SetPrintGrid( *(sal_Bool*)rVal.getValue() );
    2263           0 :             break;
    2264             :         case MID_GRID_DISPLAY:
    2265           0 :             SetDisplayGrid( *(sal_Bool*)rVal.getValue() );
    2266           0 :             break;
    2267             :         case MID_GRID_BASEHEIGHT:
    2268             :         case MID_GRID_BASEWIDTH:
    2269             :         case MID_GRID_RUBYHEIGHT:
    2270             :         {
    2271             :             OSL_ENSURE( (nMemberId & CONVERT_TWIPS) != 0,
    2272             :                         "This value needs TWIPS-MM100 conversion" );
    2273           0 :             sal_Int32 nTmp = 0;
    2274           0 :             bRet = (rVal >>= nTmp);
    2275           0 :             nTmp = convertMm100ToTwip( nTmp );
    2276           0 :             if( bRet && (nTmp >= 0) && ( nTmp <= USHRT_MAX) )
    2277             :             {
    2278             :                 // rhbz#1043551 round up to 5pt -- 0 causes divide-by-zero
    2279             :                 // in layout; 1pt ties the painting code up in knots for
    2280             :                 // minutes with bazillion lines...
    2281             : #define MIN_TEXTGRID_SIZE 100
    2282           0 :                 if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEHEIGHT )
    2283             :                 {
    2284           0 :                     nTmp = std::max<sal_Int32>(nTmp, MIN_TEXTGRID_SIZE);
    2285           0 :                     SetBaseHeight( (sal_uInt16)nTmp );
    2286             :                 }
    2287           0 :                 else if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEWIDTH )
    2288             :                 {
    2289           0 :                     nTmp = std::max<sal_Int32>(nTmp, MIN_TEXTGRID_SIZE);
    2290           0 :                     SetBaseWidth( (sal_uInt16)nTmp );
    2291             :                 }
    2292             :                 else
    2293           0 :                     SetRubyHeight( (sal_uInt16)nTmp );
    2294             :             }
    2295             :             else
    2296           0 :                 bRet = false;
    2297             :         }
    2298           0 :         break;
    2299             :         case MID_GRID_TYPE:
    2300             :         {
    2301           0 :             sal_Int16 nTmp = 0;
    2302           0 :             bRet = (rVal >>= nTmp);
    2303           0 :             if( bRet )
    2304             :             {
    2305           0 :                 switch( nTmp )
    2306             :                 {
    2307             :                     case text::TextGridMode::NONE:
    2308           0 :                         SetGridType( GRID_NONE );
    2309           0 :                         break;
    2310             :                     case text::TextGridMode::LINES:
    2311           0 :                         SetGridType( GRID_LINES_ONLY );
    2312           0 :                         break;
    2313             :                     case text::TextGridMode::LINES_AND_CHARS:
    2314           0 :                         SetGridType( GRID_LINES_CHARS );
    2315           0 :                         break;
    2316             :                     default:
    2317           0 :                         bRet = false;
    2318           0 :                         break;
    2319             :                 }
    2320             :             }
    2321           0 :             break;
    2322             :         }
    2323             :         case MID_GRID_SNAPTOCHARS:
    2324           0 :             SetSnapToChars( *(sal_Bool*)rVal.getValue() );
    2325           0 :             break;
    2326             :         case MID_GRID_STANDARD_MODE:
    2327             :         {
    2328           0 :             sal_Bool bStandard = *(sal_Bool*)rVal.getValue();
    2329           0 :                SetSquaredMode( !bStandard );
    2330           0 :             break;
    2331             :         }
    2332             :         default:
    2333             :             OSL_FAIL("Unknown SwTextGridItem member");
    2334           0 :             bRet = false;
    2335             :     }
    2336             : 
    2337           0 :     return bRet;
    2338             : }
    2339             : 
    2340           0 : void SwTextGridItem::SwitchPaperMode(sal_Bool bNew)
    2341             : {
    2342           0 :     if (bNew == m_bSquaredMode)
    2343             :     {
    2344             :         //same paper mode, not switch
    2345           0 :         return;
    2346             :     }
    2347             : 
    2348             :     // use default value when grid is disable
    2349           0 :     if (m_eGridType == GRID_NONE)
    2350             :     {
    2351           0 :         m_bSquaredMode = bNew;
    2352           0 :         Init();
    2353           0 :         return;
    2354             :     }
    2355             : 
    2356           0 :     if (m_bSquaredMode)
    2357             :     {
    2358             :         //switch from "squared mode" to "standard mode"
    2359           0 :         m_nBaseWidth = m_nBaseHeight;
    2360           0 :         m_nBaseHeight = m_nBaseHeight + m_nRubyHeight;
    2361           0 :         m_nRubyHeight = 0;
    2362             :     }
    2363             :     else
    2364             :     {
    2365             :         //switch from "standard mode" to "squared mode"
    2366           0 :         m_nRubyHeight = m_nBaseHeight/3;
    2367           0 :         m_nBaseHeight = m_nBaseHeight - m_nRubyHeight;
    2368           0 :         m_nBaseWidth = m_nBaseHeight;
    2369             :     }
    2370           0 :     m_bSquaredMode = !m_bSquaredMode;
    2371             : }
    2372             : 
    2373           0 : void SwTextGridItem::Init()
    2374             : {
    2375           0 :     if (m_bSquaredMode)
    2376             :     {
    2377           0 :         m_nLines = 20;
    2378           0 :         m_nBaseHeight = 400;
    2379           0 :         m_nRubyHeight = 200;
    2380           0 :         m_eGridType = GRID_NONE;
    2381           0 :         m_bRubyTextBelow = 0;
    2382           0 :         m_bPrintGrid = 1;
    2383           0 :         m_bDisplayGrid = 1;
    2384           0 :         m_bSnapToChars = 1;
    2385           0 :         m_nBaseWidth = 400;
    2386             :     }
    2387             :     else
    2388             :     {
    2389           0 :         m_nLines = 44;
    2390           0 :         m_nBaseHeight = 312;
    2391           0 :         m_nRubyHeight = 0;
    2392           0 :         m_eGridType = GRID_NONE;
    2393           0 :         m_bRubyTextBelow = 0;
    2394           0 :         m_bPrintGrid = 1;
    2395           0 :         m_bDisplayGrid = 1;
    2396           0 :         m_nBaseWidth = 210;
    2397           0 :         m_bSnapToChars = 1;
    2398             :     }
    2399           0 : }
    2400             : 
    2401             : // class SwHeaderAndFooterEatSpacingItem
    2402             : 
    2403           0 : SfxPoolItem* SwHeaderAndFooterEatSpacingItem::Clone( SfxItemPool* ) const
    2404             : {
    2405           0 :     return new SwHeaderAndFooterEatSpacingItem( Which(), GetValue() );
    2406             : }
    2407             : 
    2408             : //  class SwFrmFmt
    2409             : //  Partially implemented inline in hxx
    2410             : 
    2411           0 : TYPEINIT1( SwFrmFmt, SwFmt );
    2412           0 : IMPL_FIXEDMEMPOOL_NEWDEL_DLL( SwFrmFmt )
    2413             : 
    2414           0 : SwFrmFmt::SwFrmFmt(
    2415             :     SwAttrPool& rPool,
    2416             :     const sal_Char* pFmtNm,
    2417             :     SwFrmFmt *pDrvdFrm,
    2418             :     sal_uInt16 nFmtWhich,
    2419             :     const sal_uInt16* pWhichRange)
    2420             : :   SwFmt(rPool, pFmtNm, (pWhichRange ? pWhichRange : aFrmFmtSetRange), pDrvdFrm, nFmtWhich),
    2421             :     m_wXObject(),
    2422           0 :     maFillAttributes()
    2423             : {
    2424             :     //UUUU
    2425           0 :     if(RES_FLYFRMFMT == nFmtWhich)
    2426             :     {
    2427             :         // when its a SwFlyFrmFmt do not do this, this setting
    2428             :         // will be derived from the parent style. In the future this
    2429             :         // may be needed for more formats; all which use the
    2430             :         // XATTR_FILL_FIRST, XATTR_FILL_LAST range as fill attributes
    2431             :     }
    2432             :     else
    2433             :     {
    2434             :         // set FillStyle to none; this is necessary since the pool default is
    2435             :         // to fill objects by color (blue8)
    2436           0 :         SetFmtAttr(XFillStyleItem(XFILL_NONE));
    2437             :     }
    2438           0 : }
    2439             : 
    2440           0 : SwFrmFmt::SwFrmFmt(
    2441             :     SwAttrPool& rPool,
    2442             :     const OUString &rFmtNm,
    2443             :     SwFrmFmt *pDrvdFrm,
    2444             :     sal_uInt16 nFmtWhich,
    2445             :     const sal_uInt16* pWhichRange)
    2446             : :   SwFmt(rPool, rFmtNm, (pWhichRange ? pWhichRange : aFrmFmtSetRange), pDrvdFrm, nFmtWhich),
    2447             :     m_wXObject(),
    2448           0 :     maFillAttributes()
    2449             : {
    2450             :     //UUUU
    2451           0 :     if(RES_FLYFRMFMT == nFmtWhich)
    2452             :     {
    2453             :         // when its a SwFlyFrmFmt do not do this, this setting
    2454             :         // will be derived from the parent style. In the future this
    2455             :         // may be needed for more formats; all which use the
    2456             :         // XATTR_FILL_FIRST, XATTR_FILL_LAST range as fill attributes
    2457             :     }
    2458             :     else
    2459             :     {
    2460             :         // set FillStyle to none; this is necessary since the pool default is
    2461             :         // to fill objects by color (blue8)
    2462           0 :         SetFmtAttr(XFillStyleItem(XFILL_NONE));
    2463             :     }
    2464           0 : }
    2465             : 
    2466           0 : void SwFrmFmt::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
    2467             : {
    2468           0 :     SwFmtHeader *pH = 0;
    2469           0 :     SwFmtFooter *pF = 0;
    2470             : 
    2471           0 :     sal_uInt16 nWhich = pNew ? pNew->Which() : 0;
    2472             : 
    2473           0 :     if( RES_ATTRSET_CHG == nWhich )
    2474             :     {
    2475           0 :         ((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState(
    2476           0 :             RES_HEADER, false, (const SfxPoolItem**)&pH );
    2477           0 :         ((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState(
    2478           0 :             RES_FOOTER, false, (const SfxPoolItem**)&pF );
    2479             : 
    2480             :         //UUUU reset fill information
    2481           0 :         if(RES_FLYFRMFMT == Which() && maFillAttributes.get())
    2482             :         {
    2483           0 :             SfxItemIter aIter(*((SwAttrSetChg*)pNew)->GetChgSet());
    2484           0 :             bool bReset(false);
    2485             : 
    2486           0 :             for(const SfxPoolItem* pItem = aIter.FirstItem(); pItem && !bReset; pItem = aIter.NextItem())
    2487             :             {
    2488           0 :                 bReset = !IsInvalidItem(pItem) && pItem->Which() >= XATTR_FILL_FIRST && pItem->Which() <= XATTR_FILL_LAST;
    2489             :             }
    2490             : 
    2491           0 :             if(bReset)
    2492             :             {
    2493           0 :                 maFillAttributes.reset();
    2494           0 :             }
    2495             :         }
    2496             :     }
    2497           0 :     else if(RES_FMT_CHG == nWhich) //UUUU
    2498             :     {
    2499             :         //UUUU reset fill information on format change (e.g. style changed)
    2500           0 :         if(RES_FLYFRMFMT == Which() && maFillAttributes.get())
    2501             :         {
    2502           0 :             maFillAttributes.reset();
    2503             :         }
    2504             :     }
    2505           0 :     else if( RES_HEADER == nWhich )
    2506           0 :         pH = (SwFmtHeader*)pNew;
    2507           0 :     else if( RES_FOOTER == nWhich )
    2508           0 :         pF = (SwFmtFooter*)pNew;
    2509             : 
    2510           0 :     if( pH && pH->IsActive() && !pH->GetHeaderFmt() )
    2511             :     {   //If he doesn't have one, I'll add one
    2512           0 :         SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_HEADER, 0 );
    2513           0 :         pH->RegisterToFormat( *pFmt );
    2514             :     }
    2515             : 
    2516           0 :     if( pF && pF->IsActive() && !pF->GetFooterFmt() )
    2517             :     {   //If he doesn't have one, I'll add one
    2518           0 :         SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_FOOTER, 0 );
    2519           0 :         pF->RegisterToFormat( *pFmt );
    2520             :     }
    2521             : 
    2522           0 :     SwFmt::Modify( pOld, pNew );
    2523             : 
    2524           0 :     if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which()))
    2525             :     {   // invalidate cached uno object
    2526           0 :         SetXObject(uno::Reference<uno::XInterface>(0));
    2527             :     }
    2528           0 : }
    2529             : 
    2530           0 : void SwFrmFmt::RegisterToFormat( SwFmt& rFmt )
    2531             : {
    2532           0 :     rFmt.Add( this );
    2533           0 : }
    2534             : 
    2535             : /// Delete all Frms that are registered in aDepend.
    2536           0 : void SwFrmFmt::DelFrms()
    2537             : {
    2538           0 :     SwIterator<SwFrm,SwFmt> aIter( *this );
    2539           0 :     SwFrm * pLast = aIter.First();
    2540           0 :     if( pLast )
    2541           0 :         do {
    2542           0 :                 pLast->Cut();
    2543           0 :                 delete pLast;
    2544           0 :         } while( 0 != ( pLast = aIter.Next() ));
    2545           0 : }
    2546             : 
    2547           0 : void SwFrmFmt::MakeFrms()
    2548             : {
    2549             :     OSL_ENSURE( !this, "Sorry not implemented." );
    2550           0 : }
    2551             : 
    2552           0 : SwRect SwFrmFmt::FindLayoutRect( const sal_Bool bPrtArea, const Point* pPoint,
    2553             :                                  const sal_Bool bCalcFrm ) const
    2554             : {
    2555           0 :     SwRect aRet;
    2556           0 :     SwFrm *pFrm = 0;
    2557           0 :     if( ISA( SwSectionFmt ) )
    2558             :     {
    2559             :         // get the Frame using Node2Layout
    2560           0 :         SwSectionNode* pSectNd = ((SwSectionFmt*)this)->GetSectionNode();
    2561           0 :         if( pSectNd )
    2562             :         {
    2563           0 :             SwNode2Layout aTmp( *pSectNd, pSectNd->GetIndex() - 1 );
    2564           0 :             pFrm = aTmp.NextFrm();
    2565             : 
    2566           0 :             if( pFrm && !pFrm->KnowsFormat(*this) )
    2567             :             {
    2568             :                 // the Section doesn't have his own Frame, so if someone
    2569             :                 // needs the real size, we have to implement this by requesting
    2570             :                 // the matching Frame from the end.
    2571             :                 // PROBLEM: what happens if SectionFrames overlaps multiple
    2572             :                 //          pages?
    2573           0 :                 if( bPrtArea )
    2574           0 :                     aRet = pFrm->Prt();
    2575             :                 else
    2576             :                 {
    2577           0 :                     aRet = pFrm->Frm();
    2578           0 :                     --aRet.Pos().Y();
    2579             :                 }
    2580           0 :                 pFrm = 0;       // the rect is finished by now
    2581           0 :             }
    2582             :         }
    2583             :     }
    2584             :     else
    2585             :     {
    2586           0 :         sal_uInt16 nFrmType = RES_FLYFRMFMT == Which() ? FRM_FLY : USHRT_MAX;
    2587             :         pFrm = ::GetFrmOfModify( 0, *(SwModify*)this, nFrmType, pPoint,
    2588           0 :                                     0, bCalcFrm );
    2589             :     }
    2590             : 
    2591           0 :     if( pFrm )
    2592             :     {
    2593           0 :         if( bPrtArea )
    2594           0 :             aRet = pFrm->Prt();
    2595             :         else
    2596           0 :             aRet = pFrm->Frm();
    2597             :     }
    2598           0 :     return aRet;
    2599             : }
    2600             : 
    2601           0 : SwContact* SwFrmFmt::FindContactObj()
    2602             : {
    2603           0 :     return SwIterator<SwContact,SwFmt>::FirstElement( *this );
    2604             : }
    2605             : 
    2606           0 : SdrObject* SwFrmFmt::FindSdrObject()
    2607             : {
    2608             :     // #i30669# - use method <FindContactObj()> instead of
    2609             :     // duplicated code.
    2610           0 :     SwContact* pFoundContact = FindContactObj();
    2611           0 :     return pFoundContact ? pFoundContact->GetMaster() : 0;
    2612             : }
    2613             : 
    2614           0 : SdrObject* SwFrmFmt::FindRealSdrObject()
    2615             : {
    2616           0 :     if( RES_FLYFRMFMT == Which() )
    2617             :     {
    2618           0 :         Point aNullPt;
    2619             :         SwFlyFrm* pFly = (SwFlyFrm*)::GetFrmOfModify( 0, *this, FRM_FLY,
    2620           0 :                                                     &aNullPt, 0, sal_False );
    2621           0 :         return pFly ? pFly->GetVirtDrawObj() : 0;
    2622             :     }
    2623           0 :     return FindSdrObject();
    2624             : }
    2625             : 
    2626           0 : sal_Bool SwFrmFmt::IsLowerOf( const SwFrmFmt& rFmt ) const
    2627             : {
    2628             :     //Also linking from inside to outside or from outside to inside is not
    2629             :     //allowed.
    2630           0 :     SwFlyFrm *pSFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(*this);
    2631           0 :     if( pSFly )
    2632             :     {
    2633           0 :         SwFlyFrm *pAskFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(rFmt);
    2634           0 :         if( pAskFly )
    2635           0 :             return pSFly->IsLowerOf( pAskFly );
    2636             :     }
    2637             : 
    2638             :     // let's try it using the node positions
    2639           0 :     const SwFmtAnchor* pAnchor = &rFmt.GetAnchor();
    2640           0 :     if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) && pAnchor->GetCntntAnchor())
    2641             :     {
    2642           0 :         const SwFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts();
    2643           0 :         const SwNode* pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode().
    2644           0 :                                 FindFlyStartNode();
    2645           0 :         while( pFlyNd )
    2646             :         {
    2647             :             // then we walk up using the anchor
    2648             :             sal_uInt16 n;
    2649           0 :             for( n = 0; n < rFmts.size(); ++n )
    2650             :             {
    2651           0 :                 const SwFrmFmt* pFmt = rFmts[ n ];
    2652           0 :                 const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx();
    2653           0 :                 if( pIdx && pFlyNd == &pIdx->GetNode() )
    2654             :                 {
    2655           0 :                     if( pFmt == this )
    2656           0 :                         return sal_True;
    2657             : 
    2658           0 :                     pAnchor = &pFmt->GetAnchor();
    2659           0 :                     if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) ||
    2660           0 :                         !pAnchor->GetCntntAnchor() )
    2661             :                     {
    2662           0 :                         return sal_False;
    2663             :                     }
    2664             : 
    2665           0 :                     pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode().
    2666           0 :                                 FindFlyStartNode();
    2667           0 :                     break;
    2668             :                 }
    2669             :             }
    2670           0 :             if( n >= rFmts.size() )
    2671             :             {
    2672             :                 OSL_ENSURE( !this, "Fly section but no format found" );
    2673           0 :                 return sal_False;
    2674             :             }
    2675             :         }
    2676             :     }
    2677           0 :     return sal_False;
    2678             : }
    2679             : 
    2680             : // #i31698#
    2681           0 : SwFrmFmt::tLayoutDir SwFrmFmt::GetLayoutDir() const
    2682             : {
    2683           0 :     return SwFrmFmt::HORI_L2R;
    2684             : }
    2685             : 
    2686           0 : void SwFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir )
    2687             : {
    2688             :     // empty body, because default implementation does nothing
    2689           0 : }
    2690             : 
    2691             : // #i28749#
    2692           0 : sal_Int16 SwFrmFmt::GetPositionLayoutDir() const
    2693             : {
    2694           0 :     return text::PositionLayoutDir::PositionInLayoutDirOfAnchor;
    2695             : }
    2696           0 : void SwFrmFmt::SetPositionLayoutDir( const sal_Int16 )
    2697             : {
    2698             :     // empty body, because default implementation does nothing
    2699           0 : }
    2700             : 
    2701           0 : OUString SwFrmFmt::GetDescription() const
    2702             : {
    2703           0 :     return SW_RES(STR_FRAME);
    2704             : }
    2705             : 
    2706             : //  class SwFlyFrmFmt
    2707             : //  Partially implemented inline in hxx
    2708             : 
    2709           0 : TYPEINIT1( SwFlyFrmFmt, SwFrmFmt );
    2710           0 : IMPL_FIXEDMEMPOOL_NEWDEL( SwFlyFrmFmt )
    2711             : 
    2712           0 : SwFlyFrmFmt::~SwFlyFrmFmt()
    2713             : {
    2714           0 :     SwIterator<SwFlyFrm,SwFmt> aIter( *this );
    2715           0 :     SwFlyFrm * pLast = aIter.First();
    2716           0 :     if( pLast )
    2717           0 :         do {
    2718           0 :                 delete pLast;
    2719             :         } while( 0 != ( pLast = aIter.Next() ));
    2720             : 
    2721           0 :     SwIterator<SwFlyDrawContact,SwFmt> a2ndIter( *this );
    2722           0 :     SwFlyDrawContact* pC = a2ndIter.First();
    2723           0 :     if( pC )
    2724           0 :         do {
    2725           0 :                 delete pC;
    2726             : 
    2727           0 :         } while( 0 != ( pC = a2ndIter.Next() ));
    2728           0 : }
    2729             : 
    2730             : /// Creates the Frms if the format describes a paragraph-bound frame.
    2731             : /// MA: 1994-02-14: creates the Frms also for frames anchored at page.
    2732           0 : void SwFlyFrmFmt::MakeFrms()
    2733             : {
    2734             :     // is there a layout?
    2735           0 :     if( !GetDoc()->GetCurrentViewShell() )
    2736           0 :         return;
    2737             : 
    2738           0 :     SwModify *pModify = 0;
    2739             :     // OD 24.07.2003 #111032# - create local copy of anchor attribute for possible changes.
    2740           0 :     SwFmtAnchor aAnchorAttr( GetAnchor() );
    2741           0 :     switch( aAnchorAttr.GetAnchorId() )
    2742             :     {
    2743             :     case FLY_AS_CHAR:
    2744             :     case FLY_AT_PARA:
    2745             :     case FLY_AT_CHAR:
    2746           0 :         if( aAnchorAttr.GetCntntAnchor() )
    2747             :         {
    2748           0 :             pModify = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
    2749             :         }
    2750           0 :         break;
    2751             : 
    2752             :     case FLY_AT_FLY:
    2753           0 :         if( aAnchorAttr.GetCntntAnchor() )
    2754             :         {
    2755             :             //First search in the content because this is O(1)
    2756             :             //This can go wrong for linked frames because in this case it's
    2757             :             //possible, that no Frame exists for this content.
    2758             :             //In such a situation we also need to search from StartNode to
    2759             :             //FrameFormat.
    2760           0 :             SwNodeIndex aIdx( aAnchorAttr.GetCntntAnchor()->nNode );
    2761           0 :             SwCntntNode *pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
    2762             :             // #i105535#
    2763           0 :             if ( pCNd == 0 )
    2764             :             {
    2765           0 :                 pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
    2766             :             }
    2767           0 :             if ( pCNd )
    2768             :             {
    2769           0 :                 if( SwIterator<SwFrm,SwCntntNode>::FirstElement( *pCNd ) )
    2770             :                 {
    2771           0 :                     pModify = pCNd;
    2772             :                 }
    2773             :             }
    2774             :             // #i105535#
    2775           0 :             if ( pModify == 0 )
    2776             :             {
    2777           0 :                 const SwNodeIndex &rIdx = aAnchorAttr.GetCntntAnchor()->nNode;
    2778           0 :                 SwFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts();
    2779           0 :                 for( sal_uInt16 i = 0; i < rFmts.size(); ++i )
    2780             :                 {
    2781           0 :                     SwFrmFmt* pFlyFmt = rFmts[i];
    2782           0 :                     if( pFlyFmt->GetCntnt().GetCntntIdx() &&
    2783           0 :                         rIdx == *pFlyFmt->GetCntnt().GetCntntIdx() )
    2784             :                     {
    2785           0 :                         pModify = pFlyFmt;
    2786           0 :                         break;
    2787             :                     }
    2788             :                 }
    2789           0 :             }
    2790             :         }
    2791           0 :         break;
    2792             : 
    2793             :     case FLY_AT_PAGE:
    2794             :         {
    2795           0 :             sal_uInt16 nPgNum = aAnchorAttr.GetPageNum();
    2796           0 :             SwPageFrm *pPage = (SwPageFrm*)GetDoc()->GetCurrentLayout()->Lower();
    2797           0 :             if( nPgNum == 0 && aAnchorAttr.GetCntntAnchor() )
    2798             :             {
    2799           0 :                 SwCntntNode *pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode();
    2800           0 :                 SwIterator<SwFrm,SwCntntNode> aIter( *pCNd );
    2801           0 :                 for ( SwFrm* pFrm = aIter.First(); pFrm != NULL; pFrm = aIter.Next() )
    2802             :                 {
    2803           0 :                     pPage = pFrm->FindPageFrm();
    2804           0 :                     if( pPage )
    2805             :                     {
    2806           0 :                         nPgNum = pPage->GetPhyPageNum();
    2807           0 :                         aAnchorAttr.SetPageNum( nPgNum );
    2808           0 :                         aAnchorAttr.SetAnchor( 0 );
    2809           0 :                         SetFmtAttr( aAnchorAttr );
    2810           0 :                         break;
    2811             :                     }
    2812           0 :                 }
    2813             :             }
    2814           0 :             while ( pPage )
    2815             :             {
    2816           0 :                 if ( pPage->GetPhyPageNum() == nPgNum )
    2817             :                 {
    2818             :                     // #i50432# - adjust synopsis of <PlaceFly(..)>
    2819           0 :                     pPage->PlaceFly( 0, this );
    2820           0 :                     break;
    2821             :                 }
    2822           0 :                 pPage = (SwPageFrm*)pPage->GetNext();
    2823             :             }
    2824             :         }
    2825           0 :         break;
    2826             :     default:
    2827           0 :         break;
    2828             :     }
    2829             : 
    2830           0 :     if( pModify )
    2831             :     {
    2832           0 :         SwIterator<SwFrm,SwModify> aIter( *pModify );
    2833           0 :         for( SwFrm *pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
    2834             :         {
    2835           0 :             bool bAdd = !pFrm->IsCntntFrm() ||
    2836           0 :                             !((SwCntntFrm*)pFrm)->IsFollow();
    2837             : 
    2838           0 :             if ( FLY_AT_FLY == aAnchorAttr.GetAnchorId() && !pFrm->IsFlyFrm() )
    2839             :             {
    2840           0 :                 SwFrm* pFlyFrm = pFrm->FindFlyFrm();
    2841           0 :                 if ( pFlyFrm )
    2842             :                 {
    2843           0 :                     pFrm = pFlyFrm;
    2844             :                 }
    2845             :                 else
    2846             :                 {
    2847           0 :                     aAnchorAttr.SetType( FLY_AT_PARA );
    2848           0 :                     SetFmtAttr( aAnchorAttr );
    2849           0 :                     MakeFrms();
    2850           0 :                     return;
    2851             :                 }
    2852             :             }
    2853             : 
    2854           0 :             if( pFrm->GetDrawObjs() )
    2855             :             {
    2856             :                 // #i28701# - new type <SwSortedObjs>
    2857           0 :                 SwSortedObjs &rObjs = *pFrm->GetDrawObjs();
    2858           0 :                 for( sal_uInt16 i = 0; i < rObjs.Count(); ++i)
    2859             :                 {
    2860             :                     // #i28701# - consider changed type of
    2861             :                     // <SwSortedObjs> entries.
    2862           0 :                     SwAnchoredObject* pObj = rObjs[i];
    2863           0 :                     if( pObj->ISA(SwFlyFrm) &&
    2864           0 :                         (&pObj->GetFrmFmt()) == this )
    2865             :                     {
    2866           0 :                         bAdd = false;
    2867           0 :                         break;
    2868             :                     }
    2869             :                 }
    2870             :             }
    2871             : 
    2872           0 :             if( bAdd )
    2873             :             {
    2874           0 :                 SwFlyFrm *pFly = 0;
    2875           0 :                 switch( aAnchorAttr.GetAnchorId() )
    2876             :                 {
    2877             :                 case FLY_AT_FLY:
    2878           0 :                     pFly = new SwFlyLayFrm( this, pFrm, pFrm );
    2879           0 :                     break;
    2880             : 
    2881             :                 case FLY_AT_PARA:
    2882             :                 case FLY_AT_CHAR:
    2883           0 :                     pFly = new SwFlyAtCntFrm( this, pFrm, pFrm );
    2884           0 :                     break;
    2885             : 
    2886             :                 case FLY_AS_CHAR:
    2887           0 :                     pFly = new SwFlyInCntFrm( this, pFrm, pFrm );
    2888           0 :                     break;
    2889             :                 default:
    2890             :                     OSL_ENSURE( !this, "Neuer Ankertyp" );
    2891           0 :                     break;
    2892             :                 }
    2893           0 :                 pFrm->AppendFly( pFly );
    2894           0 :                 SwPageFrm *pPage = pFly->FindPageFrm();
    2895           0 :                 if( pPage )
    2896           0 :                     ::RegistFlys( pPage, pFly );
    2897             :             }
    2898           0 :         }
    2899           0 :     }
    2900             : }
    2901             : 
    2902           0 : SwFlyFrm* SwFlyFrmFmt::GetFrm( const Point* pPoint, const sal_Bool bCalcFrm ) const
    2903             : {
    2904             :     return (SwFlyFrm*)::GetFrmOfModify( 0, *(SwModify*)this, FRM_FLY,
    2905           0 :                                             pPoint, 0, bCalcFrm );
    2906             : }
    2907             : 
    2908           0 : SwAnchoredObject* SwFlyFrmFmt::GetAnchoredObj( const Point* pPoint, const sal_Bool bCalcFrm ) const
    2909             : {
    2910           0 :     SwFlyFrm* pFlyFrm( GetFrm( pPoint, bCalcFrm ) );
    2911           0 :     if ( pFlyFrm )
    2912             :     {
    2913           0 :         return dynamic_cast<SwAnchoredObject*>(pFlyFrm);
    2914             :     }
    2915             :     else
    2916             :     {
    2917           0 :         return 0L;
    2918             :     }
    2919             : }
    2920             : 
    2921           0 : bool SwFlyFrmFmt::GetInfo( SfxPoolItem& rInfo ) const
    2922             : {
    2923           0 :     bool bRet = true;
    2924           0 :     switch( rInfo.Which() )
    2925             :     {
    2926             :     case RES_CONTENT_VISIBLE:
    2927             :         {
    2928           0 :             ((SwPtrMsgPoolItem&)rInfo).pObject = SwIterator<SwFrm,SwFmt>::FirstElement( *this );
    2929             :         }
    2930           0 :         bRet = false;
    2931           0 :         break;
    2932             : 
    2933             :     default:
    2934           0 :         bRet = SwFrmFmt::GetInfo( rInfo );
    2935           0 :         break;
    2936             :     }
    2937           0 :     return bRet;
    2938             : }
    2939             : 
    2940             : // #i73249#
    2941           0 : void SwFlyFrmFmt::SetObjTitle( const OUString& rTitle, bool bBroadcast )
    2942             : {
    2943           0 :     SdrObject* pMasterObject = FindSdrObject();
    2944             :     OSL_ENSURE( pMasterObject, "<SwFlyFrmFmt::SetObjTitle(..)> - missing <SdrObject> instance" );
    2945           0 :     if ( !pMasterObject )
    2946             :     {
    2947           0 :         return;
    2948             :     }
    2949             : 
    2950           0 :     if( bBroadcast )
    2951             :     {
    2952           0 :         SwStringMsgPoolItem aOld( RES_TITLE_CHANGED, pMasterObject->GetTitle() );
    2953           0 :         SwStringMsgPoolItem aNew( RES_TITLE_CHANGED, rTitle );
    2954           0 :         pMasterObject->SetTitle( rTitle );
    2955           0 :         ModifyNotification( &aOld, &aNew );
    2956             :     }
    2957             :     else
    2958             :     {
    2959           0 :         pMasterObject->SetTitle( rTitle );
    2960             :     }
    2961             : }
    2962             : 
    2963           0 : OUString SwFlyFrmFmt::GetObjTitle() const
    2964             : {
    2965           0 :     const SdrObject* pMasterObject = FindSdrObject();
    2966             :     OSL_ENSURE( pMasterObject, "<SwFlyFrmFmt::GetObjTitle(..)> - missing <SdrObject> instance" );
    2967           0 :     if ( !pMasterObject )
    2968             :     {
    2969           0 :         return OUString();
    2970             :     }
    2971             : 
    2972           0 :     return pMasterObject->GetTitle();
    2973             : }
    2974             : 
    2975           0 : void SwFlyFrmFmt::SetObjDescription( const OUString& rDescription, bool bBroadcast )
    2976             : {
    2977           0 :     SdrObject* pMasterObject = FindSdrObject();
    2978             :     OSL_ENSURE( pMasterObject, "<SwFlyFrmFmt::SetDescription(..)> - missing <SdrObject> instance" );
    2979           0 :     if ( !pMasterObject )
    2980             :     {
    2981           0 :         return;
    2982             :     }
    2983             : 
    2984           0 :     if( bBroadcast )
    2985             :     {
    2986           0 :         SwStringMsgPoolItem aOld( RES_DESCRIPTION_CHANGED, pMasterObject->GetDescription() );
    2987           0 :         SwStringMsgPoolItem aNew( RES_DESCRIPTION_CHANGED, rDescription );
    2988           0 :         pMasterObject->SetDescription( rDescription );
    2989           0 :         ModifyNotification( &aOld, &aNew );
    2990             :     }
    2991             :     else
    2992             :     {
    2993           0 :         pMasterObject->SetDescription( rDescription );
    2994             :     }
    2995             : }
    2996             : 
    2997           0 : OUString SwFlyFrmFmt::GetObjDescription() const
    2998             : {
    2999           0 :     const SdrObject* pMasterObject = FindSdrObject();
    3000             :     OSL_ENSURE( pMasterObject, "<SwFlyFrmFmt::GetDescription(..)> - missing <SdrObject> instance" );
    3001           0 :     if ( !pMasterObject )
    3002             :     {
    3003           0 :         return OUString();
    3004             :     }
    3005             : 
    3006           0 :     return pMasterObject->GetDescription();
    3007             : }
    3008             : 
    3009             : /** SwFlyFrmFmt::IsBackgroundTransparent - for #99657#
    3010             : 
    3011             :     OD 22.08.2002 - overloading virtual method and its default implementation,
    3012             :     because format of fly frame provides transparent backgrounds.
    3013             :     Method determines, if background of fly frame is transparent.
    3014             : 
    3015             :     @return true, if background color is transparent, but not "no fill"
    3016             :     or the transparency of a existing background graphic is set.
    3017             : */
    3018           0 : bool SwFlyFrmFmt::IsBackgroundTransparent() const
    3019             : {
    3020             :     //UUUU
    3021           0 :     if(RES_FLYFRMFMT == Which() && getFillAttributes())
    3022             :     {
    3023           0 :         return getFillAttributes()->isTransparent();
    3024             :     }
    3025             : 
    3026             :     // NOTE: If background color is "no fill"/"auto fill" (COL_TRANSPARENT)
    3027             :     //     and there is no background graphic, it "inherites" the background
    3028             :     //     from its anchor.
    3029           0 :     if ( (GetBackground().GetColor().GetTransparency() != 0) &&
    3030           0 :          (GetBackground().GetColor() != COL_TRANSPARENT)
    3031             :        )
    3032             :     {
    3033           0 :         return true;
    3034             :     }
    3035             :     else
    3036             :     {
    3037             :         const GraphicObject *pTmpGrf =
    3038           0 :                 static_cast<const GraphicObject*>(GetBackground().GetGraphicObject());
    3039           0 :         if ( (pTmpGrf) &&
    3040           0 :              (pTmpGrf->GetAttr().GetTransparency() != 0)
    3041             :            )
    3042             :         {
    3043           0 :             return true;
    3044             :         }
    3045             :     }
    3046             : 
    3047           0 :     return false;
    3048             : }
    3049             : 
    3050             : /** SwFlyFrmFmt::IsBackgroundBrushInherited - for #103898#
    3051             : 
    3052             :     OD 08.10.2002 - method to determine, if the brush for drawing the
    3053             :     background is "inherited" from its parent/grandparent.
    3054             :     This is the case, if no background graphic is set and the background
    3055             :     color is "no fill"/"auto fill"
    3056             :     NOTE: condition is "copied" from method <SwFrm::GetBackgroundBrush(..).
    3057             : 
    3058             :     @return true, if background brush is "inherited" from parent/grandparent
    3059             : */
    3060           0 : bool SwFlyFrmFmt::IsBackgroundBrushInherited() const
    3061             : {
    3062             :     //UUUU
    3063           0 :     if(RES_FLYFRMFMT == Which() && getFillAttributes())
    3064             :     {
    3065           0 :         return !getFillAttributes()->isUsed();
    3066             :     }
    3067           0 :     else if ( (GetBackground().GetColor() == COL_TRANSPARENT) &&
    3068           0 :          !(GetBackground().GetGraphicObject()) )
    3069             :     {
    3070           0 :         return true;
    3071             :     }
    3072             : 
    3073           0 :     return false;
    3074             : }
    3075             : 
    3076             : // #125892#
    3077           0 : SwHandleAnchorNodeChg::SwHandleAnchorNodeChg( SwFlyFrmFmt& _rFlyFrmFmt,
    3078             :                                               const SwFmtAnchor& _rNewAnchorFmt,
    3079             :                                               SwFlyFrm* _pKeepThisFlyFrm )
    3080             :     : mrFlyFrmFmt( _rFlyFrmFmt ),
    3081           0 :       mbAnchorNodeChanged( false )
    3082             : {
    3083           0 :     const RndStdIds nNewAnchorType( _rNewAnchorFmt.GetAnchorId() );
    3084           0 :     if ( ((nNewAnchorType == FLY_AT_PARA) ||
    3085           0 :           (nNewAnchorType == FLY_AT_CHAR)) &&
    3086           0 :          _rNewAnchorFmt.GetCntntAnchor() &&
    3087           0 :          _rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() )
    3088             :     {
    3089           0 :         const SwFmtAnchor& aOldAnchorFmt( _rFlyFrmFmt.GetAnchor() );
    3090           0 :         if ( aOldAnchorFmt.GetAnchorId() == nNewAnchorType &&
    3091           0 :              aOldAnchorFmt.GetCntntAnchor() &&
    3092           0 :              aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() &&
    3093           0 :              aOldAnchorFmt.GetCntntAnchor()->nNode !=
    3094           0 :                                     _rNewAnchorFmt.GetCntntAnchor()->nNode )
    3095             :         {
    3096             :             // determine 'old' number of anchor frames
    3097           0 :             sal_uInt32 nOldNumOfAnchFrm( 0L );
    3098           0 :             SwIterator<SwFrm,SwCntntNode> aOldIter( *(aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) );
    3099           0 :             for( SwFrm* pOld = aOldIter.First(); pOld; pOld = aOldIter.Next() )
    3100             :             {
    3101           0 :                 ++nOldNumOfAnchFrm;
    3102             :             }
    3103             :             // determine 'new' number of anchor frames
    3104           0 :             sal_uInt32 nNewNumOfAnchFrm( 0L );
    3105           0 :             SwIterator<SwFrm,SwCntntNode> aNewIter( *(_rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) );
    3106           0 :             for( SwFrm* pNew = aNewIter.First(); pNew; pNew = aNewIter.Next() )
    3107             :             {
    3108           0 :                 ++nNewNumOfAnchFrm;
    3109             :             }
    3110           0 :             if ( nOldNumOfAnchFrm != nNewNumOfAnchFrm )
    3111             :             {
    3112             :                 // delete existing fly frames except <_pKeepThisFlyFrm>
    3113           0 :                 SwIterator<SwFrm,SwFmt> aIter( mrFlyFrmFmt );
    3114           0 :                 SwFrm* pFrm = aIter.First();
    3115           0 :                 if ( pFrm )
    3116             :                 {
    3117           0 :                     do {
    3118           0 :                         if ( pFrm != _pKeepThisFlyFrm )
    3119             :                         {
    3120           0 :                             pFrm->Cut();
    3121           0 :                             delete pFrm;
    3122             :                         }
    3123             :                     } while( 0 != ( pFrm = aIter.Next() ));
    3124             :                 }
    3125             :                 // indicate, that re-creation of fly frames necessary
    3126           0 :                 mbAnchorNodeChanged = true;
    3127           0 :             }
    3128             :         }
    3129             :     }
    3130           0 : }
    3131             : 
    3132           0 : SwHandleAnchorNodeChg::~SwHandleAnchorNodeChg()
    3133             : {
    3134           0 :     if ( mbAnchorNodeChanged )
    3135             :     {
    3136           0 :         mrFlyFrmFmt.MakeFrms();
    3137             :     }
    3138           0 : }
    3139             : 
    3140             : //  class SwDrawFrmFmt
    3141             : //  Partially implemented inline in hxx
    3142             : 
    3143           0 : TYPEINIT1( SwDrawFrmFmt, SwFrmFmt );
    3144           0 : IMPL_FIXEDMEMPOOL_NEWDEL( SwDrawFrmFmt )
    3145             : 
    3146           0 : SwDrawFrmFmt::~SwDrawFrmFmt()
    3147             : {
    3148           0 :     SwContact *pContact = FindContactObj();
    3149           0 :     delete pContact;
    3150           0 : }
    3151             : 
    3152           0 : void SwDrawFrmFmt::MakeFrms()
    3153             : {
    3154           0 :     SwDrawContact *pContact = (SwDrawContact*)FindContactObj();
    3155           0 :     if ( pContact )
    3156           0 :          pContact->ConnectToLayout();
    3157           0 : }
    3158             : 
    3159           0 : void SwDrawFrmFmt::DelFrms()
    3160             : {
    3161           0 :     SwDrawContact *pContact = (SwDrawContact *)FindContactObj();
    3162           0 :     if ( pContact ) //for the reader and other unpredictable things.
    3163           0 :         pContact->DisconnectFromLayout();
    3164           0 : }
    3165             : 
    3166             : // #i31698#
    3167           0 : SwFrmFmt::tLayoutDir SwDrawFrmFmt::GetLayoutDir() const
    3168             : {
    3169           0 :     return meLayoutDir;
    3170             : }
    3171             : 
    3172           0 : void SwDrawFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir _eLayoutDir )
    3173             : {
    3174           0 :     meLayoutDir = _eLayoutDir;
    3175           0 : }
    3176             : 
    3177             : // #i28749#
    3178           0 : sal_Int16 SwDrawFrmFmt::GetPositionLayoutDir() const
    3179             : {
    3180           0 :     return mnPositionLayoutDir;
    3181             : }
    3182           0 : void SwDrawFrmFmt::SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir )
    3183             : {
    3184           0 :     switch ( _nPositionLayoutDir )
    3185             :     {
    3186             :         case text::PositionLayoutDir::PositionInHoriL2R:
    3187             :         case text::PositionLayoutDir::PositionInLayoutDirOfAnchor:
    3188             :         {
    3189           0 :             mnPositionLayoutDir = _nPositionLayoutDir;
    3190             :         }
    3191           0 :         break;
    3192             :         default:
    3193             :         {
    3194             :             OSL_FAIL( "<SwDrawFrmFmt::SetPositionLayoutDir(..)> - invalid attribute value." );
    3195             :         }
    3196             :     }
    3197           0 : }
    3198             : 
    3199           0 : OUString SwDrawFrmFmt::GetDescription() const
    3200             : {
    3201           0 :     OUString aResult;
    3202           0 :     const SdrObject * pSdrObj = FindSdrObject();
    3203             : 
    3204           0 :     if (pSdrObj)
    3205             :     {
    3206           0 :         if (pSdrObj != pSdrObjCached)
    3207             :         {
    3208           0 :             SdrObject * pSdrObjCopy = pSdrObj->Clone();
    3209           0 :             SdrUndoNewObj * pSdrUndo = new SdrUndoNewObj(*pSdrObjCopy);
    3210           0 :             sSdrObjCachedComment = pSdrUndo->GetComment();
    3211             : 
    3212           0 :             delete pSdrUndo;
    3213             : 
    3214           0 :             pSdrObjCached = pSdrObj;
    3215             :         }
    3216             : 
    3217           0 :         aResult = sSdrObjCachedComment;
    3218             :     }
    3219             :     else
    3220           0 :         aResult = SW_RESSTR(STR_GRAPHIC);
    3221             : 
    3222           0 :     return aResult;
    3223             : }
    3224             : 
    3225           0 : IMapObject* SwFrmFmt::GetIMapObject( const Point& rPoint,
    3226             :                                         const SwFlyFrm *pFly ) const
    3227             : {
    3228           0 :     const SwFmtURL &rURL = GetURL();
    3229           0 :     if( !rURL.GetMap() )
    3230           0 :         return 0;
    3231             : 
    3232           0 :     if( !pFly )
    3233             :     {
    3234           0 :         pFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement( *this );
    3235           0 :         if( !pFly )
    3236           0 :             return 0;
    3237             :     }
    3238             : 
    3239             :     //Original size for OLE and graphic is TwipSize, otherwise the size of
    3240             :     //FrmFmt of the Fly.
    3241             :     const SwFrm *pRef;
    3242           0 :     SwNoTxtNode *pNd = 0;
    3243           0 :     Size aOrigSz;
    3244           0 :     if( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() )
    3245             :     {
    3246           0 :         pRef = pFly->Lower();
    3247           0 :         pNd = ((SwCntntFrm*)pRef)->GetNode()->GetNoTxtNode();
    3248           0 :         aOrigSz = pNd->GetTwipSize();
    3249             :     }
    3250             :     else
    3251             :     {
    3252           0 :         pRef = pFly;
    3253           0 :         aOrigSz = pFly->GetFmt()->GetFrmSize().GetSize();
    3254             :     }
    3255             : 
    3256           0 :     if( aOrigSz.Width() != 0 && aOrigSz.Height() != 0 )
    3257             :     {
    3258           0 :         Point aPos( rPoint );
    3259           0 :         Size aActSz ( pRef == pFly ? pFly->Frm().SSize() : pRef->Prt().SSize() );
    3260           0 :         const MapMode aSrc ( MAP_TWIP );
    3261           0 :         const MapMode aDest( MAP_100TH_MM );
    3262           0 :         aOrigSz = OutputDevice::LogicToLogic( aOrigSz, aSrc, aDest );
    3263           0 :         aActSz  = OutputDevice::LogicToLogic( aActSz,  aSrc, aDest );
    3264           0 :         aPos -= pRef->Frm().Pos();
    3265           0 :         aPos -= pRef->Prt().Pos();
    3266           0 :         aPos    = OutputDevice::LogicToLogic( aPos, aSrc, aDest );
    3267           0 :         sal_uInt32 nFlags = 0;
    3268           0 :         if ( pFly != pRef && pNd->IsGrfNode() )
    3269             :         {
    3270           0 :             const sal_uInt16 nMirror = pNd->GetSwAttrSet().
    3271           0 :                                         GetMirrorGrf().GetValue();
    3272           0 :             if ( RES_MIRROR_GRAPH_BOTH == nMirror )
    3273           0 :                 nFlags = IMAP_MIRROR_HORZ | IMAP_MIRROR_VERT;
    3274           0 :             else if ( RES_MIRROR_GRAPH_VERT == nMirror )
    3275           0 :                 nFlags = IMAP_MIRROR_VERT;
    3276           0 :             else if ( RES_MIRROR_GRAPH_HOR == nMirror )
    3277           0 :                 nFlags = IMAP_MIRROR_HORZ;
    3278             : 
    3279             :         }
    3280           0 :         return ((ImageMap*)rURL.GetMap())->GetHitIMapObject( aOrigSz,
    3281           0 :                                                 aActSz, aPos, nFlags );
    3282             :     }
    3283             : 
    3284           0 :     return 0;
    3285             : }
    3286             : 
    3287             : //UUUU
    3288           0 : FillAttributesPtr SwFrmFmt::getFillAttributes() const
    3289             : {
    3290           0 :     if(RES_FLYFRMFMT == Which())
    3291             :     {
    3292             :         // create FillAttributes on demand
    3293           0 :         if(!maFillAttributes.get())
    3294             :         {
    3295           0 :             const_cast< SwFrmFmt* >(this)->maFillAttributes.reset(new FillAttributes(GetAttrSet()));
    3296             :         }
    3297             :     }
    3298             :     else
    3299             :     {
    3300             :         // FALLBACKBREAKHERE assert wrong usage
    3301             :         OSL_ENSURE(false, "getFillAttributes() call only valid for RES_FLYFRMFMT currently (!)");
    3302             :     }
    3303             : 
    3304           0 :     return maFillAttributes;
    3305           0 : }
    3306             : 
    3307             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10