xref: /trunk/main/sw/source/core/doc/poolfmt.cxx (revision 870262e3d94a18ee0354cc9d1c33864d287ac949)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"

#include <hintids.hxx>
#include <i18npool/mslangid.hxx>
#include <unotools/localedatawrapper.hxx>
#include <svx/xdef.hxx>
#include <editeng/paperinf.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/tstpitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/adjitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/keepitem.hxx>
#include <editeng/opaqitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/cmapitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/protitem.hxx>
#include <editeng/escpitem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/charrotateitem.hxx>
#include <editeng/frmdiritem.hxx>
#include <editeng/emphitem.hxx>
#include <editeng/scriptspaceitem.hxx>
#include <viewopt.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <fmtanchr.hxx>
#include <fmtornt.hxx>
#include <fmtsrnd.hxx>
#include <fmtfsize.hxx>
#include <poolfmt.hxx>
#include <paratr.hxx>
#include <pagedesc.hxx>
#include <frmtool.hxx>
#include <charfmt.hxx>
#include <docary.hxx>
#include <fmtcol.hxx>
#include <ndtxt.hxx>
#include <fmtline.hxx>
#include <poolfmt.hrc>
#include <GetMetricVal.hxx>
#include <numrule.hxx>

//UUUU
#include <svx/xfillit0.hxx>

using namespace ::com::sun::star;

const sal_uInt16 PT_3   =  3 * 20;      //  3 pt
const sal_uInt16 PT_6   =  6 * 20;      //  6 pt
const sal_uInt16 PT_7   =  7 * 20;      //  6 pt
const sal_uInt16 PT_8   =  8 * 20;      //  8 pt
const sal_uInt16 PT_9   =  9 * 20;      //  9 pt
const sal_uInt16 PT_10  = 10 * 20;      // 10 pt
const sal_uInt16 PT_11  = 11 * 20;      // 11 pt
const sal_uInt16 PT_12  = 12 * 20;      // 12 pt
const sal_uInt16 PT_14  = 14 * 20;      // 14 pt
const sal_uInt16 PT_16  = 16 * 20;      // 16 pt
const sal_uInt16 PT_18  = 18 * 20;      // 18 pt
const sal_uInt16 PT_22  = 22 * 20;      // 22 pt
const sal_uInt16 PT_24  = 24 * 20;      // 22 pt


//const sal_uInt16 HTML_PARSPACE = ((CM_05 * 7) / 10);
#define HTML_PARSPACE   GetMetricVal( CM_05 )

static const sal_Char __FAR_DATA sKomma[] = ", ";

static const sal_uInt16 aHeadlineSizes[ 2 * MAXLEVEL ] = {
//  PT_16, PT_14, PT_14, PT_12, PT_12,          // normal
//JP 10.12.96: jetzt soll alles prozentual sein:
    115, 100, 100, 85, 85,
    75,   75,  75, 75, 75,  // normal
//  PT_22, PT_16, PT_12, PT_11, PT_9            // HTML-Mode
    PT_24, PT_18, PT_14, PT_12, PT_10,
    PT_7, PT_7, PT_7, PT_7, PT_7            // HTML-Mode
};

long lcl_GetRightMargin( SwDoc& rDoc )
{
    // sorge dafuer, dass die Druckereinstellungen in die Standard-
    // Seitenvorlage uebernommen wurden.
    const SwFrmFmt& rPgDscFmt =
            const_cast<const SwDoc *>(&rDoc)->GetPageDesc( 0 ).GetMaster();
    const SvxLRSpaceItem& rLR = rPgDscFmt.GetLRSpace();
    const long nLeft = rLR.GetLeft();
    const long nRight = rLR.GetRight();
    const long nWidth = rPgDscFmt.GetFrmSize().GetWidth();
    return nWidth - nLeft - nRight;
}

void SetAllScriptItem( SfxItemSet& rSet, const SfxPoolItem& rItem )
{
    rSet.Put( rItem );
    sal_uInt16 nWhCJK = 0, nWhCTL = 0;
    switch( rItem.Which() )
    {
    case RES_CHRATR_FONTSIZE:
        nWhCJK = RES_CHRATR_CJK_FONTSIZE, nWhCTL = RES_CHRATR_CTL_FONTSIZE;
        break;
    case RES_CHRATR_FONT:
        nWhCJK = RES_CHRATR_CJK_FONT, nWhCTL = RES_CHRATR_CTL_FONT;
        break;
    case RES_CHRATR_LANGUAGE:
        nWhCJK = RES_CHRATR_CJK_LANGUAGE, nWhCTL = RES_CHRATR_CTL_LANGUAGE;
        break;
    case RES_CHRATR_POSTURE:
        nWhCJK = RES_CHRATR_CJK_POSTURE, nWhCTL = RES_CHRATR_CTL_POSTURE;
        break;
    case RES_CHRATR_WEIGHT:
        nWhCJK = RES_CHRATR_CJK_WEIGHT, nWhCTL = RES_CHRATR_CTL_WEIGHT;
        break;
    }

    if( nWhCJK )
        rSet.Put( rItem, nWhCJK );
    if( nWhCTL )
        rSet.Put( rItem, nWhCTL );
}

void lcl_SetDfltFont( sal_uInt16 nFntType, SfxItemSet& rSet )
{
    static struct {
        sal_uInt16 nResLngId;
        sal_uInt16 nResFntId;
    } aArr[ 3 ] = {
        { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT },
        { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT },
        { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT }
    };
    for( sal_uInt16 n = 0; n < 3; ++n )
    {
        sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem(
                            aArr[n].nResLngId )).GetLanguage();
        Font aFnt( OutputDevice::GetDefaultFont( nFntType,
                                nLng, DEFAULTFONT_FLAGS_ONLYONE ) );

        rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
                            aEmptyStr, aFnt.GetPitch(),
                            aFnt.GetCharSet(), aArr[n].nResFntId ));
    }
}

void lcl_SetDfltFont( sal_uInt16 nLatinFntType, sal_uInt16 nCJKFntType,
                        sal_uInt16 nCTLFntType, SfxItemSet& rSet )
{
    static struct {
        sal_uInt16 nResLngId;
        sal_uInt16 nResFntId;
        sal_uInt16 nFntType;
    } aArr[ 3 ] = {
        { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT, 0 },
        { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT, 0 },
        { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT, 0 }
    };
    aArr[0].nFntType = nLatinFntType;
    aArr[1].nFntType = nCJKFntType;
    aArr[2].nFntType = nCTLFntType;

    for( sal_uInt16 n = 0; n < 3; ++n )
    {
        sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem(
                            aArr[n].nResLngId )).GetLanguage();
        Font aFnt( OutputDevice::GetDefaultFont( aArr[n].nFntType,
                                nLng, DEFAULTFONT_FLAGS_ONLYONE ) );

        rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
                            aEmptyStr, aFnt.GetPitch(),
                            aFnt.GetCharSet(), aArr[n].nResFntId ));
    }
}

void lcl_SetHeadline( SwDoc* pDoc, SwTxtFmtColl* pColl,
                        SfxItemSet& rSet,
                        sal_uInt16 nOutLvlBits, sal_uInt8 nLevel, sal_Bool bItalic )
{
    SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
    SvxFontHeightItem aHItem(240, 100, RES_CHRATR_FONTSIZE);
    const bool bHTMLMode = pDoc->get(IDocumentSettingAccess::HTML_MODE);
    if( bHTMLMode )
        aHItem.SetHeight( aHeadlineSizes[ MAXLEVEL + nLevel ] );
    else
        aHItem.SetHeight( PT_14, aHeadlineSizes[ nLevel ] );
    SetAllScriptItem( rSet, aHItem );

    if( bItalic && !bHTMLMode )
        SetAllScriptItem( rSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );

    if( bHTMLMode )
    {
        ::lcl_SetDfltFont( DEFAULTFONT_LATIN_TEXT, DEFAULTFONT_CJK_TEXT,
                            DEFAULTFONT_CTL_TEXT, rSet );
    }

    if( pColl )
    {
        if( !( nOutLvlBits & ( 1 << nLevel )) )
        {
            //pColl->SetOutlineLevel( nLevel );          //#outline level zhaojianwei
            pColl->AssignToListLevelOfOutlineStyle(nLevel);//<-end,zhaojianwei
            if( !bHTMLMode )
            {
                SwNumRule * pOutlineRule = pDoc->GetOutlineNumRule();
                const SwNumFmt& rNFmt = pOutlineRule->Get( nLevel );
                // --> OD 2008-02-01 #newlistlevelattrs#
                if ( rNFmt.GetPositionAndSpaceMode() ==
                                    SvxNumberFormat::LABEL_WIDTH_AND_POSITION &&
                     ( rNFmt.GetAbsLSpace() || rNFmt.GetFirstLineOffset() ) )
                // <--
                {
                    SvxLRSpaceItem aLR( (SvxLRSpaceItem&)pColl->GetFmtAttr( RES_LR_SPACE ) );
                    aLR.SetTxtFirstLineOfstValue( rNFmt.GetFirstLineOffset() );
                    aLR.SetTxtLeft( rNFmt.GetAbsLSpace() );
                    pColl->SetFmtAttr( aLR );
                }

                // --> OD 2006-11-20 #i71764#
                // Check on document setting OUTLINE_LEVEL_YIELDS_OUTLINE_RULE no longer needed.
                // All paragraph styles, which are assigned to a level of the
                // outline style has to have the outline style set as its list style.
                {
                    SwNumRuleItem aItem(pOutlineRule->GetName());

                    pColl->SetFmtAttr(aItem);
                }
                // <--
            }
        }
        pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool(
                                        RES_POOLCOLL_TEXT ));
    }
}



void lcl_SetRegister( SwDoc* pDoc, SfxItemSet& rSet, sal_uInt16 nFact,
                        sal_Bool bHeader, sal_Bool bTab )
{
    SvxLRSpaceItem aLR( RES_LR_SPACE );
    sal_uInt16 nLeft = nFact ? GetMetricVal( CM_05 ) * nFact : 0;
    aLR.SetTxtLeft( nLeft );

    rSet.Put( aLR );
    if( bHeader )
    {
        SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
        SetAllScriptItem( rSet, SvxFontHeightItem( PT_16, 100, RES_CHRATR_FONTSIZE ) );
    }
    if( bTab )
    {
        long nRightMargin = lcl_GetRightMargin( *pDoc );
        SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
        aTStops.Insert( SvxTabStop( nRightMargin - nLeft,
                                    SVX_TAB_ADJUST_RIGHT,
                                    cDfltDecimalChar, '.' ));
        rSet.Put( aTStops );
    }
}



void lcl_SetNumBul( SwDoc* pDoc, SwTxtFmtColl* pColl,
                        SfxItemSet& rSet,
                        sal_uInt16 nNxt, SwTwips nEZ, SwTwips nLeft,
                        SwTwips nUpper, SwTwips nLower )
{

    SvxLRSpaceItem aLR( RES_LR_SPACE ); SvxULSpaceItem aUL( RES_UL_SPACE );
    aLR.SetTxtFirstLineOfst( sal_uInt16(nEZ) ); aLR.SetTxtLeft( sal_uInt16(nLeft) );
    aUL.SetUpper( sal_uInt16(nUpper) ); aUL.SetLower( sal_uInt16(nLower) );
    rSet.Put( aLR );
    rSet.Put( aUL );

    pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool( nNxt ));
}



// Gebe die "Auto-Collection" mit der Id zurueck. Existiert
// sie noch nicht, dann erzeuge sie
// Ist der String-Pointer definiert, dann erfrage nur die
// Beschreibung der Attribute, !! es legt keine Vorlage an !!

SvxFrameDirection GetDefaultFrameDirection(sal_uLong nLanguage)
{
    SvxFrameDirection eResult = (MsLangId::isRightToLeft( static_cast<LanguageType>(nLanguage)) ?
            FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP);
    return eResult;
}

SwTxtFmtColl* SwDoc::GetTxtCollFromPool( sal_uInt16 nId, bool bRegardLanguage )
{
    ASSERT(
        (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
        (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
        (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
        (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
        (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
        (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
            "Falsche AutoFormat-Id" );

    SwTxtFmtColl* pNewColl;
    sal_uInt16 nOutLvlBits = 0;
    for( sal_uInt16 n = 0; n < pTxtFmtCollTbl->Count(); ++n )
    {
        if( nId == ( pNewColl = (*pTxtFmtCollTbl)[ n ] )->GetPoolFmtId() )
        {
            return pNewColl;
        }
        //if( pNewColl->GetOutlineLevel() < MAXLEVEL )          //#outline level,zhaojianwei
        //nOutLvlBits |= ( 1 << pNewColl->GetOutlineLevel() );
        if( pNewColl->IsAssignedToListLevelOfOutlineStyle())
            nOutLvlBits |= ( 1 << pNewColl->GetAssignedOutlineStyleLevel() );//<-end,zhaojianwei
    }

    // bis hierher nicht gefunden -> neu anlegen
    sal_uInt16 nResId = 0;
    if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END )
        nResId = RC_POOLCOLL_TEXT_BEGIN - RES_POOLCOLL_TEXT_BEGIN;
    else if (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END)
        nResId = RC_POOLCOLL_LISTS_BEGIN - RES_POOLCOLL_LISTS_BEGIN;
    else if (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END)
        nResId = RC_POOLCOLL_EXTRA_BEGIN - RES_POOLCOLL_EXTRA_BEGIN;
    else if (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END)
        nResId = RC_POOLCOLL_REGISTER_BEGIN - RES_POOLCOLL_REGISTER_BEGIN;
    else if (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END)
        nResId = RC_POOLCOLL_DOC_BEGIN - RES_POOLCOLL_DOC_BEGIN;
    else if (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END)
        nResId = RC_POOLCOLL_HTML_BEGIN - RES_POOLCOLL_HTML_BEGIN;

    ASSERT( nResId, "Ungueltige Pool-ID" );
    if( !nResId )
        return GetTxtCollFromPool( RES_POOLCOLL_STANDARD );

    ResId aResId( nResId + nId, *pSwResMgr );
    String aNm( aResId );

    // ein Set fuer alle zusetzenden Attribute
    SwAttrSet aSet( GetAttrPool(), aTxtFmtCollSetRange );
    sal_uInt16 nParent = GetPoolParent( nId );

    {

//FEATURE::CONDCOLL
        if(::IsConditionalByPoolId( nId ))
            pNewColl = new SwConditionTxtFmtColl( GetAttrPool(), aNm, !nParent
                                                ? pDfltTxtFmtColl
                                                : GetTxtCollFromPool( nParent ));
        else
//FEATURE::CONDCOLL
        pNewColl = new SwTxtFmtColl( GetAttrPool(), aNm, !nParent
                                            ? pDfltTxtFmtColl
                                            : GetTxtCollFromPool( nParent ));
        pNewColl->SetPoolFmtId( nId );
        pTxtFmtCollTbl->Insert( pNewColl, pTxtFmtCollTbl->Count() );
    }

    switch( nId )
    {
    // allgemeine Inhaltsformen
    case RES_POOLCOLL_STANDARD:
        /* #111214# koreans do not like SvxScriptItem(sal_True) */
        if (bRegardLanguage)
        {
            sal_uLong nAppLanguage = GetAppLanguage();
            if (GetDefaultFrameDirection(nAppLanguage) ==
                FRMDIR_HORI_RIGHT_TOP)
            {
                SvxAdjustItem aAdjust(SVX_ADJUST_RIGHT, RES_PARATR_ADJUST );
                aSet.Put(aAdjust);
            }
            if (nAppLanguage == LANGUAGE_KOREAN)
            {
                SvxScriptSpaceItem aScriptSpace(sal_False, RES_PARATR_SCRIPTSPACE);
                aSet.Put(aScriptSpace);
            }
        }

        break;

    case RES_POOLCOLL_TEXT:                 // Textkoerper
        {
            SvxULSpaceItem aUL( 0, PT_6, RES_UL_SPACE );
            if( get(IDocumentSettingAccess::HTML_MODE) ) aUL.SetLower( HTML_PARSPACE );
            aSet.Put( aUL );
        }
        break;
    case RES_POOLCOLL_TEXT_IDENT:           // Textkoerper Einzug
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtFirstLineOfst( GetMetricVal( CM_05 ));
            aSet.Put( aLR );
        }
        break;
    case RES_POOLCOLL_TEXT_NEGIDENT:        // Textkoerper neg. Einzug
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 ));
            aLR.SetTxtLeft( GetMetricVal( CM_1 ));
            SvxTabStopItem aTStops(RES_PARATR_TABSTOP);    aTStops.Insert( SvxTabStop( 0 ));

            aSet.Put( aLR );
            aSet.Put( aTStops );
        }
        break;
    case RES_POOLCOLL_TEXT_MOVE:            // Textkoerper Einrueckung
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtLeft( GetMetricVal( CM_05 ));
            aSet.Put( aLR );
        }
        break;

    case RES_POOLCOLL_CONFRONTATION:    // Textkoerper Gegenueberstellung
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtFirstLineOfst( - short( GetMetricVal( CM_1 ) * 4 +
                                              GetMetricVal( CM_05)) );
            aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 5 );
            SvxTabStopItem aTStops( RES_PARATR_TABSTOP );    aTStops.Insert( SvxTabStop( 0 ));

            aSet.Put( aLR );
            aSet.Put( aTStops );
        }
        break;
    case RES_POOLCOLL_MARGINAL:         // Textkoerper maginalie
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 4 );
            aSet.Put( aLR );
        }
        break;

    case RES_POOLCOLL_HEADLINE_BASE:            // Basis Ueberschrift
        {
            static const sal_uInt16 aFntInit[] = {
                DEFAULTFONT_LATIN_HEADING,  RES_CHRATR_FONT,
                                RES_CHRATR_LANGUAGE, LANGUAGE_ENGLISH_US,
                DEFAULTFONT_CJK_HEADING,    RES_CHRATR_CJK_FONT,
                                RES_CHRATR_CJK_LANGUAGE, LANGUAGE_ENGLISH_US,
                DEFAULTFONT_CTL_HEADING,    RES_CHRATR_CTL_FONT,
                                RES_CHRATR_CTL_LANGUAGE, LANGUAGE_ARABIC_SAUDI_ARABIA,
                0
            };

            for( const sal_uInt16* pArr = aFntInit; *pArr; pArr += 4 )
            {
                sal_uInt16 nLng = ((SvxLanguageItem&)GetDefault( *(pArr+2) )).GetLanguage();
                if( LANGUAGE_DONTKNOW == nLng )
                    nLng = *(pArr+3);

                Font aFnt( OutputDevice::GetDefaultFont( *pArr,
                                        nLng, DEFAULTFONT_FLAGS_ONLYONE ) );

                aSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
                                        aEmptyStr, aFnt.GetPitch(),
                                        aFnt.GetCharSet(), *(pArr+1) ));
            }

            SvxFontHeightItem aFntSize( PT_14, 100, RES_CHRATR_FONTSIZE );
            SvxULSpaceItem aUL( PT_12, PT_6, RES_UL_SPACE );
            if( get(IDocumentSettingAccess::HTML_MODE) )
                aUL.SetLower( HTML_PARSPACE );
            aSet.Put( SvxFmtKeepItem( sal_True, RES_KEEP ));

            pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( RES_POOLCOLL_TEXT ));

            aSet.Put( aUL );
            SetAllScriptItem( aSet, aFntSize );
        }
        break;

    case RES_POOLCOLL_NUMBUL_BASE:          // Basis Numerierung/Aufzaehlung
        break;

    case RES_POOLCOLL_GREETING:             // Grussformel
    case RES_POOLCOLL_REGISTER_BASE:        // Basis Verzeichnisse
    case RES_POOLCOLL_SIGNATURE:            // Unterschrift
    case RES_POOLCOLL_TABLE:                // Tabelle-Inhalt
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_HEADLINE1:        // Ueberschrift 1
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 0, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE2:        // Ueberschrift 2
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 1, sal_True );
        break;
    case RES_POOLCOLL_HEADLINE3:        // Ueberschrift 3
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 2, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE4:        // Ueberschrift 4
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 3, sal_True );
        break;
    case RES_POOLCOLL_HEADLINE5:        // Ueberschrift 5
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 4, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE6:        // Ueberschrift 6
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 5, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE7:        // Ueberschrift 7
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 6, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE8:        // Ueberschrift 8
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 7, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE9:        // Ueberschrift 9
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 8, sal_False );
        break;
    case RES_POOLCOLL_HEADLINE10:       // Ueberschrift 10
        lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 9, sal_False );
        break;


    // Sonderbereiche:
    // Kopfzeilen
    case RES_POOLCOLL_HEADER:
    case RES_POOLCOLL_HEADERL:
    case RES_POOLCOLL_HEADERR:
    // Fusszeilen
    case RES_POOLCOLL_FOOTER:
    case RES_POOLCOLL_FOOTERL:
    case RES_POOLCOLL_FOOTERR:
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );

            long nRightMargin = lcl_GetRightMargin( *this );

            SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
            aTStops.Insert( SvxTabStop( nRightMargin / 2, SVX_TAB_ADJUST_CENTER ) );
            aTStops.Insert( SvxTabStop( nRightMargin, SVX_TAB_ADJUST_RIGHT ) );

            aSet.Put( aTStops );
        }
        break;

    case RES_POOLCOLL_TABLE_HDLN:
        {
            SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
            aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_FOOTNOTE:             // Fussnote
    case RES_POOLCOLL_ENDNOTE:
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 ));
            aLR.SetTxtLeft( GetMetricVal( CM_05 ));
            SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
            aSet.Put( aLR );
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_LABEL:                // Beschriftung-Basis
        {
            SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetUpper( PT_6 ); aUL.SetLower( PT_6 );
            aSet.Put( aUL );
            SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );
            SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_FRAME:                // Rahmen Inhalt
    case RES_POOLCOLL_LABEL_ABB:            // Beschriftung-Abbildung
    case RES_POOLCOLL_LABEL_TABLE:          // Beschriftung-Tabelle
    case RES_POOLCOLL_LABEL_FRAME:          // Beschriftung-Rahmen
    case RES_POOLCOLL_LABEL_DRAWING:        // Beschriftung-Zeichnung
        break;

    case RES_POOLCOLL_JAKETADRESS:          // UmschlagAdresse
        {
            SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
            aSet.Put( aUL );
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_SENDADRESS:           // AbsenderAdresse
        {
            if( get(IDocumentSettingAccess::HTML_MODE) )
                SetAllScriptItem( aSet, SvxPostureItem(ITALIC_NORMAL, RES_CHRATR_POSTURE) );
            else
            {
                SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
                aSet.Put( aUL );
            }
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    // Benutzer-Verzeichnisse:
    case RES_POOLCOLL_TOX_USERH:            // Header
        lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;
    case RES_POOLCOLL_TOX_USER1:            // 1. Ebene
        lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER2:            // 2. Ebene
        lcl_SetRegister( this, aSet, 1, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER3:            // 3. Ebene
        lcl_SetRegister( this, aSet, 2, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER4:            // 4. Ebene
        lcl_SetRegister( this, aSet, 3, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER5:            // 5. Ebene
        lcl_SetRegister( this, aSet, 4, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER6:            // 6. Ebene
        lcl_SetRegister( this, aSet, 5, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER7:            // 7. Ebene
        lcl_SetRegister( this, aSet, 6, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER8:            // 8. Ebene
        lcl_SetRegister( this, aSet, 7, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER9:            // 9. Ebene
        lcl_SetRegister( this, aSet, 8, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_USER10:           // 10. Ebene
        lcl_SetRegister( this, aSet, 9, sal_False, sal_True );
        break;

    // Index-Verzeichnisse
    case RES_POOLCOLL_TOX_IDXH:         // Header
        lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;
    case RES_POOLCOLL_TOX_IDX1:         // 1. Ebene
        lcl_SetRegister( this, aSet, 0, sal_False, sal_False );
        break;
    case RES_POOLCOLL_TOX_IDX2:         // 2. Ebene
        lcl_SetRegister( this, aSet, 1, sal_False, sal_False );
        break;
    case RES_POOLCOLL_TOX_IDX3:         // 3. Ebene
        lcl_SetRegister( this, aSet, 2, sal_False, sal_False );
        break;
    case RES_POOLCOLL_TOX_IDXBREAK:     // Trenner
        lcl_SetRegister( this, aSet, 0, sal_False, sal_False );
        break;

    // Inhalts-Verzeichnisse
    case RES_POOLCOLL_TOX_CNTNTH:       // Header
        lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;
    case RES_POOLCOLL_TOX_CNTNT1:       // 1. Ebene
        lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT2:       // 2. Ebene
        lcl_SetRegister( this, aSet, 1, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT3:       // 3. Ebene
        lcl_SetRegister( this, aSet, 2, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT4:       // 4. Ebene
        lcl_SetRegister( this, aSet, 3, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT5:       // 5. Ebene
        lcl_SetRegister( this, aSet, 4, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT6:       // 6. Ebene
        lcl_SetRegister( this, aSet, 5, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT7:       // 7. Ebene
        lcl_SetRegister( this, aSet, 6, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT8:       // 8. Ebene
        lcl_SetRegister( this, aSet, 7, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT9:       // 9. Ebene
        lcl_SetRegister( this, aSet, 8, sal_False, sal_True );
        break;
    case RES_POOLCOLL_TOX_CNTNT10:      // 10. Ebene
        lcl_SetRegister( this, aSet, 9, sal_False, sal_True );
        break;

    case RES_POOLCOLL_TOX_ILLUSH:
    case RES_POOLCOLL_TOX_OBJECTH:
    case RES_POOLCOLL_TOX_TABLESH:
    case RES_POOLCOLL_TOX_AUTHORITIESH:
        lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
        {
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;
    case RES_POOLCOLL_TOX_ILLUS1:
    case RES_POOLCOLL_TOX_OBJECT1:
    case RES_POOLCOLL_TOX_TABLES1:
    case RES_POOLCOLL_TOX_AUTHORITIES1:
        lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
    break;



    case RES_POOLCOLL_NUM_LEVEL1S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL1:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL1E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_NUM_NONUM1:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM1,
                        0, SwNumRule::GetNumIndent( 0 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL2S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL2:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL2E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_NUM_NONUM2:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM2,
                        0, SwNumRule::GetNumIndent( 1 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL3S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL3:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL3E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_NUM_NONUM3:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM3,
                        0, SwNumRule::GetNumIndent( 2 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL4S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL4:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL4E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_NUM_NONUM4:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM4,
                        0, SwNumRule::GetNumIndent( 3 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL5S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL5:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_NUM_LEVEL5E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
                        lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_NUM_NONUM5:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM5,
                        0, SwNumRule::GetNumIndent( 4 ), 0, PT_6 );
        break;

    case RES_POOLCOLL_BUL_LEVEL1S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL1:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL1E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_BUL_NONUM1:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM1,
                        0, SwNumRule::GetBullIndent( 0 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL2S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL2:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL2E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_BUL_NONUM2:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM2,
                        0, SwNumRule::GetBullIndent( 1 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL3S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL3:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL3E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_BUL_NONUM3:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM3,
                        0, SwNumRule::GetBullIndent( 2 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL4S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL4:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL4E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_BUL_NONUM4:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM4,
                        0, SwNumRule::GetBullIndent( 3 ), 0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL5S:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
                        PT_12, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL5:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
                        0, PT_6 );
        break;
    case RES_POOLCOLL_BUL_LEVEL5E:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
                        lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
                        0, PT_12 );
        break;
    case RES_POOLCOLL_BUL_NONUM5:
        lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM5,
                        0, SwNumRule::GetBullIndent( 4 ), 0, PT_6 );
        break;

    case RES_POOLCOLL_DOC_TITEL:            // Doc. Titel
        {
            SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
            SetAllScriptItem( aSet, SvxFontHeightItem( PT_18, 100, RES_CHRATR_FONTSIZE ) );

            aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );

            pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
                                                RES_POOLCOLL_DOC_SUBTITEL ));
        }
        break;

    case RES_POOLCOLL_DOC_SUBTITEL:         // Doc. UnterTitel
        {
            SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ));
            SetAllScriptItem( aSet, SvxFontHeightItem( PT_14, 100, RES_CHRATR_FONTSIZE ));

            aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ));

            pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
                                                RES_POOLCOLL_TEXT ));
        }
        break;

    case RES_POOLCOLL_HTML_BLOCKQUOTE:
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR.SetLeft( GetMetricVal( CM_1 ));
            aLR.SetRight( GetMetricVal( CM_1 ));
            aSet.Put( aLR );
//          aSet.Put( SvxAdjustItem( SVX_ADJUST_BLOCK, RES_PARATR_ADJUST ) );
            SvxULSpaceItem aUL( RES_UL_SPACE );
            aUL = pNewColl->GetULSpace();
            aUL.SetLower( HTML_PARSPACE );
            aSet.Put( aUL);
        }
        break;

    case RES_POOLCOLL_HTML_PRE:
        {
            ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet );

// WORKAROUND: PRE auf 10pt setzten
            SetAllScriptItem( aSet, SvxFontHeightItem(PT_10, 100, RES_CHRATR_FONTSIZE) );
// WORKAROUND: PRE auf 10pt setzten

            // der untere Absatz-Abstand wird explizit gesetzt (macht
            // die harte Attributierung einfacher)
            SvxULSpaceItem aULSpaceItem( RES_UL_SPACE );
            aULSpaceItem = pNewColl->GetULSpace();
            aULSpaceItem.SetLower( 0 );
            aSet.Put( aULSpaceItem );
        }
        break;

    case RES_POOLCOLL_HTML_HR:
        {
            SvxBoxItem aBox( RES_BOX );
            Color aColor( COL_GRAY );
            SvxBorderLine aNew( &aColor, DEF_DOUBLE_LINE0_OUT,
                                         DEF_DOUBLE_LINE0_IN,
                                         DEF_DOUBLE_LINE0_DIST );
            aBox.SetLine( &aNew, BOX_LINE_BOTTOM );

            aSet.Put( aBox );
            aSet.Put( SwParaConnectBorderItem( sal_False ) );
            SetAllScriptItem( aSet, SvxFontHeightItem(120, 100, RES_CHRATR_FONTSIZE) );

            SvxULSpaceItem aUL( RES_UL_SPACE );
            {
                pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
                                                RES_POOLCOLL_TEXT ));
                aUL = pNewColl->GetULSpace();
            }
            aUL.SetLower( HTML_PARSPACE );
            aSet.Put( aUL);
            SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
            aSet.Put( aLN );
        }
        break;

    case RES_POOLCOLL_HTML_DD:
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            aLR = pNewColl->GetLRSpace();
            // es wird um 1cm eingerueckt. Die IDs liegen immer 2 auseinander!
            aLR.SetLeft( GetMetricVal( CM_1 ));
            aSet.Put( aLR );
        }
        break;
    case RES_POOLCOLL_HTML_DT:
        {
            SvxLRSpaceItem aLR( RES_LR_SPACE );
            {
                pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
                                                    RES_POOLCOLL_HTML_DD ));
                aLR = pNewColl->GetLRSpace();
            }
            // es wird um 0cm eingerueckt. Die IDs liegen immer 2 auseinander!
            aLR.SetLeft( 0 );
            aSet.Put( aLR );
        }
        break;
    }

    if( aSet.Count() )
    {
        {
            pNewColl->SetFmtAttr( aSet );
            // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation
            //              (Bug: 18545)
            // SetModified();
        }
    }
    return pNewColl;
}



    // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
    // benutzt wird
bool SwDoc::IsPoolTxtCollUsed( sal_uInt16 nId ) const
{
    ASSERT(
        (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
        (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
        (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
        (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
        (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
        (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
            "Falsche AutoFormat-Id" );

    SwTxtFmtColl* pNewColl = 0;
    sal_Bool bFnd = sal_False;
    for( sal_uInt16 n = 0; !bFnd && n < pTxtFmtCollTbl->Count(); ++n )
    {
        pNewColl = (*pTxtFmtCollTbl)[ n ];
        if( nId == pNewColl->GetPoolFmtId() )
            bFnd = sal_True;
    }

    if( !bFnd || !pNewColl->GetDepends() )
        return sal_False;

    SwAutoFmtGetDocNode aGetHt( &GetNodes() );
    return !pNewColl->GetInfo( aGetHt );
}

    // Gebe das "Auto[matische]-Format" mit der Id zurueck. Existiert
    // es noch nicht, dann erzeuge es

SwFmt* SwDoc::GetFmtFromPool( sal_uInt16 nId )
{
    SwFmt *pNewFmt = 0;
    SwFmt *pDeriveFmt = 0;

    SvPtrarr* pArray[ 2 ];
    sal_uInt16 nArrCnt = 1, nRCId = 0;
    sal_uInt16* pWhichRange = 0;

    switch( nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
    {
    case POOLGRP_CHARFMT:
        {
            pArray[0] = pCharFmtTbl;
            pDeriveFmt = pDfltCharFmt;

            if( nId > RES_POOLCHR_NORMAL_END )
                nRCId = RC_POOLCHRFMT_HTML_BEGIN - RES_POOLCHR_HTML_BEGIN;
            else
                nRCId = RC_POOLCHRFMT_BEGIN - RES_POOLCHR_BEGIN;
            pWhichRange =  aCharFmtSetRange;

            // Fehlerfall: unbekanntes Format, aber CharFormat
            //          -> returne das erste
            if( RES_POOLCHR_BEGIN > nId || nId >= RES_POOLCHR_END )
            {
                ASSERT( sal_False, "<SwDoc::GetFmtFromPool(..)> - unknown page pool ID" );
                nId = RES_POOLCHR_BEGIN;
            }
        }
        break;
    case POOLGRP_FRAMEFMT:
        {
            pArray[0] = pFrmFmtTbl;
            pArray[1] = pSpzFrmFmtTbl;
            pDeriveFmt = pDfltFrmFmt;
            nArrCnt = 2;
            nRCId = RC_POOLFRMFMT_BEGIN - RES_POOLFRM_BEGIN;
            pWhichRange = aFrmFmtSetRange;

            // Fehlerfall: unbekanntes Format, aber FrameFormat
            //          -> returne das erste
            if( RES_POOLFRM_BEGIN > nId || nId >= RES_POOLFRM_END )
            {
                ASSERT( sal_False, "<SwDoc::GetFmtFromPool(..)> - unknown page pool ID" );
                nId = RES_POOLFRM_BEGIN;
            }
        }
        break;

    default:
        // Fehlerfall, unbekanntes Format
        ASSERT( nId, "ungueltige Id" );
        return 0;
    }
    ASSERT( nRCId, "ungueltige Id" );

    while( nArrCnt-- )
        for( sal_uInt16 n = 0; n < (*pArray[nArrCnt]).Count(); ++n )
            if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )->
                    GetPoolFmtId() )
            {
                return pNewFmt;
            }

    ResId aResId( nRCId + nId, *pSwResMgr );
    String aNm( aResId );
    SwAttrSet aSet( GetAttrPool(), pWhichRange );

    {
        sal_Bool bIsModified = IsModified();

        {
            ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
            switch (nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
            {
                case POOLGRP_CHARFMT:
                    pNewFmt = _MakeCharFmt(aNm, pDeriveFmt, sal_False, sal_True);
                break;
                case POOLGRP_FRAMEFMT:
                    pNewFmt = _MakeFrmFmt(aNm, pDeriveFmt, sal_False, sal_True);
                break;
                default:
                break;
            }
        }

        if( !bIsModified )
            ResetModified();
        pNewFmt->SetPoolFmtId( nId );
        pNewFmt->SetAuto( sal_False );      // kein Auto-Format
    }

    switch( nId )
    {
    case RES_POOLCHR_FOOTNOTE:              // Fussnote
    case RES_POOLCHR_PAGENO:                // Seiten/Feld
    case RES_POOLCHR_LABEL:                 // Beschriftung
    case RES_POOLCHR_DROPCAPS:              // Initialien
    case RES_POOLCHR_NUM_LEVEL:             // Aufzaehlungszeichen
    case RES_POOLCHR_TOXJUMP:               // Verzeichnissprung
    case RES_POOLCHR_ENDNOTE:               // Endnote
    case RES_POOLCHR_LINENUM:               // Zeilennummerierung
        break;

    case RES_POOLCHR_ENDNOTE_ANCHOR:        // Endnotenanker
    case RES_POOLCHR_FOOTNOTE_ANCHOR:       // Fussnotenanker
        {
            aSet.Put( SvxEscapementItem( DFLT_ESC_AUTO_SUPER, 58, RES_CHRATR_ESCAPEMENT ) );
        }
        break;


    case RES_POOLCHR_BUL_LEVEL:             // Aufzaehlungszeichen
        {
            const Font& rBulletFont = numfunc::GetDefBulletFont();
            SetAllScriptItem( aSet, SvxFontItem( rBulletFont.GetFamily(),
                      rBulletFont.GetName(), rBulletFont.GetStyleName(),
                        rBulletFont.GetPitch(), rBulletFont.GetCharSet(), RES_CHRATR_FONT ));
            // --> OD 2008-06-02 #i63395#
            // no font and no font size any more
//            SetAllScriptItem( aSet, SvxFontHeightItem( PT_9, 100, RES_CHRATR_FONTSIZE ));
            // <--
        }
        break;

    case RES_POOLCHR_INET_NORMAL:
        {
            Color aCol( COL_BLUE );
            aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
            aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
            // i40133: patch submitted by rail: set language to 'none' to prevent spell checking:
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
        }
        break;
    case RES_POOLCHR_INET_VISIT:
        {
            Color aCol( COL_RED );
            aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
            aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
            aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
        }
        break;
    case RES_POOLCHR_JUMPEDIT:
        {
            Color aCol( COL_CYAN );
            aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
            aSet.Put( SvxUnderlineItem( UNDERLINE_DOTTED, RES_CHRATR_UNDERLINE ) );
            aSet.Put( SvxCaseMapItem( SVX_CASEMAP_KAPITAELCHEN, RES_CHRATR_CASEMAP ) );
        }
        break;

    case RES_POOLCHR_RUBYTEXT:
        {
            long nH = ((SvxFontHeightItem*)GetDfltAttr(
                                RES_CHRATR_CJK_FONTSIZE ))->GetHeight() / 2;
            SetAllScriptItem( aSet, SvxFontHeightItem( nH, 100, RES_CHRATR_FONTSIZE));
            aSet.Put(SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE ));
            aSet.Put(SvxEmphasisMarkItem( EMPHASISMARK_NONE, RES_CHRATR_EMPHASIS_MARK) );
        }
        break;

    case RES_POOLCHR_HTML_EMPHASIS:
    case RES_POOLCHR_HTML_CITIATION:
    case RES_POOLCHR_HTML_VARIABLE:
        {
            SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE) );
        }
        break;

    case RES_POOLCHR_IDX_MAIN_ENTRY:
    case RES_POOLCHR_HTML_STRONG:
        {
            SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ));
        }
        break;

    case RES_POOLCHR_HTML_CODE:
    case RES_POOLCHR_HTML_SAMPLE:
    case RES_POOLCHR_HTML_KEYBOARD:
    case RES_POOLCHR_HTML_TELETYPE:
        {
            ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet );
        }
        break;
   case RES_POOLCHR_VERT_NUM:
            aSet.Put( SvxCharRotateItem( 900, sal_False, RES_CHRATR_ROTATE ) );
    break;
//nichts besonderes
//  case RES_POOLCHR_HTML_DEFINSTANCE:
//          break;


    case RES_POOLFRM_FRAME:
        {
            if ( get(IDocumentSettingAccess::HTML_MODE) )
            {
                aSet.Put( SwFmtAnchor( FLY_AS_CHAR ));
                aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::LINE_CENTER, text::RelOrientation::PRINT_AREA ) );
                aSet.Put( SwFmtSurround( SURROUND_NONE ) );
            }
            else
            {
                aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
                aSet.Put( SwFmtSurround( SURROUND_PARALLEL ) );
                aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::PRINT_AREA ) );
                aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::PRINT_AREA ) );
                Color aCol( COL_BLACK );
                SvxBorderLine aLine( &aCol, DEF_LINE_WIDTH_0 );
                SvxBoxItem aBox( RES_BOX );
                aBox.SetLine( &aLine, BOX_LINE_TOP );
                aBox.SetLine( &aLine, BOX_LINE_BOTTOM );
                aBox.SetLine( &aLine, BOX_LINE_LEFT );
                aBox.SetLine( &aLine, BOX_LINE_RIGHT );
                aBox.SetDistance( 85 );
                aSet.Put( aBox );
                aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
                aSet.Put( SvxULSpaceItem( 114, 114, RES_UL_SPACE ) );
            }

            //UUUU for styles of FlyFrames do not set the FillStyle to make it a derived attribute
            aSet.ClearItem(XATTR_FILLSTYLE);
        }
        break;
    case RES_POOLFRM_GRAPHIC:
    case RES_POOLFRM_OLE:
        {
            aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
            aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
            aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
            aSet.Put( SwFmtSurround( SURROUND_NONE ));
        }
        break;
    case RES_POOLFRM_FORMEL:
        {
            aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) );
            aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CHAR_CENTER, text::RelOrientation::FRAME ) );
            aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
        }
        break;
    case RES_POOLFRM_MARGINAL:
        {
            aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
            aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::FRAME ));
            aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
            aSet.Put( SwFmtSurround( SURROUND_PARALLEL ));
            // Breite 3.5 centimeter vorgegeben, als Hoehe nur den
            // min. Wert benutzen
            aSet.Put( SwFmtFrmSize( ATT_MIN_SIZE,
                    GetMetricVal( CM_1 ) * 3 + GetMetricVal( CM_05 ),
                    MM50 ));
        }
        break;
    case RES_POOLFRM_WATERSIGN:
        {
            aSet.Put( SwFmtAnchor( FLY_AT_PAGE ));
            aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
            aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CENTER, text::RelOrientation::FRAME ));
            aSet.Put( SvxOpaqueItem( sal_False ));
            aSet.Put( SwFmtSurround( SURROUND_THROUGHT ));
        }
        break;

    case RES_POOLFRM_LABEL:
        {
            aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) );
            aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ) );
            aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );

            SvxProtectItem aProtect( RES_PROTECT );
            aProtect.SetSizeProtect( sal_True );
            aProtect.SetPosProtect( sal_True );
            aSet.Put( aProtect );

            pNewFmt->SetAutoUpdateFmt( sal_True );
        }
        break;
    }
    if( aSet.Count() )
    {
        {
            pNewFmt->SetFmtAttr( aSet );
            // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation
            //              (Bug: 18545)
            // SetModified();
        }
    }
    return pNewFmt;
}

SwFrmFmt* SwDoc::GetFrmFmtFromPool( sal_uInt16 nId )
{
    return (SwFrmFmt*)GetFmtFromPool( nId );
}

SwCharFmt* SwDoc::GetCharFmtFromPool( sal_uInt16 nId )
{
    return (SwCharFmt*)GetFmtFromPool( nId );
}

    // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
    // benutzt wird
bool SwDoc::IsPoolFmtUsed( sal_uInt16 nId ) const
{
    SwFmt *pNewFmt = 0;
    const SvPtrarr* pArray[ 2 ];
    sal_uInt16 nArrCnt = 1;
    sal_Bool bFnd = sal_True;

    if( RES_POOLCHR_BEGIN <= nId && nId < RES_POOLCHR_END )
    {
        pArray[0] = pCharFmtTbl;
    }
    if( RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END )
    {
        pArray[0] = pFrmFmtTbl;
        pArray[1] = pSpzFrmFmtTbl;
        nArrCnt = 2;
    }
    else
    {
        ASSERT( sal_False, "<SwDoc::IsPoolFmtUsed(..)> - unknown page pool ID" );
        bFnd = sal_False;
    }

    if( bFnd )
    {
        bFnd = sal_False;
        while( nArrCnt-- && !bFnd )
            for( sal_uInt16 n = 0; !bFnd && n < (*pArray[nArrCnt]).Count(); ++n )
                if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )->
                        GetPoolFmtId() )
                    bFnd = sal_True;
    }

    // nicht gefunden oder keine Abhaengigen ?
    if( bFnd && pNewFmt->GetDepends() )
    {
        // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
        // (auch indirekte fuer Format-Ableitung! )
        SwAutoFmtGetDocNode aGetHt( &GetNodes() );
        bFnd = !pNewFmt->GetInfo( aGetHt );
    }
    else
        bFnd = sal_False;

    return bFnd;
}



void lcl_PutStdPageSizeIntoItemSet( SwDoc* pDoc, SfxItemSet& rSet )
{
    SwPageDesc* pStdPgDsc = pDoc->GetPageDescFromPool( RES_POOLPAGE_STANDARD );
    SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
    if( pStdPgDsc->GetLandscape() )
    {
        SwTwips nTmp = aFrmSz.GetHeight();
        aFrmSz.SetHeight( aFrmSz.GetWidth() );
        aFrmSz.SetWidth( nTmp );
    }
    rSet.Put( aFrmSz );
}

SwPageDesc* SwDoc::GetPageDescFromPool( sal_uInt16 nId, bool bRegardLanguage )
{
    ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
            "Falsche AutoFormat-Id" );

    for( sal_uInt16 n = 0; n < aPageDescs.Count(); ++n )
    {
        if ( nId == aPageDescs[ n ]->GetPoolFmtId() )
        {
            return aPageDescs[ n ];
        }
    }

    if( RES_POOLPAGE_BEGIN > nId ||  nId >= RES_POOLPAGE_END )
    {
        // unknown page pool ID
        ASSERT( sal_False, "<SwDoc::GetPageDescFromPool(..)> - unknown page pool ID" );
        nId = RES_POOLPAGE_BEGIN;
    }

    SwPageDesc* pNewPgDsc = 0;
    {
        const ResId aResId( sal_uInt32(RC_POOLPAGEDESC_BEGIN + nId - RES_POOLPAGE_BEGIN), *pSwResMgr );
        const String aNm( aResId );
        const bool bIsModified = IsModified();

        sal_uInt16 nPageDescIdx = 0;
        {
            ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
            nPageDescIdx = MakePageDesc( aNm, 0, bRegardLanguage );
        }

        pNewPgDsc = aPageDescs[ nPageDescIdx ];
        pNewPgDsc->SetPoolFmtId( nId );
        if ( !bIsModified )
        {
            ResetModified();
        }
    }

    SvxLRSpaceItem aLR( RES_LR_SPACE );
    {
        aLR.SetLeft( GetMetricVal( CM_1 ) * 2 );
        aLR.SetRight( aLR.GetLeft() );
    }
    SvxULSpaceItem aUL( RES_UL_SPACE );
    {
        aUL.SetUpper( (sal_uInt16)aLR.GetLeft() );
        aUL.SetLower( (sal_uInt16)aLR.GetLeft() );
    }

    SwAttrSet aSet( GetAttrPool(), aPgFrmFmtSetRange );
    bool bSetLeft = true;

    switch( nId )
    {
    case RES_POOLPAGE_STANDARD:     // "Default"
        {
            aSet.Put( aLR );
            aSet.Put( aUL );
            if( pNewPgDsc )
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
        }
        break;

    case RES_POOLPAGE_FIRST:        // "First Page"
    case RES_POOLPAGE_REGISTER:     // "Index"
        {
            lcl_PutStdPageSizeIntoItemSet( this, aSet );
            aSet.Put( aLR );
            aSet.Put( aUL );
            if( pNewPgDsc )
            {
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
                if( RES_POOLPAGE_FIRST == nId )
                    pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_STANDARD ));
            }
        }
        break;

    case RES_POOLPAGE_LEFT:         // "Left Page"
        {
            lcl_PutStdPageSizeIntoItemSet( this, aSet );
            aSet.Put( aLR );
            aSet.Put( aUL );
            bSetLeft = false;
            if( pNewPgDsc )
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_LEFT );
        }
        break;
    case RES_POOLPAGE_RIGHT:        // "Right Page"
        {
            lcl_PutStdPageSizeIntoItemSet( this, aSet );
            aSet.Put( aLR );
            aSet.Put( aUL );
            bSetLeft = false;
            if( pNewPgDsc )
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_RIGHT );
        }
        break;

    case RES_POOLPAGE_JAKET:        // "Envelope"
        {
            Size aPSize( SvxPaperInfo::GetPaperSize( PAPER_ENV_C65 ) );
            LandscapeSwap( aPSize );
            aSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, aPSize.Width(), aPSize.Height() ));
            aLR.SetLeft( 0 ); aLR.SetRight( 0 );
            aUL.SetUpper( 0 ); aUL.SetLower( 0 );
            aSet.Put( aLR );
            aSet.Put( aUL );

            if( pNewPgDsc )
            {
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
                pNewPgDsc->SetLandscape( sal_True );
            }
        }
        break;

    case RES_POOLPAGE_HTML:         // "HTML"
        {
            lcl_PutStdPageSizeIntoItemSet( this, aSet );
            aLR.SetRight( GetMetricVal( CM_1 ));
            aUL.SetUpper( (sal_uInt16)aLR.GetRight() );
            aUL.SetLower( (sal_uInt16)aLR.GetRight() );
            aSet.Put( aLR );
            aSet.Put( aUL );

            if( pNewPgDsc )
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
        }
        break;

    case RES_POOLPAGE_FOOTNOTE:     // "Footnote"
    case RES_POOLPAGE_ENDNOTE:      // "Endnote"
        {
            lcl_PutStdPageSizeIntoItemSet( this, aSet );
            aSet.Put( aLR );
            aSet.Put( aUL );
            if( pNewPgDsc )
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
            SwPageFtnInfo aInf( pNewPgDsc->GetFtnInfo() );
            aInf.SetLineWidth( 0 );
            aInf.SetTopDist( 0 );
            aInf.SetBottomDist( 0 );
            pNewPgDsc->SetFtnInfo( aInf );
        }
        break;

    case RES_POOLPAGE_LANDSCAPE:    // "Landscape"
        {
            SwPageDesc* pStdPgDsc = this->GetPageDescFromPool( RES_POOLPAGE_STANDARD );
            SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
            if ( !pStdPgDsc->GetLandscape() )
            {
                const SwTwips nTmp = aFrmSz.GetHeight();
                aFrmSz.SetHeight( aFrmSz.GetWidth() );
                aFrmSz.SetWidth( nTmp );
            }
            aSet.Put( aFrmSz );
            aSet.Put( aLR );
            aSet.Put( aUL );
            if( pNewPgDsc )
            {
                pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
                pNewPgDsc->SetLandscape( sal_True );
            }
        }
        break;

    }

    if( aSet.Count() )
    {
        if( bSetLeft )
            pNewPgDsc->GetLeft().SetFmtAttr( aSet );
        pNewPgDsc->GetMaster().SetFmtAttr( aSet );
    }
    return pNewPgDsc;
}

SwNumRule* SwDoc::GetNumRuleFromPool( sal_uInt16 nId )
{
    ASSERT( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END,
            "Falsche AutoFormat-Id" );

    SwNumRule* pNewRule;
    sal_uInt16 n;

    for( n = 0; n < GetNumRuleTbl().Count(); ++n )
        if( nId == ( pNewRule = GetNumRuleTbl()[ n ] )->GetPoolFmtId() )
        {
            return pNewRule;
        }

    // Fehlerfall: unbekannte Poolvorlage
    if( RES_POOLNUMRULE_BEGIN > nId ||  nId >= RES_POOLNUMRULE_END )
    {
        ASSERT( sal_False, "<SwDoc::GetNumRuleFromPool(..)> - unknown page pool ID" );
        nId = RES_POOLNUMRULE_BEGIN;
    }

    ResId aResId( sal_uInt32(RC_POOLNUMRULE_BEGIN + nId - RES_POOLNUMRULE_BEGIN), *pSwResMgr );
    String aNm( aResId );

    SwCharFmt *pNumCFmt = 0, *pBullCFmt = 0;

    // --> OD 2008-02-11 #newlistlevelattrs#
    const SvxNumberFormat::SvxNumPositionAndSpaceMode eNumberFormatPositionAndSpaceMode
                                  // --> OD 2008-06-06 #i89178#
                                  = numfunc::GetDefaultPositionAndSpaceMode();
                                  // <--
    // <--
    {
        sal_Bool bIsModified = IsModified();
        // --> OD 2008-02-11 #newlistlevelattrs#
        n = MakeNumRule( aNm, 0, sal_False, eNumberFormatPositionAndSpaceMode );
        // <--
        pNewRule = GetNumRuleTbl()[ n ];
        pNewRule->SetPoolFmtId( nId );
        pNewRule->SetAutoRule( sal_False );

        if( RES_POOLNUMRULE_NUM1 <= nId && nId <= RES_POOLNUMRULE_NUM5 )
            pNumCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL );

        if( ( RES_POOLNUMRULE_BUL1 <= nId && nId <= RES_POOLNUMRULE_BUL5 ) ||
            RES_POOLNUMRULE_NUM5 == nId )
            pBullCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL );

        if( !bIsModified )
            ResetModified();
    }

    switch( nId )
    {
    case RES_POOLNUMRULE_NUM1:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_ARABIC);
            aFmt.SetCharFmt( pNumCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            aFmt.SetSuffix( aDotStr );

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,5  1,0  1,5  2,0   2,5   3,0   3,5   4,0   4,5   5,0
                    283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;

    case RES_POOLNUMRULE_NUM2:
        {
            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
                    283,  283,  567,  709,      // 0.50, 0.50, 1.00, 1.25
                    850, 1021, 1304, 1474,      // 1.50, 1.80, 2.30, 2.60
                   1588, 1758                   // 2.80, 3.10
                };

#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    385,  385,  770,  963,
                   1155, 1386, 1771, 2002,
                   2156, 2387
                };

            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_ARABIC);
            aFmt.SetCharFmt( pNumCFmt );
            aFmt.SetIncludeUpperLevels( 1 );
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
            }
            // <--
            sal_uInt16 nSpace = 0;
            for( n = 0; n < MAXLEVEL; ++n )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( nSpace = nSpace + pArr[ n ] );
                    aFmt.SetFirstLineOffset( - pArr[ n ] );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( nSpace = nSpace + pArr[ n ] );
                    aFmt.SetIndentAt( nSpace );
                    aFmt.SetFirstLineIndent( - pArr[ n ] );
                }
                // <--
                aFmt.SetStart( n+1 );
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_NUM3:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_ARABIC);
            aFmt.SetCharFmt( pNumCFmt );
            aFmt.SetIncludeUpperLevels( 1 );

            sal_uInt16 nOffs = GetMetricVal( CM_1 ) * 3;
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - nOffs );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - nOffs );
            }
            // <--

            for( n = 0; n < MAXLEVEL; ++n )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( (n+1) * nOffs );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( (n+1) * nOffs );
                    aFmt.SetIndentAt( (n+1) * nOffs );
                }
                // <--
                aFmt.SetStart( n+1 );
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_NUM4:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_ROMAN_UPPER);
            aFmt.SetCharFmt( pNumCFmt );
            aFmt.SetIncludeUpperLevels( 1 );
            aFmt.SetSuffix( aDotStr );

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,5  1,0  1,5  2,0   2,5   3,0   3,5   4,0   4,5   5,0
                    283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                aFmt.SetStart( n + 1 );
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_NUM5:
        {
            // [ First, LSpace ]
            static const sal_uInt16 aAbsSpace0to2[] =
                {
                    227,  227,      // 0.40, 0.40,
                    369,  624,      // 0.65, 1.10,
                    255,  879       // 0.45, 1.55
                };

#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch0to2[] =
                {
                    308,  308,
                    501,  847,
                    347, 1194
                };
            const sal_uInt16* pArr0to2 = MEASURE_METRIC ==
                            SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                ? aAbsSpace0to2
                                : aAbsSpaceInch0to2;
#else
            const sal_uInt16* pArr0to2 = aAbsSpace0to2;
#endif
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_ARABIC);
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            aFmt.SetSuffix( aDotStr );
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
            }
            // <--

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( -pArr0to2[0] );    // == 0.40 cm
                aFmt.SetAbsLSpace( pArr0to2[1] );           // == 0.40 cm
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetFirstLineIndent( -pArr0to2[0] );
                aFmt.SetListtabPos( pArr0to2[1] );
                aFmt.SetIndentAt( pArr0to2[1] );
            }
            // <--

            aFmt.SetCharFmt( pNumCFmt );
            pNewRule->Set( 0, aFmt );

            aFmt.SetIncludeUpperLevels( 2 );
            aFmt.SetStart( 2 );
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( -pArr0to2[2] );    // == 0.65 cm
                aFmt.SetAbsLSpace( pArr0to2[3] );           // == 1.10 cm
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetFirstLineIndent( -pArr0to2[2] );
                aFmt.SetListtabPos( pArr0to2[3] );
                aFmt.SetIndentAt( pArr0to2[3] );
            }
            // <--
            pNewRule->Set( 1, aFmt );

            aFmt.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER);
            aFmt.SetSuffix( ')');
            aFmt.SetIncludeUpperLevels( 1 );
            aFmt.SetStart( 3 );
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - pArr0to2[4] );   // == 0.45cm
                aFmt.SetAbsLSpace( pArr0to2[5] );           // == 1.55 cm
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetFirstLineIndent( -pArr0to2[4] );
                aFmt.SetListtabPos( pArr0to2[5] );
                aFmt.SetIndentAt( pArr0to2[5] );
            }
            // <--
            pNewRule->Set( 2, aFmt );


            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
            // <--
            aFmt.SetBulletChar( cBulletChar );
            sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4,
                   nOffs2 = GetMetricVal( CM_1 ) * 2;

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - nOffs );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetFirstLineIndent( - nOffs );
            }
            // <--
            aFmt.SetSuffix( aEmptyStr );
            for( n = 3; n < MAXLEVEL; ++n )
            {
                aFmt.SetStart( n+1 );
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( nOffs2 + ((n-3) * nOffs) );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( nOffs2 + ((n-3) * nOffs) );
                    aFmt.SetIndentAt( nOffs2 + ((n-3) * nOffs) );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;

    case RES_POOLNUMRULE_BUL1:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont( &numfunc::GetDefBulletFont() );
            // <--
            aFmt.SetBulletChar( cBulletChar );

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_BUL2:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
            // <--
            aFmt.SetBulletChar( 0x2013 );

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,3  0,6  0,9  1,2  1,5  1,8   2,1   2,4   2,7   3,0
                    170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_BUL3:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
            // <--

            sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4;
            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - nOffs );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - nOffs );
            }
            // <--

            for( n = 0; n < MAXLEVEL; ++n )
            {
                aFmt.SetBulletChar( ( n & 1 ? 0x25a1 : 0x2611 ) );
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( ((n & 1) +1) * nOffs );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( ((n & 1) +1) * nOffs );
                    aFmt.SetIndentAt( ((n & 1) +1) * nOffs );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_BUL4:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
            // <--

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                switch( n )
                {
                case 0:     aFmt.SetBulletChar( 0x27a2 );   break;
                case 1:     aFmt.SetBulletChar( 0xE006 );   break;
                default:    aFmt.SetBulletChar( 0xE004 );   break;
                }
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    case RES_POOLNUMRULE_BUL5:
        {
            SwNumFmt aFmt;
            // --> OD 2008-02-11 #newlistlevelattrs#
            aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
            // <--
            aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
            aFmt.SetCharFmt( pBullCFmt );
            aFmt.SetStart( 1 );
            aFmt.SetIncludeUpperLevels( 1 );
            aFmt.SetBulletChar( 0x2717 );
            // --> OD 2006-06-29 #6440955#
            aFmt.SetBulletFont( &numfunc::GetDefBulletFont() );
            // <--

            static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
                {
//              cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
#ifdef USE_MEASUREMENT
            static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
                {
                    227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
                };
            const sal_uInt16* pArr = MEASURE_METRIC ==
                                SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
                                    ? aAbsSpace
                                    : aAbsSpaceInch;
#else
            const sal_uInt16* pArr = aAbsSpace;
#endif

            // --> OD 2008-02-11 #newlistlevelattrs#
            if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                aFmt.SetFirstLineOffset( - (*pArr) );
            }
            else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
            {
                aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
                aFmt.SetFirstLineIndent( - (*pArr) );
            }
            // <--
            for( n = 0; n < MAXLEVEL; ++n, ++pArr )
            {
                // --> OD 2008-02-11 #newlistlevelattrs#
                if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
                {
                    aFmt.SetAbsLSpace( *pArr );
                }
                else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    aFmt.SetListtabPos( *pArr );
                    aFmt.SetIndentAt( *pArr );
                }
                // <--
                pNewRule->Set( n, aFmt );
            }
        }
        break;
    }

    return pNewRule;
}



    // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
    // benutzt wird
bool SwDoc::IsPoolPageDescUsed( sal_uInt16 nId ) const
{
    ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
            "Falsche AutoFormat-Id" );
    SwPageDesc *pNewPgDsc = 0;
    sal_Bool bFnd = sal_False;
    for( sal_uInt16 n = 0; !bFnd && n < aPageDescs.Count(); ++n )
    {
        pNewPgDsc = aPageDescs[ n ];
        if( nId == pNewPgDsc->GetPoolFmtId() )
            bFnd = sal_True;
    }

    // nicht gefunden oder keine Abhaengigen ?
    if( !bFnd || !pNewPgDsc->GetDepends() )     // ??????
        return sal_False;

    // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
    // (auch indirekte fuer Format-Ableitung! )
    SwAutoFmtGetDocNode aGetHt( &GetNodes() );
    return !pNewPgDsc->GetInfo( aGetHt );
}

// erfrage ob die Absatz-/Zeichen-/Rahmen-/Seiten - Vorlage benutzt wird
sal_Bool SwDoc::IsUsed( const SwModify& rModify ) const
{
    // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
    // (auch indirekte fuer Format-Ableitung! )
    SwAutoFmtGetDocNode aGetHt( &GetNodes() );
    return !rModify.GetInfo( aGetHt );
}

// erfrage ob die NumRule benutzt wird
sal_Bool SwDoc::IsUsed( const SwNumRule& rRule ) const
{
    // --> OD 2008-03-04 #refactorlists#
//    // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
//    // (auch indirekte fuer Format-Ableitung! )
//    sal_Bool bUsed = sal_False;
//    SwAutoFmtGetDocNode aGetHt( &aNodes );
//    SwModify* pMod;
//    const SfxPoolItem* pItem;
//    sal_uInt16 i, nMaxItems = GetAttrPool().GetItemCount( RES_PARATR_NUMRULE);
//    for( i = 0; i < nMaxItems; ++i )
//    {
//        if( 0 != (pItem = GetAttrPool().GetItem( RES_PARATR_NUMRULE, i ) ) &&
//            0 != ( pMod = (SwModify*)((SwNumRuleItem*)pItem)->GetDefinedIn()) &&
//            ((SwNumRuleItem*)pItem)->GetValue().Len() &&
//            ((SwNumRuleItem*)pItem)->GetValue() == rRule.GetName() )
//        {
//            if( pMod->IsA( TYPE( SwFmt )) )
//            {
//                bUsed = !pMod->GetInfo( aGetHt );
//                if( bUsed )
//                    break;
//            }
//            else if( ((SwTxtNode*)pMod)->GetNodes().IsDocNodes() )
//            {
//                bUsed = sal_True;
//                break;
//            }
//        }
//    }

//    return bUsed;
    sal_Bool bUsed = rRule.GetTxtNodeListSize() > 0 ||
                     rRule.GetParagraphStyleListSize() > 0;

    return bUsed;
    // <--
}

    // Suche die Position vom Vorlagen-Namen. Ist nicht vorhanden
    // dann fuege neu ein
sal_uInt16 SwDoc::SetDocPattern( const String& rPatternName )
{
    ASSERT( rPatternName.Len(), "kein Dokument-Vorlagenname" );

    sal_uInt16 nNewPos = aPatternNms.Count();
    for( sal_uInt16 n = 0; n < aPatternNms.Count(); ++n )
        if( !aPatternNms[n] )
        {
            if( nNewPos == aPatternNms.Count() )
                nNewPos = n;
        }
        else if( rPatternName == *aPatternNms[n] )
            return n;

    if( nNewPos < aPatternNms.Count() )
        aPatternNms.Remove( nNewPos );      // Platz wieder frei machen

    String* pNewNm = new String( rPatternName );
    aPatternNms.Insert( pNewNm, nNewPos );
    SetModified();
    return nNewPos;
}

sal_uInt16 GetPoolParent( sal_uInt16 nId )
{
    sal_uInt16 nRet = USHRT_MAX;
    if( POOLGRP_NOCOLLID & nId )        // 1 == Formate / 0 == Collections
    {
        switch( ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID ) & nId )
        {
        case POOLGRP_CHARFMT:
        case POOLGRP_FRAMEFMT:
            nRet = 0;           // vom default abgeleitet
            break;
        case POOLGRP_PAGEDESC:
        case POOLGRP_NUMRULE:
            break;              // es gibt keine Ableitung
        }
    }
    else
    {
        switch( COLL_GET_RANGE_BITS & nId )
        {
        case COLL_TEXT_BITS:
            switch( nId )
            {
            case RES_POOLCOLL_STANDARD:
                    nRet = 0;                                   break;
            case RES_POOLCOLL_TEXT_IDENT:
            case RES_POOLCOLL_TEXT_NEGIDENT:
            case RES_POOLCOLL_TEXT_MOVE:
            case RES_POOLCOLL_CONFRONTATION:
            case RES_POOLCOLL_MARGINAL:
                    nRet = RES_POOLCOLL_TEXT;                   break;

            case RES_POOLCOLL_TEXT:
            case RES_POOLCOLL_GREETING:
            case RES_POOLCOLL_SIGNATURE:
            case RES_POOLCOLL_HEADLINE_BASE:
                    nRet = RES_POOLCOLL_STANDARD;               break;

            case RES_POOLCOLL_HEADLINE1:
            case RES_POOLCOLL_HEADLINE2:
            case RES_POOLCOLL_HEADLINE3:
            case RES_POOLCOLL_HEADLINE4:
            case RES_POOLCOLL_HEADLINE5:
            case RES_POOLCOLL_HEADLINE6:
            case RES_POOLCOLL_HEADLINE7:
            case RES_POOLCOLL_HEADLINE8:
            case RES_POOLCOLL_HEADLINE9:
            case RES_POOLCOLL_HEADLINE10:
                    nRet = RES_POOLCOLL_HEADLINE_BASE;          break;
            }
            break;

        case COLL_LISTS_BITS:
            switch( nId )
            {
            case RES_POOLCOLL_NUMBUL_BASE:
                    nRet = RES_POOLCOLL_TEXT;                   break;

            default:
                nRet = RES_POOLCOLL_NUMBUL_BASE;                break;
            }
            break;

        case COLL_EXTRA_BITS:
            switch( nId )
            {
            case RES_POOLCOLL_FRAME:
                    nRet = RES_POOLCOLL_TEXT;                   break;

            case RES_POOLCOLL_TABLE_HDLN:
                    nRet = RES_POOLCOLL_TABLE;                  break;

            case RES_POOLCOLL_TABLE:
            case RES_POOLCOLL_FOOTNOTE:
            case RES_POOLCOLL_ENDNOTE:
            case RES_POOLCOLL_JAKETADRESS:
            case RES_POOLCOLL_SENDADRESS:
            case RES_POOLCOLL_HEADER:
            case RES_POOLCOLL_HEADERL:
            case RES_POOLCOLL_HEADERR:
            case RES_POOLCOLL_FOOTER:
            case RES_POOLCOLL_FOOTERL:
            case RES_POOLCOLL_FOOTERR:
            case RES_POOLCOLL_LABEL:
                    nRet = RES_POOLCOLL_STANDARD;               break;

            case RES_POOLCOLL_LABEL_ABB:
            case RES_POOLCOLL_LABEL_TABLE:
            case RES_POOLCOLL_LABEL_FRAME:
            case RES_POOLCOLL_LABEL_DRAWING:
                    nRet = RES_POOLCOLL_LABEL;                  break;
            }
            break;

        case COLL_REGISTER_BITS:
            switch( nId )
            {
            case RES_POOLCOLL_REGISTER_BASE:
                    nRet = RES_POOLCOLL_STANDARD;               break;

            case RES_POOLCOLL_TOX_USERH:
            case RES_POOLCOLL_TOX_CNTNTH:
            case RES_POOLCOLL_TOX_IDXH:
            case RES_POOLCOLL_TOX_ILLUSH:
            case RES_POOLCOLL_TOX_OBJECTH:
            case RES_POOLCOLL_TOX_TABLESH:
            case RES_POOLCOLL_TOX_AUTHORITIESH:
                    nRet = RES_POOLCOLL_HEADLINE_BASE;          break;

            default:
                    nRet = RES_POOLCOLL_REGISTER_BASE;          break;
            }
            break;

        case COLL_DOC_BITS:
            nRet = RES_POOLCOLL_HEADLINE_BASE;
            break;

        case COLL_HTML_BITS:
            nRet = RES_POOLCOLL_STANDARD;
            break;
        }
    }

    return nRet;
}

void SwDoc::RemoveAllFmtLanguageDependencies()
{
    /* #106748# Restore the language independ pool defaults and styles. */
    GetAttrPool().ResetPoolDefaultItem( RES_PARATR_ADJUST );

    SwTxtFmtColl * pTxtFmtColl = GetTxtCollFromPool( RES_POOLCOLL_STANDARD );

    pTxtFmtColl->ResetFmtAttr( RES_PARATR_ADJUST );
    /* #111214# koreans do not like SvxScriptItem(sal_True) */
    pTxtFmtColl->ResetFmtAttr( RES_PARATR_SCRIPTSPACE );

    SvxFrameDirectionItem aFrameDir( FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR );

    sal_uInt16 nCount = GetPageDescCnt();
    for( sal_uInt16 i=0; i<nCount; ++i )
    {
        SwPageDesc& rDesc = _GetPageDesc( i );
        rDesc.GetMaster().SetFmtAttr( aFrameDir );
        rDesc.GetLeft().SetFmtAttr( aFrameDir );
    }

    // OD 09.10.2003 #i18732# - restore static pool default for item
    // RES_FOLLOW_TEXT_FLOW.
    GetAttrPool().ResetPoolDefaultItem( RES_FOLLOW_TEXT_FLOW );

    //#i16874# AutoKerning as default for new documents
    GetAttrPool().ResetPoolDefaultItem( RES_CHRATR_AUTOKERN );
}