xref: /trunk/main/sw/source/ui/app/docstyle.cxx (revision 26ea3662d86be9f95232e6ac21c3a47954d21453)

/**************************************************************
 *
 * 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"

#define _SVSTDARR_USHORTS
#include <svl/smplhint.hxx>
#include <hintids.hxx>
#include <svl/itemiter.hxx>
#include <svl/eitem.hxx>
#include <svx/xdef.hxx>
#include <unotools/syslocale.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/numitem.hxx>
#include <editeng/lrspitem.hxx>
#include <fmtcol.hxx>
#include <uitool.hxx>
#include <swmodule.hxx>
#include <wrtsh.hxx>
#include <docsh.hxx>
#include <errhdl.hxx>
#include <frmfmt.hxx>
#include <charfmt.hxx>
#include <poolfmt.hxx>
#include <pagedesc.hxx>
#include <docstyle.hxx>
#include <docary.hxx>
#include <ccoll.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <cmdid.h>
#include <swstyle.h>
#include <app.hrc>
#include <paratr.hxx>
#include <SwStyleNameMapper.hxx>
#include <svl/cjkoptions.hxx>
#include <comphelper/processfactory.hxx>
#include <unotools/localedatawrapper.hxx>
#include <unotools/intlwrapper.hxx>
#include <numrule.hxx>
#include <fmthdft.hxx>
#include <svx/svxids.hrc>
#include <SwRewriter.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xflftrit.hxx>
#include <svx/svdmodel.hxx>
#include <svx/drawitem.hxx>
#include <drawdoc.hxx>

// MD 06.02.95: Die Formatnamen in der Liste aller Namen haben als
// erstes Zeichen die Familie:

#define cCHAR       (sal_Unicode)'c'
#define cPARA       (sal_Unicode)'p'
#define cFRAME      (sal_Unicode)'f'
#define cPAGE       (sal_Unicode)'g'
#define cNUMRULE    (sal_Unicode)'n'

// Dieses Zeichen wird bei der Herausgabe der Namen wieder entfernt und
// die Familie wird neu generiert.

// Ausserdem gibt es jetzt zusaetzlich das Bit bPhysical. Ist dieses Bit
// sal_True, werden die Pool-Formatnamen NICHT mit eingetragen.

class SwImplShellAction
{
    SwWrtShell* pSh;
    CurrShell* pCurrSh;
public:
    SwImplShellAction( SwDoc& rDoc );
    ~SwImplShellAction();

    SwWrtShell* GetSh() { return pSh; }
};

SwImplShellAction::SwImplShellAction( SwDoc& rDoc )
    : pCurrSh( 0 )
{
    if( rDoc.GetDocShell() )
        pSh = rDoc.GetDocShell()->GetWrtShell();
    else
        pSh = 0;

    if( pSh )
    {
        pCurrSh = new CurrShell( pSh );
        pSh->StartAllAction();
    }
}

SwImplShellAction::~SwImplShellAction()
{
    if( pCurrSh )
    {
        pSh->EndAllAction();
        delete pCurrSh;
    }
}

/*--------------------------------------------------------------------
    Beschreibung:   SwCharFormate finden/anlegen
                    evtl. Style fuellen
 --------------------------------------------------------------------*/

SwCharFmt* lcl_FindCharFmt( SwDoc& rDoc,
                            const String& rName,
                            SwDocStyleSheet* pStyle = 0,
                            sal_Bool bCreate = sal_True )
{
    SwCharFmt*  pFmt = 0;
    if( rName.Len() )
    {
        pFmt = rDoc.FindCharFmtByName( rName );
        if( !pFmt && rName == *SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
                                                RES_POOLCOLL_TEXT_BEGIN ] )
        {
            // Standard-Zeichenvorlage
            pFmt = (SwCharFmt*)rDoc.GetDfltCharFmt();
        }

        if( !pFmt && bCreate )
        {   // Pool abklappern
            const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
            if(nId != USHRT_MAX)
                pFmt = rDoc.GetCharFmtFromPool(nId);
        }
    }
    if(pStyle)
    {
        if(pFmt)
        {
            pStyle->SetPhysical(sal_True);
            SwFmt* p = pFmt->DerivedFrom();
            if( p && !p->IsDefault() )
                pStyle->PresetParent( p->GetName() );
            else
                pStyle->PresetParent( aEmptyStr );
        }
        else
            pStyle->SetPhysical(sal_False);
    }
    return pFmt;
}


/*--------------------------------------------------------------------
    Beschreibung:   ParaFormate finden/erzeugen
                    Style fuellen
 --------------------------------------------------------------------*/

SwTxtFmtColl* lcl_FindParaFmt(  SwDoc& rDoc,
                                const String& rName,
                                SwDocStyleSheet* pStyle = 0,
                                sal_Bool bCreate = sal_True )
{
    SwTxtFmtColl*   pColl = 0;

    if( rName.Len() )
    {
        pColl = rDoc.FindTxtFmtCollByName( rName );
        if( !pColl && bCreate )
        {   // Pool abklappern
            const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
            if(nId != USHRT_MAX)
                pColl = rDoc.GetTxtCollFromPool(nId);
        }
    }

    if(pStyle)
    {
        if(pColl)
        {
            pStyle->SetPhysical(sal_True);
            if( pColl->DerivedFrom() && !pColl->DerivedFrom()->IsDefault() )
                pStyle->PresetParent( pColl->DerivedFrom()->GetName() );
            else
                pStyle->PresetParent( aEmptyStr );

            SwTxtFmtColl& rNext = pColl->GetNextTxtFmtColl();
            pStyle->PresetFollow(rNext.GetName());
        }
        else
            pStyle->SetPhysical(sal_False);
    }
    return pColl;
}


/*--------------------------------------------------------------------
    Beschreibung:   Rahmenformate
 --------------------------------------------------------------------*/


SwFrmFmt* lcl_FindFrmFmt(   SwDoc& rDoc,
                            const String& rName,
                            SwDocStyleSheet* pStyle = 0,
                            sal_Bool bCreate = sal_True )
{
    SwFrmFmt* pFmt = 0;
    if( rName.Len() )
    {
        pFmt = rDoc.FindFrmFmtByName( rName );
        if( !pFmt && bCreate )
        {   // Pool abklappern
            const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT);
            if(nId != USHRT_MAX)
                pFmt = rDoc.GetFrmFmtFromPool(nId);
        }
    }

    if(pStyle)
    {
        if(pFmt)
        {
            pStyle->SetPhysical(sal_True);
            if( pFmt->DerivedFrom() && !pFmt->DerivedFrom()->IsDefault() )
                pStyle->PresetParent( pFmt->DerivedFrom()->GetName() );
            else
                pStyle->PresetParent( aEmptyStr );
        }
        else
            pStyle->SetPhysical(sal_False);
    }
    return pFmt;
}

/*--------------------------------------------------------------------
    Beschreibung:   Seitendescriptoren
 --------------------------------------------------------------------*/


const SwPageDesc* lcl_FindPageDesc( SwDoc&  rDoc,
                                    const String&    rName,
                                    SwDocStyleSheet* pStyle = 0,
                                    sal_Bool bCreate = sal_True )
{
    const SwPageDesc* pDesc = 0;

    if( rName.Len() )
    {
        pDesc = rDoc.FindPageDescByName( rName );
        if( !pDesc && bCreate )
        {
            sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC);
            if(nId != USHRT_MAX)
                pDesc = rDoc.GetPageDescFromPool(nId);
        }
    }

    if(pStyle)
    {
        if(pDesc)
        {
            pStyle->SetPhysical(sal_True);
            if(pDesc->GetFollow())
                pStyle->PresetFollow(pDesc->GetFollow()->GetName());
            else
                pStyle->PresetParent( aEmptyStr );
        }
        else
            pStyle->SetPhysical(sal_False);
    }
    return pDesc;
}

const SwNumRule* lcl_FindNumRule(   SwDoc&  rDoc,
                                    const String&    rName,
                                    SwDocStyleSheet* pStyle = 0,
                                    sal_Bool bCreate = sal_True )
{
    const SwNumRule* pRule = 0;

    if( rName.Len() )
    {
        pRule = rDoc.FindNumRulePtr( rName );
        if( !pRule && bCreate )
        {
            sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE);
            if(nId != USHRT_MAX)
                pRule = rDoc.GetNumRuleFromPool(nId);
        }
    }

    if(pStyle)
    {
        if(pRule)
        {
            pStyle->SetPhysical(sal_True);
            pStyle->PresetParent( aEmptyStr );
        }
        else
            pStyle->SetPhysical(sal_False);
    }
    return pRule;
}


sal_uInt16 lcl_FindName( const SwPoolFmtList& rLst, SfxStyleFamily eFam,
                        const String& rName )
{
    if( rLst.Count() )
    {
        // suchen
        String sSrch( ' ' );
        switch( eFam )
        {
        case SFX_STYLE_FAMILY_CHAR:  sSrch = cCHAR;     break;
        case SFX_STYLE_FAMILY_PARA:  sSrch = cPARA;     break;
        case SFX_STYLE_FAMILY_FRAME: sSrch = cFRAME;    break;
        case SFX_STYLE_FAMILY_PAGE:  sSrch = cPAGE;     break;
        case SFX_STYLE_FAMILY_PSEUDO: sSrch = cNUMRULE; break;
        default:; //prevent warning
        }
        sSrch += rName;
        for( sal_uInt16 i=0; i < rLst.Count(); ++i )
            if( *rLst[i] == sSrch )
                return i;
    }
    return USHRT_MAX;
}

sal_Bool FindPhyStyle( SwDoc& rDoc, const String& rName, SfxStyleFamily eFam )
{
    switch( eFam )
    {
    case SFX_STYLE_FAMILY_CHAR :
        return 0 != lcl_FindCharFmt( rDoc, rName, 0, sal_False );
    case SFX_STYLE_FAMILY_PARA :
        return 0 != lcl_FindParaFmt( rDoc, rName, 0, sal_False );
    case SFX_STYLE_FAMILY_FRAME:
        return 0 != lcl_FindFrmFmt( rDoc, rName, 0, sal_False );
    case SFX_STYLE_FAMILY_PAGE :
        return 0 != lcl_FindPageDesc( rDoc, rName, 0, sal_False );
    case SFX_STYLE_FAMILY_PSEUDO:
        return 0 != lcl_FindNumRule( rDoc, rName, 0, sal_False );
    default:; //prevent warning
    }
    return sal_False;
}


/*--------------------------------------------------------------------
    Beschreibung:   Einfuegen von Strings in die Liste der Vorlagen
 --------------------------------------------------------------------*/


void SwPoolFmtList::Append( char cChar, const String& rStr )
{
    String* pStr = new String( cChar );
    *pStr += rStr;
    for ( sal_uInt16 i=0; i < Count(); ++i )
    {
        if( *operator[](i) == *pStr )
        {
            delete pStr;
            return;
        }
    }
    Insert( pStr, Count() );
}

/*--------------------------------------------------------------------
    Beschreibung:   Liste kompletti loeschen
 --------------------------------------------------------------------*/


void SwPoolFmtList::Erase()
{
    DeleteAndDestroy( 0, Count() );
}

/*  */

/*--------------------------------------------------------------------
    Beschreibung:  UI-seitige implementierung von StyleSheets
                   greift auf die Core-Engine zu
 --------------------------------------------------------------------*/

SwDocStyleSheet::SwDocStyleSheet(   SwDoc&          rDocument,
                                    const String&           rName,
                                    SwDocStyleSheetPool&    _rPool,
                                    SfxStyleFamily          eFam,
                                    sal_uInt16                  _nMask) :

    SfxStyleSheetBase( rName, _rPool, eFam, _nMask ),
    pCharFmt(0),
    pColl(0),
    pFrmFmt(0),
    pDesc(0),
    pNumRule(0),

    rDoc(rDocument),
    aCoreSet(GetPool().GetPool(),   //UUUU sorted by indices, one double removed
            RES_CHRATR_BEGIN,       RES_CHRATR_END - 1,             // [1
            RES_PARATR_BEGIN,       RES_PARATR_END - 1,             // [60
            // --> OD 2008-02-25 #refactorlists#
            RES_PARATR_LIST_BEGIN,  RES_PARATR_LIST_END - 1,        // [77
            // <--
            RES_FRMATR_BEGIN,       RES_FRMATR_END - 1,             // [82
            RES_UNKNOWNATR_BEGIN,   RES_UNKNOWNATR_END-1,           // [143

            //UUUU FillAttribute support
            XATTR_FILL_FIRST, XATTR_FILL_LAST,                      // [1014

            SID_ATTR_BORDER_INNER,  SID_ATTR_BORDER_INNER,          // [10023
            SID_ATTR_PAGE,          SID_ATTR_PAGE_EXT1,             // [10050
            SID_ATTR_PAGE_HEADERSET,SID_ATTR_PAGE_FOOTERSET,        // [10058
            SID_ATTR_PARA_MODEL,    SID_ATTR_PARA_MODEL,            // [10065

            //UUUU items to hand over XPropertyList things like
            // XColorList, XHatchList, XGradientList and XBitmapList
            // to the Area TabPage
            SID_COLOR_TABLE,        SID_BITMAP_LIST,                // [10179

            SID_SWREGISTER_COLLECTION, SID_SWREGISTER_COLLECTION,   // [10451
            SID_ATTR_PARA_PAGENUM, SID_ATTR_PARA_PAGENUM,           // [10457
            SID_SWREGISTER_MODE,    SID_SWREGISTER_MODE,            // [10467
            SID_PARA_BACKGRND_DESTINATION,  SID_ATTR_BRUSH_CHAR,    // [10590
            SID_ATTR_NUMBERING_RULE,    SID_ATTR_NUMBERING_RULE,    // [10855
            SID_ATTR_AUTO_STYLE_UPDATE, SID_ATTR_AUTO_STYLE_UPDATE, // [12065
            FN_PARAM_FTN_INFO,      FN_PARAM_FTN_INFO,              // [21123
            FN_COND_COLL,           FN_COND_COLL,                   // [22401
            0),
    bPhysical(sal_False)
{
    nHelpId = UCHAR_MAX;
}


SwDocStyleSheet::SwDocStyleSheet( const SwDocStyleSheet& rOrg) :
    SfxStyleSheetBase(rOrg),
    pCharFmt(rOrg.pCharFmt),
    pColl(rOrg.pColl),
    pFrmFmt(rOrg.pFrmFmt),
    pDesc(rOrg.pDesc),
    pNumRule(rOrg.pNumRule),
    rDoc(rOrg.rDoc),
    aCoreSet(rOrg.aCoreSet),
    bPhysical(rOrg.bPhysical)
{
}


 SwDocStyleSheet::~SwDocStyleSheet()
{
}

/*--------------------------------------------------------------------
    Beschreibung:   Zuruecksetzen
 --------------------------------------------------------------------*/


void  SwDocStyleSheet::Reset()
{
    aName.Erase();
    aFollow.Erase();
    aParent.Erase();
    SetPhysical(sal_False);
}

/*--------------------------------------------------------------------
    Beschreibung:   virtuelle Methoden
 --------------------------------------------------------------------*/


const String&  SwDocStyleSheet::GetParent() const
{
    if( !bPhysical )
    {
        // dann pruefe, ob schon im Doc vorhanden
        SwFmt* pFmt = 0;
        SwGetPoolIdFromName eGetType;
        switch(nFamily)
        {
        case SFX_STYLE_FAMILY_CHAR:
            pFmt = rDoc.FindCharFmtByName( aName );
            eGetType = nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
            break;

        case SFX_STYLE_FAMILY_PARA:
            pFmt = rDoc.FindTxtFmtCollByName( aName );
            eGetType = nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL;
            break;

        case SFX_STYLE_FAMILY_FRAME:
            pFmt = rDoc.FindFrmFmtByName( aName );
            eGetType = nsSwGetPoolIdFromName::GET_POOLID_FRMFMT;
            break;

        case SFX_STYLE_FAMILY_PAGE:
        case SFX_STYLE_FAMILY_PSEUDO:
        default:
            return aEmptyStr;       // es gibt keinen Parent
        }

        String sTmp;
        if( !pFmt )         // noch nicht vorhanden, also dflt. Parent
        {
            sal_uInt16 i = SwStyleNameMapper::GetPoolIdFromUIName( aName, eGetType );
            i = ::GetPoolParent( i );
            if( i && USHRT_MAX != i )
                SwStyleNameMapper::FillUIName( i, sTmp );
        }
        else
        {
            SwFmt* p = pFmt->DerivedFrom();
            if( p && !p->IsDefault() )
                sTmp = p->GetName();
        }
        SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
        pThis->aParent = sTmp;
    }
    return aParent;
}

/*--------------------------------------------------------------------
   Beschreibung:    Nachfolger
 --------------------------------------------------------------------*/


const String&  SwDocStyleSheet::GetFollow() const
{
    if( !bPhysical )
    {
        SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
        pThis->FillStyleSheet( FillAllInfo );
    }
    return aFollow;
}

/*--------------------------------------------------------------------
    Beschreibung:   Welche Verkettung ist moeglich
 --------------------------------------------------------------------*/


sal_Bool  SwDocStyleSheet::HasFollowSupport() const
{
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_PARA :
        case SFX_STYLE_FAMILY_PAGE : return sal_True;
        case SFX_STYLE_FAMILY_FRAME:
        case SFX_STYLE_FAMILY_CHAR :
        case SFX_STYLE_FAMILY_PSEUDO: return sal_False;
        default:
            ASSERT(!this, "unbekannte Style-Familie");
    }
    return sal_False;
}

/*--------------------------------------------------------------------
    Beschreibung:   Parent ?
 --------------------------------------------------------------------*/


sal_Bool  SwDocStyleSheet::HasParentSupport() const
{
    sal_Bool bRet = sal_False;
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR :
        case SFX_STYLE_FAMILY_PARA :
        case SFX_STYLE_FAMILY_FRAME: bRet = sal_True;
        default:; //prevent warning
    }
    return bRet;
}


sal_Bool  SwDocStyleSheet::HasClearParentSupport() const
{
    sal_Bool bRet = sal_False;
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_PARA :
        case SFX_STYLE_FAMILY_CHAR :
        case SFX_STYLE_FAMILY_FRAME: bRet = sal_True;
        default:; //prevent warning
    }
    return bRet;
}

/*--------------------------------------------------------------------
    Beschreibung:   textuelle Beschreibung ermitteln
 --------------------------------------------------------------------*/
String  SwDocStyleSheet::GetDescription(SfxMapUnit eUnit)
{
    IntlWrapper aIntlWrapper(
        ::comphelper::getProcessServiceFactory(),
        SvtSysLocale().GetLocaleData().getLocale());

    String sPlus(String::CreateFromAscii(" + "));
    if ( SFX_STYLE_FAMILY_PAGE == nFamily )
    {
        if( !pSet )
            GetItemSet();

        SfxItemIter aIter( *pSet );
        String aDesc;
        const SfxPoolItem* pItem = aIter.FirstItem();

        while ( pItem )
        {
            if(!IsInvalidItem(pItem))
                switch ( pItem->Which() )
                {
                    case RES_LR_SPACE:
                    case SID_ATTR_PAGE_SIZE:
                    case SID_ATTR_PAGE_MAXSIZE:
                    case SID_ATTR_PAGE_PAPERBIN:
                    case SID_ATTR_PAGE_APP:
                    case SID_ATTR_BORDER_INNER:
                        break;
                    default:
                    {
                        String aItemPresentation;
                        if ( !IsInvalidItem( pItem ) &&
                             rPool.GetPool().GetPresentation(
                                *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
                                eUnit, aItemPresentation, &aIntlWrapper ) )
                        {
                            if ( aDesc.Len() && aItemPresentation.Len() )
                                aDesc += sPlus;
                            aDesc += aItemPresentation;
                        }
                    }
                }
            pItem = aIter.NextItem();
        }
        return aDesc;
    }
    else if ( SFX_STYLE_FAMILY_FRAME == nFamily ||
                    SFX_STYLE_FAMILY_PARA == nFamily)
    {
        if( !pSet )
            GetItemSet();

        SfxItemIter aIter( *pSet );
        String aDesc;
        const SfxPoolItem* pItem = aIter.FirstItem();

        String sPageNum, sModel, sBreak;
        sal_Bool bHasWesternFontPrefix = sal_False;
        sal_Bool bHasCJKFontPrefix = sal_False;
        SvtCJKOptions aCJKOptions;

        //UUUU Get currently used FillStyle and remember, also need the XFillFloatTransparenceItem
        // to decide if gradient transparence is used
        const XFillStyle eFillStyle(static_cast< const XFillStyleItem& >(pSet->Get(XATTR_FILLSTYLE)).GetValue());
        const bool bUseFloatTransparence(static_cast< const XFillFloatTransparenceItem& >(pSet->Get(XATTR_FILLFLOATTRANSPARENCE)).IsEnabled());

        while ( pItem )
        {
            if(!IsInvalidItem(pItem))
                switch ( pItem->Which() )
                {
                    case SID_ATTR_AUTO_STYLE_UPDATE:
                    case SID_PARA_BACKGRND_DESTINATION:
                    case RES_PAGEDESC:
                    //CTL no yet supported
                    case RES_CHRATR_CTL_FONT:
                    case RES_CHRATR_CTL_FONTSIZE:
                    case RES_CHRATR_CTL_LANGUAGE:
                    case RES_CHRATR_CTL_POSTURE:
                    case RES_CHRATR_CTL_WEIGHT:
                        break;
                    default:
                    {
                        String aItemPresentation;
                        if ( !IsInvalidItem( pItem ) &&
                             rPool.GetPool().GetPresentation(
                                *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
                                eUnit, aItemPresentation, &aIntlWrapper ) )
                        {
                            sal_Bool bIsDefault = sal_False;
                            switch ( pItem->Which() )
                            {
                                //UUUU
                                case XATTR_FILLCOLOR:
                                {
                                    // only use active FillStyle information
                                    bIsDefault = (XFILL_SOLID == eFillStyle);
                                    break;
                                }
                                case XATTR_FILLGRADIENT:
                                {
                                    // only use active FillStyle information
                                    bIsDefault = (XFILL_GRADIENT == eFillStyle);
                                    break;
                                }
                                case XATTR_FILLHATCH:
                                {
                                    // only use active FillStyle information
                                    bIsDefault = (XFILL_HATCH == eFillStyle);
                                    break;
                                }
                                case XATTR_FILLBITMAP:
                                {
                                    // only use active FillStyle information
                                    bIsDefault = (XFILL_BITMAP == eFillStyle);
                                    break;
                                }
                                case XATTR_FILLTRANSPARENCE:
                                {
                                    // only active when not FloatTransparence
                                    bIsDefault = !bUseFloatTransparence;
                                    break;
                                }
                                case XATTR_FILLFLOATTRANSPARENCE:
                                {
                                    // only active when FloatTransparence
                                    bIsDefault = bUseFloatTransparence;
                                    break;
                                }

                                case SID_ATTR_PARA_PAGENUM:
                                    sPageNum = aItemPresentation;
                                    break;
                                case SID_ATTR_PARA_MODEL:
                                    sModel = aItemPresentation;
                                    break;
                                case RES_BREAK:
                                    sBreak = aItemPresentation;
                                    break;
                                case RES_CHRATR_CJK_FONT:
                                case RES_CHRATR_CJK_FONTSIZE:
                                case RES_CHRATR_CJK_LANGUAGE:
                                case RES_CHRATR_CJK_POSTURE:
                                case RES_CHRATR_CJK_WEIGHT:
                                if(aCJKOptions.IsCJKFontEnabled())
                                    bIsDefault = sal_True;
                                if(!bHasCJKFontPrefix)
                                {
                                    aItemPresentation.Insert(SW_RESSTR(STR_CJK_FONT), 0);
                                    bHasCJKFontPrefix = sal_True;
                                }
                                break;
                                case RES_CHRATR_FONT:
                                case RES_CHRATR_FONTSIZE:
                                case RES_CHRATR_LANGUAGE:
                                case RES_CHRATR_POSTURE:
                                case RES_CHRATR_WEIGHT:
                                if(!bHasWesternFontPrefix)
                                {
                                    aItemPresentation.Insert(SW_RESSTR(STR_WESTERN_FONT), 0);
                                    bHasWesternFontPrefix = sal_True;
                                    bIsDefault = sal_True;
                                }
                                // no break;
                                default:
                                    bIsDefault = sal_True;
                            }
                            if(bIsDefault)
                            {
                                if ( aDesc.Len() && aItemPresentation.Len() )
                                    aDesc += sPlus;
                                aDesc += aItemPresentation;
                            }
                        }
                    }
                }
            pItem = aIter.NextItem();
        }
        //Sonderbehandlung fuer Umburch, Seitenvorlage und Seitenoffset
        if(sBreak.Len() && !sModel.Len())  // wemm Model. dann ist Break ungueltig
        {
            if(aDesc.Len())
                aDesc += sPlus;
            aDesc += sBreak;
        }
        if(sModel.Len())
        {
            if(aDesc.Len())
                aDesc += sPlus;
            aDesc += SW_RESSTR(STR_PAGEBREAK);
            aDesc += sPlus;
            aDesc += sModel;
            if(sPageNum != String(UniString::CreateFromInt32(0)))
            {
                aDesc += sPlus;
                aDesc += SW_RESSTR(STR_PAGEOFFSET);
                aDesc += sPageNum;
            }
        }
        return aDesc;
    }
    else if( SFX_STYLE_FAMILY_PSEUDO == nFamily )
    {
//      if( pNumRule )
//          return pNumRule->GetName();
        //os: was sollte man bei Numerierungen schon anzeigen?
        return aEmptyStr;
    }

    return SfxStyleSheetBase::GetDescription(eUnit);
}


String  SwDocStyleSheet::GetDescription()
{
    return GetDescription(SFX_MAPUNIT_CM);
}

/*--------------------------------------------------------------------
    Beschreibung:   Namen setzen
 --------------------------------------------------------------------*/


sal_Bool  SwDocStyleSheet::SetName( const String& rStr)
{
    if( !rStr.Len() )
        return sal_False;

    if( aName != rStr )
    {
        if( !SfxStyleSheetBase::SetName( rStr ))
            return sal_False;
    }
    else if(!bPhysical)
        FillStyleSheet( FillPhysical );

    int bChg = sal_False;
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR :
        {
            ASSERT(pCharFmt, "SwCharFormat fehlt!");
            if( pCharFmt && pCharFmt->GetName() != rStr )
            {
                pCharFmt->SetName( rStr );
                bChg = sal_True;
            }
            break;
        }
        case SFX_STYLE_FAMILY_PARA :
        {
            ASSERT(pColl, "Collektion fehlt!");
            if( pColl && pColl->GetName() != rStr )
            {
                if (pColl->GetName().Len() > 0)
                    rDoc.RenameFmt(*pColl, rStr);
                else
                    pColl->SetName(rStr);

                bChg = sal_True;
            }
            break;
        }
        case SFX_STYLE_FAMILY_FRAME:
        {
            ASSERT(pFrmFmt, "FrmFmt fehlt!");
            if( pFrmFmt && pFrmFmt->GetName() != rStr )
            {
                if (pFrmFmt->GetName().Len() > 0)
                    rDoc.RenameFmt(*pFrmFmt, rStr);
                else
                    pFrmFmt->SetName( rStr );

                bChg = sal_True;
            }
            break;
        }
        case SFX_STYLE_FAMILY_PAGE :
            ASSERT(pDesc, "PageDesc fehlt!");
            if( pDesc && pDesc->GetName() != rStr )
            {
                //PageDesc setzen - mit vorherigem kopieren - ist fuer das
                //setzen des Namens wohl nicht notwendig. Deshalb erlauben
                //wir hier mal einen cast.
                // -> #116530#
                SwPageDesc aPageDesc(*((SwPageDesc*)pDesc));
                String aOldName(aPageDesc.GetName());

                aPageDesc.SetName( rStr );
                bool const bDoesUndo = rDoc.GetIDocumentUndoRedo().DoesUndo();

                rDoc.GetIDocumentUndoRedo().DoUndo(aOldName.Len() > 0);
                rDoc.ChgPageDesc(aOldName, aPageDesc);
                rDoc.GetIDocumentUndoRedo().DoUndo(bDoesUndo);
                // <- #116530#

                rDoc.SetModified();
                bChg = sal_True;
            }
            break;
        case SFX_STYLE_FAMILY_PSEUDO:
            ASSERT(pNumRule, "NumRule fehlt!");

            // -> #106897#
            if (pNumRule)
            {
                String aOldName = pNumRule->GetName();

                if (aOldName.Len() > 0)
                {
                    if ( aOldName != rStr &&
                         rDoc.RenameNumRule(aOldName, rStr))
                    {
                        pNumRule = rDoc.FindNumRulePtr(rStr);
                        rDoc.SetModified();

                        bChg = sal_True;
                    }
                }
                else
                {
                    // --> OD 2008-07-08 #i91400#
                    ((SwNumRule*)pNumRule)->SetName( rStr, rDoc );
                    // <--
                    rDoc.SetModified();

                    bChg = sal_True;
                }
            }
            // <- #106897#

            break;

        default:
            ASSERT(!this, "unbekannte Style-Familie");
    }

    if( bChg )
    {
        rPool.First();      // interne Liste muss geupdatet werden
        rPool.Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED, *this ) );
        SwEditShell* pSh = rDoc.GetEditShell();
        if( pSh )
            pSh->CallChgLnk();
    }
    return sal_True;
}

/*--------------------------------------------------------------------
    Beschreibung:   Ableitungshirachie
 --------------------------------------------------------------------*/


sal_Bool   SwDocStyleSheet::SetParent( const String& rStr)
{
    SwFmt* pFmt = 0, *pParent = 0;
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR :
            ASSERT( pCharFmt, "SwCharFormat fehlt!" )
            if( 0 != ( pFmt = pCharFmt ) && rStr.Len() )
                pParent = lcl_FindCharFmt(rDoc, rStr);
            break;

        case SFX_STYLE_FAMILY_PARA :
            ASSERT( pColl, "Collektion fehlt!")
            if( 0 != ( pFmt = pColl ) && rStr.Len() )
                pParent = lcl_FindParaFmt( rDoc, rStr );
            break;

        case SFX_STYLE_FAMILY_FRAME:
            ASSERT(pFrmFmt, "FrameFormat fehlt!");
            if( 0 != ( pFmt = pFrmFmt ) && rStr.Len() )
                pParent = lcl_FindFrmFmt( rDoc, rStr );
            break;

        case SFX_STYLE_FAMILY_PAGE:
        case SFX_STYLE_FAMILY_PSEUDO:
            break;
        default:
            ASSERT(!this, "unbekannte Style-Familie");
    }

    sal_Bool bRet = sal_False;
    if( pFmt && pFmt->DerivedFrom() &&
        pFmt->DerivedFrom()->GetName() != rStr )
    {
        {
            SwImplShellAction aTmp( rDoc );
            bRet = pFmt->SetDerivedFrom( pParent );
        }

        if( bRet )
        {
            aParent = rStr;
            rPool.Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
                            *this ) );
        }
    }

    return bRet;
}

/*--------------------------------------------------------------------
    Beschreibung:   Nachfolger detzen
 --------------------------------------------------------------------*/


sal_Bool   SwDocStyleSheet::SetFollow( const String& rStr)
{
    if( rStr.Len() && !SfxStyleSheetBase::SetFollow( rStr ))
        return sal_False;

    SwImplShellAction aTmpSh( rDoc );
    switch(nFamily)
    {
    case SFX_STYLE_FAMILY_PARA :
    {
        ASSERT(pColl, "Collection fehlt!");
        if( pColl )
        {
            SwTxtFmtColl* pFollow = pColl;
            if( rStr.Len() && 0 == (pFollow = lcl_FindParaFmt(rDoc, rStr) ))
                pFollow = pColl;

            pColl->SetNextTxtFmtColl(*pFollow);
        }
        break;
    }
    case SFX_STYLE_FAMILY_PAGE :
    {
        ASSERT(pDesc, "PageDesc fehlt!");
        if( pDesc )
        {
            const SwPageDesc* pFollowDesc = rStr.Len()
                                            ? lcl_FindPageDesc(rDoc, rStr)
                                            : 0;
            sal_uInt16 nId;
            if( pFollowDesc != pDesc->GetFollow() &&
                rDoc.FindPageDescByName( pDesc->GetName(), &nId ) )
            {
                SwPageDesc aDesc( *pDesc );
                aDesc.SetFollow( pFollowDesc );
                rDoc.ChgPageDesc( nId, aDesc );
                pDesc = &const_cast<const SwDoc &>(rDoc).GetPageDesc( nId );
            }
        }
        break;
    }
    case SFX_STYLE_FAMILY_CHAR:
    case SFX_STYLE_FAMILY_FRAME:
    case SFX_STYLE_FAMILY_PSEUDO:
        break;
    default:
        ASSERT(!this, "unbekannte Style-Familie");
    }

    return sal_True;
}

/*--------------------------------------------------------------------
    Beschreibung:   ueber Name und Family, Mask den ItemSet rausholen
 --------------------------------------------------------------------*/

SfxItemSet&   SwDocStyleSheet::GetItemSet()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );

    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR:
            {
                ASSERT(pCharFmt, "Wo ist das SwCharFmt");
                aCoreSet.Put(pCharFmt->GetAttrSet());
                if(pCharFmt->DerivedFrom())
                    aCoreSet.SetParent(&pCharFmt->DerivedFrom()->GetAttrSet());
            }
            break;
        case SFX_STYLE_FAMILY_PARA :
        case SFX_STYLE_FAMILY_FRAME:
            {
                SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
                aBoxInfo.SetTable( sal_False );
                aBoxInfo.SetDist( sal_True);    // Abstandsfeld immer anzeigen
                aBoxInfo.SetMinDist( sal_True );// Minimalgroesse in Tabellen und Absaetzen setzen
                aBoxInfo.SetDefDist( MIN_BORDER_DIST );// Default-Abstand immer setzen
                    // Einzelne Linien koennen nur in Tabellen DontCare-Status haben
                aBoxInfo.SetValid( VALID_DISABLE, sal_True );
                if ( nFamily == SFX_STYLE_FAMILY_PARA )
                {
                    ASSERT(pColl, "Wo ist die Collektion");
                    aCoreSet.Put(pColl->GetAttrSet());
                    aCoreSet.Put( aBoxInfo );
                    aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pColl->IsAutoUpdateFmt()));
                    if(pColl->DerivedFrom())
                        aCoreSet.SetParent(&pColl->DerivedFrom()->GetAttrSet());
                }
                else
                {
                    ASSERT(pFrmFmt, "Wo ist das FrmFmt");
                    aCoreSet.Put(pFrmFmt->GetAttrSet());
                    aCoreSet.Put( aBoxInfo );
                    aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pFrmFmt->IsAutoUpdateFmt()));
                    if(pFrmFmt->DerivedFrom())
                        aCoreSet.SetParent(&pFrmFmt->DerivedFrom()->GetAttrSet());

                    //UUUU create needed items for XPropertyList entries from the DrawModel so that
                    // the Area TabPage can access them
                    const SwDrawModel* pDrawModel = rDoc.GetDrawModel();

                    aCoreSet.Put(SvxColorTableItem(pDrawModel->GetColorTableFromSdrModel(), SID_COLOR_TABLE));
                    aCoreSet.Put(SvxGradientListItem(pDrawModel->GetGradientListFromSdrModel(), SID_GRADIENT_LIST));
                    aCoreSet.Put(SvxHatchListItem(pDrawModel->GetHatchListFromSdrModel(), SID_HATCH_LIST));
                    aCoreSet.Put(SvxBitmapListItem(pDrawModel->GetBitmapListFromSdrModel(), SID_BITMAP_LIST));
                }
            }
            break;

        case SFX_STYLE_FAMILY_PAGE :
            {
                //UUUU set correct parent to get the XFILL_NONE FillStyle as needed
                if(!aCoreSet.GetParent())
                {
                    aCoreSet.SetParent(&rDoc.GetDfltFrmFmt()->GetAttrSet());
                }

                ASSERT(pDesc, "Kein PageDescriptor");
                ::PageDescToItemSet(*((SwPageDesc*)pDesc), aCoreSet);
            }
            break;

        case SFX_STYLE_FAMILY_PSEUDO:
            {
                ASSERT(pNumRule, "Keine NumRule");
                SvxNumRule aRule = pNumRule->MakeSvxNumRule();
                aCoreSet.Put(SvxNumBulletItem(aRule));
            }
            break;

        default:
            ASSERT(!this, "unbekannte Style-Familie");
    }
    // Member der Basisklasse
    pSet = &aCoreSet;

    return aCoreSet;
}

// --> OD 2008-02-13 #newlistlevelattrs#
void SwDocStyleSheet::MergeIndentAttrsOfListStyle( SfxItemSet& rSet )
{
    if ( nFamily != SFX_STYLE_FAMILY_PARA )
    {
        return;
    }

    ASSERT( pColl, "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - missing paragraph style");
    if ( pColl->AreListLevelIndentsApplicable() )
    {
        ASSERT( pColl->GetItemState( RES_PARATR_NUMRULE ) == SFX_ITEM_SET,
                "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - list level indents are applicable at paragraph style, but no list style found. Serious defect -> please inform OD." );
        const String sNumRule = pColl->GetNumRule().GetValue();
        if( sNumRule.Len() )
        {
            const SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
            if( pRule )
            {
                const SwNumFmt& rFmt = pRule->Get( 0 );
                if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
                {
                    SvxLRSpaceItem aLR( RES_LR_SPACE );
                    aLR.SetTxtLeft( rFmt.GetIndentAt() );
                    aLR.SetTxtFirstLineOfst( static_cast<short>(rFmt.GetFirstLineIndent()) );
                    rSet.Put( aLR );
                }
            }
        }
    }
}
// <--

/*--------------------------------------------------------------------
    Beschreibung:   ItemSet setzen
 --------------------------------------------------------------------*/

// --> OD 2008-02-12 #newlistlevelattrs#
// handling of parameter <bResetIndentAttrsAtParagraphStyle>
void SwDocStyleSheet::SetItemSet( const SfxItemSet& rSet,
                                  const bool bResetIndentAttrsAtParagraphStyle )
{
    // gegebenenfalls Format erst ermitteln
    if(!bPhysical)
        FillStyleSheet( FillPhysical );

    SwImplShellAction aTmpSh( rDoc );

    ASSERT( &rSet != &aCoreSet, "SetItemSet mit eigenem Set ist nicht erlaubt" );

    // --> OD 2008-02-12 #newlistlevelattrs#
    if (rDoc.GetIDocumentUndoRedo().DoesUndo())
    {
        SwRewriter aRewriter;
        aRewriter.AddRule( UNDO_ARG1, GetName() );
        rDoc.GetIDocumentUndoRedo().StartUndo( UNDO_INSFMTATTR, &aRewriter );
    }
    // <--

    SwFmt* pFmt = 0;
    SwPageDesc* pNewDsc = 0;
    sal_uInt16 nPgDscPos = 0;

    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR :
            {
                ASSERT(pCharFmt, "Wo ist das CharFormat");
                pFmt = pCharFmt;
            }
            break;

        case SFX_STYLE_FAMILY_PARA :
        {
            ASSERT(pColl, "Wo ist die Collection");
            const SfxPoolItem* pAutoUpdate;
            if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
            {
                pColl->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
            }

            const SwCondCollItem* pCondItem;
            if( SFX_ITEM_SET != rSet.GetItemState( FN_COND_COLL, sal_False,
                (const SfxPoolItem**)&pCondItem ))
                pCondItem = 0;

            if( RES_CONDTXTFMTCOLL == pColl->Which() && pCondItem )
            {
                SwFmt* pFindFmt;
                const CommandStruct* pCmds = SwCondCollItem::GetCmds();
                for(sal_uInt16 i = 0; i < COND_COMMAND_COUNT; i++)
                {
                    SwCollCondition aCond( 0, pCmds[ i ].nCnd, pCmds[ i ].nSubCond );
                    ((SwConditionTxtFmtColl*)pColl)->RemoveCondition( aCond );
                    const String& rStyle = pCondItem->GetStyle( i );
                    if( rStyle.Len() &&
                        0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
                    {
                        aCond.RegisterToFormat( *pFindFmt );
                        ((SwConditionTxtFmtColl*)pColl)->InsertCondition( aCond );
                    }
                }

                // Document auf die neue Bedingungen updaten
                SwCondCollCondChg aMsg( pColl );
                pColl->ModifyNotification( &aMsg, &aMsg );
            }
            else if( pCondItem && !pColl->GetDepends() )
            {
                // keine bedingte Vorlage, dann erstmal erzeugen und
                // alle wichtigen Werte uebernehmen
                SwConditionTxtFmtColl* pCColl = rDoc.MakeCondTxtFmtColl(
                        pColl->GetName(), (SwTxtFmtColl*)pColl->DerivedFrom() );
                if( pColl != &pColl->GetNextTxtFmtColl() )
                    pCColl->SetNextTxtFmtColl( pColl->GetNextTxtFmtColl() );

                //pCColl->SetOutlineLevel( pColl->GetOutlineLevel() );//#outline level,zhaojianwei
                if( pColl->IsAssignedToListLevelOfOutlineStyle())
                    pCColl->AssignToListLevelOfOutlineStyle(pColl->GetAssignedOutlineStyleLevel());
                else
                    pCColl->DeleteAssignmentToListLevelOfOutlineStyle();//<--end,zhaojianwei



                SwTxtFmtColl* pFindFmt;
                const CommandStruct* pCmds = SwCondCollItem::GetCmds();
                for( sal_uInt16 i = 0; i < COND_COMMAND_COUNT; ++i )
                {
                    const String& rStyle = pCondItem->GetStyle( i );
                    if( rStyle.Len() &&
                        0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
                    {
                        pCColl->InsertCondition( SwCollCondition( pFindFmt,
                                    pCmds[ i ].nCnd, pCmds[ i ].nSubCond ) );
                    }
                }

                rDoc.DelTxtFmtColl( pColl );
                pColl = pCColl;
            }
            // --> OD 2008-02-12 #newlistlevelattrs#
            if ( bResetIndentAttrsAtParagraphStyle &&
                 rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, 0 ) == SFX_ITEM_SET &&
                 rSet.GetItemState( RES_LR_SPACE, sal_False, 0 ) != SFX_ITEM_SET &&
                 pColl->GetItemState( RES_LR_SPACE, sal_False, 0 ) == SFX_ITEM_SET )
            {
                rDoc.ResetAttrAtFormat( RES_LR_SPACE, *pColl );
            }
            // <--

            // #i56252: If a standard numbering style is assigned to a standard paragraph style
            // we have to create a physical instance of the numbering style. If we do not and
            // neither the paragraph style nor the numbering style is used in the document
            // the numbering style will not be saved with the document and the assignment got lost.
            const SfxPoolItem* pNumRuleItem = 0;
            if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, &pNumRuleItem ) )
            {   // Setting a numbering rule?
                String sNumRule = ((SwNumRuleItem*)pNumRuleItem)->GetValue();
                if( sNumRule.Len() )
                {
                    SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
                    if( !pRule )
                    {   // Numbering rule not in use yet.
                        sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( sNumRule, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
                        if( USHRT_MAX != nPoolId ) // It's a standard numbering rule
                        {
                            pRule = rDoc.GetNumRuleFromPool( nPoolId ); // Create numbering rule (physical)
                        }
                    }
                }
            }

            pFmt = pColl;

            sal_uInt16 nId = pColl->GetPoolFmtId() &
                            ~ ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID );
            switch( GetMask() & ( 0x0fff & ~SWSTYLEBIT_CONDCOLL ) )
            {
                case SWSTYLEBIT_TEXT:
                    nId |= COLL_TEXT_BITS;
                    break;
                case SWSTYLEBIT_CHAPTER:
                    nId |= COLL_DOC_BITS;
                    break;
                case SWSTYLEBIT_LIST:
                    nId |= COLL_LISTS_BITS;
                    break;
                case SWSTYLEBIT_IDX:
                    nId |= COLL_REGISTER_BITS;
                    break;
                case SWSTYLEBIT_EXTRA:
                    nId |= COLL_EXTRA_BITS;
                    break;
                case SWSTYLEBIT_HTML:
                    nId |= COLL_HTML_BITS;
                    break;
            }
            pColl->SetPoolFmtId( nId );
            break;
        }
        case SFX_STYLE_FAMILY_FRAME:
        {
            ASSERT(pFrmFmt, "Wo ist das FrmFmt");
            const SfxPoolItem* pAutoUpdate;
            if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
            {
                pFrmFmt->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
            }
            pFmt = pFrmFmt;
        }
        break;

        case SFX_STYLE_FAMILY_PAGE :
            {
                ASSERT(pDesc, "Wo ist der PageDescriptor");

                if( rDoc.FindPageDescByName( pDesc->GetName(), &nPgDscPos ))
                {
                    pNewDsc = new SwPageDesc( *pDesc );
                    // --> OD 2005-05-09 #i48949# - no undo actions for the
                    // copy of the page style
                    ::sw::UndoGuard const ug(rDoc.GetIDocumentUndoRedo());
                    rDoc.CopyPageDesc(*pDesc, *pNewDsc); // #i7983#
                    // <--

                    pFmt = &pNewDsc->GetMaster();
                }
            }
            break;

        case SFX_STYLE_FAMILY_PSEUDO:
            {
                ASSERT(pNumRule, "Wo ist die NumRule");

                if (!pNumRule)
                    break;

                const SfxPoolItem* pItem;
                switch( rSet.GetItemState( SID_ATTR_NUMBERING_RULE, sal_False, &pItem ))
                {
                case SFX_ITEM_SET:
                {
                    SvxNumRule* pSetRule = ((SvxNumBulletItem*)pItem)->GetNumRule();
                    pSetRule->UnLinkGraphics();
                    //SwNumRule aSetRule(rDoc.GetUniqueNumRuleName());
                    SwNumRule aSetRule(*pNumRule);
                    aSetRule.SetSvxRule(*pSetRule, &rDoc);
                    rDoc.ChgNumRuleFmts( aSetRule );
                }
                break;
                case SFX_ITEM_DONTCARE:
                    // NumRule auf default Werte
                    // was sind die default Werte?
                    {
                        // --> OD 2008-02-11 #newlistlevelattrs#
                        SwNumRule aRule( pNumRule->GetName(),
                                         // --> OD 2008-06-06 #i89178#
                                         numfunc::GetDefaultPositionAndSpaceMode() );
                                         // <--
                        // <--
                        rDoc.ChgNumRuleFmts( aRule );
                    }
                    break;
                }
            }
            break;

        default:
            ASSERT(!this, "unbekannte Style-Familie");
    }

    if( pFmt && rSet.Count())
    {
        SfxItemIter aIter( rSet );
        const SfxPoolItem* pItem = aIter.GetCurItem();
        while( sal_True )
        {
            if( IsInvalidItem( pItem ) )            // Clearen
            {
                // --> OD 2008-02-12 #newlistlevelattrs#
                // use method <SwDoc::ResetAttrAtFormat(..)> in order to
                // create an Undo object for the attribute reset.
//                pFmt->ResetAttr( rSet.GetWhichByPos(aIter.GetCurPos()));
                rDoc.ResetAttrAtFormat( rSet.GetWhichByPos(aIter.GetCurPos()),
                                        *pFmt );
            }

            if( aIter.IsAtEnd() )
                break;
            pItem = aIter.NextItem();
        }
        SfxItemSet aSet(rSet);
        aSet.ClearInvalidItems();

        if(SFX_STYLE_FAMILY_FRAME == nFamily)
        {
            //UUUU Need to check for unique item for DrawingLayer items of type NameOrIndex
            // and evtl. correct that item to ensure unique names for that type. This call may
            // modify/correct entries inside of the given SfxItemSet
            rDoc.CheckForUniqueItemForLineFillNameOrIndex(aSet);
        }

        aCoreSet.ClearItem();

        if( pNewDsc )
        {
            ::ItemSetToPageDesc( aSet, *pNewDsc );
            rDoc.ChgPageDesc( nPgDscPos, *pNewDsc );
            pDesc = &const_cast<const SwDoc &>(rDoc).GetPageDesc( nPgDscPos );
            rDoc.PreDelPageDesc(pNewDsc); // #i7983#
            delete pNewDsc;
        }
        else
            rDoc.ChgFmt(*pFmt, aSet);       // alles gesetzten Putten
    }
    else
    {
        aCoreSet.ClearItem();
        if( pNewDsc )           // den muessen wir noch vernichten!!
        {
            rDoc.PreDelPageDesc(pNewDsc); // #i7983#
            delete pNewDsc;
        }
    }

    // --> OD 2008-02-12 #newlistlevelattrs#
    if (rDoc.GetIDocumentUndoRedo().DoesUndo())
    {
        rDoc.GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
    }
    // <--
}

void lcl_SaveStyles( sal_uInt16 nFamily, SvPtrarr& rArr, SwDoc& rDoc )
{
    switch( nFamily )
    {
    case SFX_STYLE_FAMILY_CHAR:
        {
            const SwCharFmts& rTbl = *rDoc.GetCharFmts();
            for( sal_uInt16 n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                rArr.Insert( p, n );
            }
        }
        break;
    case SFX_STYLE_FAMILY_PARA:
        {
            const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
            for( sal_uInt16 n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                rArr.Insert( p, n );
            }
        }
        break;
    case SFX_STYLE_FAMILY_FRAME:
        {
            const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
            for( sal_uInt16 n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                rArr.Insert( p, n );
            }
        }
        break;

    case SFX_STYLE_FAMILY_PAGE:
        {
            for( sal_uInt16 n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
            {
                void* p =
                    (void*)&const_cast<const SwDoc &>(rDoc).GetPageDesc( n );
                rArr.Insert( p, n );
            }
        }
        break;

    case SFX_STYLE_FAMILY_PSEUDO:
        {
            const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
            for( sal_uInt16 n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                rArr.Insert( p, n );
            }
        }
        break;
    }
}

void lcl_DeleteInfoStyles( sal_uInt16 nFamily, SvPtrarr& rArr, SwDoc& rDoc )
{
    sal_uInt16 n, nCnt;
    switch( nFamily )
    {
    case SFX_STYLE_FAMILY_CHAR:
        {
            SvUShorts aDelArr;
            const SwCharFmts& rTbl = *rDoc.GetCharFmts();
            for( n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                if( USHRT_MAX == rArr.GetPos( p ))
                    aDelArr.Insert( n, 0 );
            }
            for( n = 0, nCnt = aDelArr.Count(); n < nCnt; ++n )
                rDoc.DelCharFmt( aDelArr[ n ] );
        }
        break;

    case SFX_STYLE_FAMILY_PARA :
        {
            SvUShorts aDelArr;
            const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
            for( n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                if( USHRT_MAX == rArr.GetPos( p ))
                    aDelArr.Insert( n, 0 );
            }
            for( n = 0, nCnt = aDelArr.Count(); n < nCnt; ++n )
                rDoc.DelTxtFmtColl( aDelArr[ n ] );
        }
        break;

    case SFX_STYLE_FAMILY_FRAME:
        {
            SvPtrarr aDelArr;
            const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
            for( n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                if( USHRT_MAX == rArr.GetPos( p ))
                    aDelArr.Insert( p, 0 );
            }
            for( n = 0, nCnt = aDelArr.Count(); n < nCnt; ++n )
                rDoc.DelFrmFmt( (SwFrmFmt*)aDelArr[ n ] );
        }
        break;

    case SFX_STYLE_FAMILY_PAGE:
        {
            SvUShorts aDelArr;
            for( n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
            {
                void* p =
                    (void*)&const_cast<const SwDoc &>(rDoc).GetPageDesc( n );
                if( USHRT_MAX == rArr.GetPos( p ))
                    aDelArr.Insert( n, 0 );
            }
            for( n = 0, nCnt = aDelArr.Count(); n < nCnt; ++n )
                rDoc.DelPageDesc( aDelArr[ n ] );
        }
        break;


    case SFX_STYLE_FAMILY_PSEUDO:
        {
            SvPtrarr aDelArr;
            const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
            for( n = 0, nCnt = rTbl.Count(); n < nCnt; ++n )
            {
                void* p = (void*)rTbl[ n ];
                if( USHRT_MAX == rArr.GetPos( p ))
                    aDelArr.Insert( p, 0 );
            }
            for( n = 0, nCnt = aDelArr.Count(); n < nCnt; ++n )
                rDoc.DelNumRule( ((SwNumRule*)aDelArr[ n ])->GetName() );
        }
        break;
    }
}

/*--------------------------------------------------------------------
    Beschreibung:   Das Format ermitteln
 --------------------------------------------------------------------*/

sal_Bool SwDocStyleSheet::FillStyleSheet( FillStyleType eFType )
{
    sal_Bool bRet = sal_False;
    sal_uInt16 nPoolId = USHRT_MAX;
    SwFmt* pFmt = 0;

    sal_Bool bCreate = FillPhysical == eFType;
    sal_Bool bDeleteInfo = sal_False;
    sal_Bool bFillOnlyInfo = FillAllInfo == eFType;
    SvPtrarr aDelArr;

    switch(nFamily)
    {
    case SFX_STYLE_FAMILY_CHAR:
        pCharFmt = lcl_FindCharFmt(rDoc, aName, this, bCreate );
        bPhysical = 0 != pCharFmt;
        if( bFillOnlyInfo && !bPhysical )
        {
            bDeleteInfo = sal_True;
            ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
            pCharFmt = lcl_FindCharFmt(rDoc, aName, this, sal_True );
        }

        pFmt = pCharFmt;
        if( !bCreate && !pFmt )
        {
            if( aName == *SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
                                            RES_POOLCOLL_TEXT_BEGIN ] )
                nPoolId = 0;
            else
                nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
        }

        bRet = 0 != pCharFmt || USHRT_MAX != nPoolId;

        if( bDeleteInfo )
            pCharFmt = 0;
        break;

    case SFX_STYLE_FAMILY_PARA:
        {
            pColl = lcl_FindParaFmt(rDoc, aName, this, bCreate);
            bPhysical = 0 != pColl;
            if( bFillOnlyInfo && !bPhysical )
            {
                bDeleteInfo = sal_True;
                ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
                pColl = lcl_FindParaFmt(rDoc, aName, this, sal_True );
            }

            pFmt = pColl;
            if( pColl )
                PresetFollow( pColl->GetNextTxtFmtColl().GetName() );
            else if( !bCreate )
                nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );

            bRet = 0 != pColl || USHRT_MAX != nPoolId;

            if( bDeleteInfo )
                pColl = 0;
        }
        break;

    case SFX_STYLE_FAMILY_FRAME:
        pFrmFmt = lcl_FindFrmFmt(rDoc,  aName, this, bCreate);
        bPhysical = 0 != pFrmFmt;
        if( bFillOnlyInfo && bPhysical )
        {
            bDeleteInfo = sal_True;
            ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
            pFrmFmt = lcl_FindFrmFmt(rDoc, aName, this, sal_True );
        }
        pFmt = pFrmFmt;
        if( !bCreate && !pFmt )
            nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );

        bRet = 0 != pFrmFmt || USHRT_MAX != nPoolId;

        if( bDeleteInfo )
            pFrmFmt = 0;
        break;

    case SFX_STYLE_FAMILY_PAGE:
        pDesc = lcl_FindPageDesc(rDoc, aName, this, bCreate);
        bPhysical = 0 != pDesc;
        if( bFillOnlyInfo && !pDesc )
        {
            bDeleteInfo = sal_True;
            ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
            pDesc = lcl_FindPageDesc( rDoc, aName, this, sal_True );
        }

        if( pDesc )
        {
            nPoolId = pDesc->GetPoolFmtId();
            nHelpId = pDesc->GetPoolHelpId();
            if( pDesc->GetPoolHlpFileId() != UCHAR_MAX )
                aHelpFile = *rDoc.GetDocPattern( pDesc->GetPoolHlpFileId() );
            else
                aHelpFile.Erase();
        }
        else if( !bCreate )
            nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
        SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );

        bRet = 0 != pDesc || USHRT_MAX != nPoolId;
        if( bDeleteInfo )
            pDesc = 0;
        break;

    case SFX_STYLE_FAMILY_PSEUDO:
        pNumRule = lcl_FindNumRule(rDoc, aName, this, bCreate);
        bPhysical = 0 != pNumRule;
        if( bFillOnlyInfo && !pNumRule )
        {
            bDeleteInfo = sal_True;
            ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
            pNumRule = lcl_FindNumRule( rDoc, aName, this, sal_True );
        }

        if( pNumRule )
        {
            nPoolId = pNumRule->GetPoolFmtId();
            nHelpId = pNumRule->GetPoolHelpId();
            if( pNumRule->GetPoolHlpFileId() != UCHAR_MAX )
                aHelpFile = *rDoc.GetDocPattern( pNumRule->GetPoolHlpFileId() );
            else
                aHelpFile.Erase();
        }
        else if( !bCreate )
            nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
        SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );

        bRet = 0 != pNumRule || USHRT_MAX != nPoolId;

        if( bDeleteInfo )
            pNumRule = 0;
        break;
        default:; //prevent warning
    }

    if( SFX_STYLE_FAMILY_CHAR == nFamily ||
        SFX_STYLE_FAMILY_PARA == nFamily ||
        SFX_STYLE_FAMILY_FRAME == nFamily )
    {
        if( pFmt )
            nPoolId = pFmt->GetPoolFmtId();

        sal_uInt16 _nMask = 0;
        if( pFmt == rDoc.GetDfltCharFmt() )
            _nMask |= SFXSTYLEBIT_READONLY;
        else if( USER_FMT & nPoolId )
            _nMask |= SFXSTYLEBIT_USERDEF;

        switch ( COLL_GET_RANGE_BITS & nPoolId )
        {
        case COLL_TEXT_BITS:     _nMask |= SWSTYLEBIT_TEXT;   break;
        case COLL_DOC_BITS :     _nMask |= SWSTYLEBIT_CHAPTER; break;
        case COLL_LISTS_BITS:    _nMask |= SWSTYLEBIT_LIST;   break;
        case COLL_REGISTER_BITS: _nMask |= SWSTYLEBIT_IDX;    break;
        case COLL_EXTRA_BITS:    _nMask |= SWSTYLEBIT_EXTRA;      break;
        case COLL_HTML_BITS:     _nMask |= SWSTYLEBIT_HTML;   break;
        }

        if( pFmt )
        {
            ASSERT( bPhysical, "Format nicht gefunden" );

            nHelpId = pFmt->GetPoolHelpId();
            if( pFmt->GetPoolHlpFileId() != UCHAR_MAX )
                aHelpFile = *rDoc.GetDocPattern( pFmt->GetPoolHlpFileId() );
            else
                aHelpFile.Erase();

            if( RES_CONDTXTFMTCOLL == pFmt->Which() )
                _nMask |= SWSTYLEBIT_CONDCOLL;
        }

        SetMask( _nMask );
    }
    if( bDeleteInfo && bFillOnlyInfo )
        ::lcl_DeleteInfoStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    return bRet;
}

/*--------------------------------------------------------------------
    Beschreibung:   Neues Format in der Core anlegen
 --------------------------------------------------------------------*/


void SwDocStyleSheet::Create()
{
    switch(nFamily)
    {
        case SFX_STYLE_FAMILY_CHAR :
            pCharFmt = lcl_FindCharFmt( rDoc, aName );
            if( !pCharFmt )
                pCharFmt = rDoc.MakeCharFmt(aName,
                                            rDoc.GetDfltCharFmt());
            pCharFmt->SetAuto( sal_False );
            break;

        case SFX_STYLE_FAMILY_PARA :
            pColl = lcl_FindParaFmt( rDoc, aName );
            if( !pColl )
            {
                SwTxtFmtColl *pPar = (*rDoc.GetTxtFmtColls())[0];
                if( nMask & SWSTYLEBIT_CONDCOLL )
                    pColl = rDoc.MakeCondTxtFmtColl( aName, pPar );
                else
                    pColl = rDoc.MakeTxtFmtColl( aName, pPar );
            }
            break;

        case SFX_STYLE_FAMILY_FRAME:
            pFrmFmt = lcl_FindFrmFmt( rDoc, aName );
            if( !pFrmFmt )
                pFrmFmt = rDoc.MakeFrmFmt(aName, rDoc.GetDfltFrmFmt(), sal_False, sal_False);

            break;

        case SFX_STYLE_FAMILY_PAGE :
            pDesc = lcl_FindPageDesc( rDoc, aName );
            if( !pDesc )
            {
                sal_uInt16 nId = rDoc.MakePageDesc(aName);
                pDesc = &const_cast<const SwDoc &>(rDoc).GetPageDesc(nId);
            }
            break;

        case SFX_STYLE_FAMILY_PSEUDO:
            pNumRule = lcl_FindNumRule( rDoc, aName );
            if( !pNumRule )
            {
                //JP 05.02.99: temp Namen erzeugen, damit kein ASSERT kommt
                String sTmpNm( aName );
                if( !aName.Len() )
                    sTmpNm = rDoc.GetUniqueNumRuleName();

                // --> OD 2008-02-11 #newlistlevelattrs#
                SwNumRule* pRule = rDoc.GetNumRuleTbl()[
                    rDoc.MakeNumRule( sTmpNm, 0, sal_False,
                                      // --> OD 2008-06-06 #i89178#
                                      numfunc::GetDefaultPositionAndSpaceMode() ) ];
                                      // <--
                // <--
                pRule->SetAutoRule( sal_False );
                if( !aName.Len() )
                {
                    // --> OD 2008-07-08 #i91400#
                    pRule->SetName( aName, rDoc );
                    // <--
                }
                pNumRule = pRule;
            }
            break;
        default:; //prevent warning
    }
    bPhysical = sal_True;
    aCoreSet.ClearItem();
}

/*--------------------------------------------------------------------
    Beschreibung:   Konkrete Formate rausholen
 --------------------------------------------------------------------*/



SwCharFmt* SwDocStyleSheet::GetCharFmt()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );
    return pCharFmt;
}


SwTxtFmtColl* SwDocStyleSheet::GetCollection()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );
    return pColl;
}


const SwPageDesc* SwDocStyleSheet::GetPageDesc()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );
    return pDesc;
}

const SwNumRule * SwDocStyleSheet::GetNumRule()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );
    return pNumRule;
}

void SwDocStyleSheet::SetNumRule(const SwNumRule& rRule)
{
    DBG_ASSERT(pNumRule, "Wo ist die NumRule");
    rDoc.ChgNumRuleFmts( rRule );
}

// Namen UND Familie aus String re-generieren
// First() und Next() (s.u.) fuegen einen Kennbuchstaben an Pos.1 ein

void SwDocStyleSheet::PresetNameAndFamily(const String& rName)
{
    switch( rName.GetChar(0) )
    {
        case cPARA:     nFamily = SFX_STYLE_FAMILY_PARA; break;
        case cFRAME:    nFamily = SFX_STYLE_FAMILY_FRAME; break;
        case cPAGE:     nFamily = SFX_STYLE_FAMILY_PAGE; break;
        case cNUMRULE:  nFamily = SFX_STYLE_FAMILY_PSEUDO; break;
        default:        nFamily = SFX_STYLE_FAMILY_CHAR; break;
    }
    aName = rName;
    aName.Erase( 0, 1 );
}

/*--------------------------------------------------------------------
    Beschreibung:   Ist das Format physikalisch schon vorhanden
 --------------------------------------------------------------------*/


void SwDocStyleSheet::SetPhysical(sal_Bool bPhys)
{
    bPhysical = bPhys;

    if(!bPhys)
    {
        pCharFmt = 0;
        pColl    = 0;
        pFrmFmt  = 0;
        pDesc    = 0;
    }
}

SwFrmFmt* SwDocStyleSheet::GetFrmFmt()
{
    if(!bPhysical)
        FillStyleSheet( FillPhysical );
    return pFrmFmt;
}


sal_Bool  SwDocStyleSheet::IsUsed() const
{
    if( !bPhysical )
    {
        SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
        pThis->FillStyleSheet( FillOnlyName );
    }

    // immer noch nicht ?
    if( !bPhysical )
        return sal_False;

    const SwModify* pMod;
    switch( nFamily )
    {
    case SFX_STYLE_FAMILY_CHAR : pMod = pCharFmt;   break;
    case SFX_STYLE_FAMILY_PARA : pMod = pColl;      break;
    case SFX_STYLE_FAMILY_FRAME: pMod = pFrmFmt;    break;
    case SFX_STYLE_FAMILY_PAGE : pMod = pDesc;      break;

    case SFX_STYLE_FAMILY_PSEUDO:
            return pNumRule ? rDoc.IsUsed( *pNumRule ) : sal_False;

    default:
        ASSERT(!this, "unbekannte Style-Familie");
        return sal_False;
    }
    return rDoc.IsUsed( *pMod );
}


sal_uLong  SwDocStyleSheet::GetHelpId( String& rFile )
{
static String sTemplateHelpFile = String::CreateFromAscii("swrhlppi.hlp");

    sal_uInt16 nId = 0;
    sal_uInt16 nPoolId = 0;
    unsigned char nFileId = UCHAR_MAX;

    rFile = sTemplateHelpFile;

    const SwFmt* pTmpFmt = 0;
    switch( nFamily )
    {
    case SFX_STYLE_FAMILY_CHAR :
        if( !pCharFmt &&
            0 == (pCharFmt = lcl_FindCharFmt( rDoc, aName, 0, sal_False )) )
        {
            nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
            return USHRT_MAX == nId ? 0 : nId;
        }
        pTmpFmt = pCharFmt;
        break;

    case SFX_STYLE_FAMILY_PARA:
        if( !pColl &&
            0 == ( pColl = lcl_FindParaFmt( rDoc, aName, 0, sal_False )) )
        {
            nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
            return USHRT_MAX == nId ? 0 : nId;
        }
        pTmpFmt = pColl;
        break;

    case SFX_STYLE_FAMILY_FRAME:
        if( !pFrmFmt &&
            0 == ( pFrmFmt = lcl_FindFrmFmt( rDoc, aName, 0, sal_False ) ) )
        {
            nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
            return USHRT_MAX == nId ? 0 : nId;
        }
        pTmpFmt = pFrmFmt;
        break;

    case SFX_STYLE_FAMILY_PAGE:
        if( !pDesc &&
            0 == ( pDesc = lcl_FindPageDesc( rDoc, aName, 0, sal_False ) ) )
        {
            nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
            return USHRT_MAX == nId ? 0 : nId;
        }

        nId = pDesc->GetPoolHelpId();
        nFileId = pDesc->GetPoolHlpFileId();
        nPoolId = pDesc->GetPoolFmtId();
        break;

    case SFX_STYLE_FAMILY_PSEUDO:
        if( !pNumRule &&
            0 == ( pNumRule = lcl_FindNumRule( rDoc, aName, 0, sal_False ) ) )
        {
            nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
            return USHRT_MAX == nId ? 0 : nId;
        }

        nId = pNumRule->GetPoolHelpId();
        nFileId = pNumRule->GetPoolHlpFileId();
        nPoolId = pNumRule->GetPoolFmtId();
        break;

    default:
        ASSERT(!this, "unbekannte Style-Familie");
        return 0;
    }

    if( pTmpFmt )
    {
        nId = pTmpFmt->GetPoolHelpId();
        nFileId = pTmpFmt->GetPoolHlpFileId();
        nPoolId = pTmpFmt->GetPoolFmtId();
    }

    if( UCHAR_MAX != nFileId )
    {
        const String *pTemplate = rDoc.GetDocPattern( nFileId );
        if( pTemplate )
        {
//          const String aHelpPath(MakeHelpPath(*pTemplate));
            rFile = *pTemplate;
        }
    }
    else if( !IsPoolUserFmt( nPoolId ) )
    {
        nId = nPoolId;
    }

    // weil sich der SFX so anstellt mit der HilfeId:
    if( USHRT_MAX == nId )
        nId = 0;        // entsp. keine Hilfe anzeigen

    return nId;
}


void  SwDocStyleSheet::SetHelpId( const String& r, sal_uLong nId )
{
    sal_uInt8 nFileId = static_cast< sal_uInt8 >(rDoc.SetDocPattern( r ));
    sal_uInt16 nHId = static_cast< sal_uInt16 >(nId);     //!! SFX hat eigenmaechtig auf sal_uLong umgestellt!

    SwFmt* pTmpFmt = 0;
    switch( nFamily )
    {
    case SFX_STYLE_FAMILY_CHAR : pTmpFmt = pCharFmt;    break;
    case SFX_STYLE_FAMILY_PARA : pTmpFmt = pColl;       break;
    case SFX_STYLE_FAMILY_FRAME: pTmpFmt = pFrmFmt;     break;
    case SFX_STYLE_FAMILY_PAGE :
        ((SwPageDesc*)pDesc)->SetPoolHelpId( nHId );
        ((SwPageDesc*)pDesc)->SetPoolHlpFileId( nFileId );
        break;

    case SFX_STYLE_FAMILY_PSEUDO:
        ((SwNumRule*)pNumRule)->SetPoolHelpId( nHId );
        ((SwNumRule*)pNumRule)->SetPoolHlpFileId( nFileId );
        break;

    default:
        ASSERT(!this, "unbekannte Style-Familie");
        return ;
    }
    if( pTmpFmt )
    {
        pTmpFmt->SetPoolHelpId( nHId );
        pTmpFmt->SetPoolHlpFileId( nFileId );
    }
}


/*  */

/*--------------------------------------------------------------------
    Beschreibung:   Methoden fuer den DocStyleSheetPool
 --------------------------------------------------------------------*/

SwDocStyleSheetPool::SwDocStyleSheetPool( SwDoc& rDocument, sal_Bool bOrg )
: SfxStyleSheetBasePool( rDocument.GetAttrPool() )
, mxStyleSheet( new SwDocStyleSheet( rDocument, aEmptyStr, *this, SFX_STYLE_FAMILY_CHAR, 0 ) )
, rDoc( rDocument )
{
    bOrganizer = bOrg;
}

 SwDocStyleSheetPool::~SwDocStyleSheetPool()
{
}

void SAL_CALL SwDocStyleSheetPool::acquire(  ) throw ()
{
    comphelper::OWeakTypeObject::acquire();
}

void SAL_CALL SwDocStyleSheetPool::release(  ) throw ()
{
    comphelper::OWeakTypeObject::release();
}

SfxStyleSheetBase&   SwDocStyleSheetPool::Make(
        const String&   rName,
        SfxStyleFamily  eFam,
        sal_uInt16          _nMask,
        sal_uInt16          /*nPos*/ )
{
    mxStyleSheet->PresetName(rName);
    mxStyleSheet->PresetParent(aEmptyStr);
    mxStyleSheet->PresetFollow(aEmptyStr);
    mxStyleSheet->SetMask(_nMask) ;
    mxStyleSheet->SetFamily(eFam);
    mxStyleSheet->SetPhysical(sal_True);
    mxStyleSheet->Create();

    return *mxStyleSheet.get();
}


SfxStyleSheetBase*   SwDocStyleSheetPool::Create( const SfxStyleSheetBase& /*rOrg*/)
{
    ASSERT(!this , "Create im SW-Stylesheet-Pool geht nicht" );
    return NULL;
}


SfxStyleSheetBase*   SwDocStyleSheetPool::Create( const String &,
                                                SfxStyleFamily, sal_uInt16 )
{
    ASSERT( !this, "Create im SW-Stylesheet-Pool geht nicht" );
    return NULL;
}

void  SwDocStyleSheetPool::Replace( SfxStyleSheetBase& rSource,
                                            SfxStyleSheetBase& rTarget )
{
    SfxStyleFamily eFamily( rSource.GetFamily() );
    if( rSource.HasParentSupport())
    {
        const String& rParentName = rSource.GetParent();
        if( 0 != rParentName.Len() )
        {
            SfxStyleSheetBase* pParentOfNew = Find( rParentName, eFamily );
            if( pParentOfNew )
                rTarget.SetParent( rParentName );
        }
    }
    if( rSource.HasFollowSupport())
    {
        const String& rFollowName = rSource.GetFollow();
        if( 0 != rFollowName.Len() )
        {
            SfxStyleSheetBase* pFollowOfNew = Find( rFollowName, eFamily );
            if( pFollowOfNew )
                rTarget.SetFollow( rFollowName );
        }
    }

    SwImplShellAction aTmpSh( rDoc );

    sal_Bool bSwSrcPool = GetAppName() == rSource.GetPool().GetAppName();
    if( SFX_STYLE_FAMILY_PAGE == eFamily && bSwSrcPool )
    {
        // gesondert behandeln!!
        SwPageDesc* pDestDsc =
            (SwPageDesc*)((SwDocStyleSheet&)rTarget).GetPageDesc();
        SwPageDesc* pCpyDsc =
            (SwPageDesc*)((SwDocStyleSheet&)rSource).GetPageDesc();
        rDoc.CopyPageDesc( *pCpyDsc, *pDestDsc );
    }
    else
    {
        const SwFmt *pSourceFmt = 0;
        SwFmt *pTargetFmt = 0;
        sal_uInt16 nPgDscPos = USHRT_MAX;
        switch( eFamily )
        {
        case SFX_STYLE_FAMILY_CHAR :
            if( bSwSrcPool )
                pSourceFmt = ((SwDocStyleSheet&)rSource).GetCharFmt();
            pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCharFmt();
            break;
        case SFX_STYLE_FAMILY_PARA :
            if( bSwSrcPool )
                pSourceFmt = ((SwDocStyleSheet&)rSource).GetCollection();
            pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCollection();
            break;
        case SFX_STYLE_FAMILY_FRAME:
            if( bSwSrcPool )
                pSourceFmt = ((SwDocStyleSheet&)rSource).GetFrmFmt();
            pTargetFmt = ((SwDocStyleSheet&)rTarget).GetFrmFmt();
            break;
        case SFX_STYLE_FAMILY_PAGE:
            if( bSwSrcPool )
                pSourceFmt = &((SwDocStyleSheet&)rSource).GetPageDesc()
                                ->GetMaster();
            {
                SwPageDesc *pDesc = rDoc.FindPageDescByName(
                    ((SwDocStyleSheet&)rTarget).GetPageDesc()->GetName(),
                    &nPgDscPos );

                if( pDesc )
                    pTargetFmt = &pDesc->GetMaster();
            }
            break;
        case SFX_STYLE_FAMILY_PSEUDO:
            // Eine NumRule besteht nur aus einem Item, also muss man
            // hier nichts loeschen.
            break;
        default:; //prevent warning
        }
        if( pTargetFmt )
        {
            if( pSourceFmt )
                pTargetFmt->DelDiffs( *pSourceFmt );
            else if( USHRT_MAX != nPgDscPos )
                pTargetFmt->ResetFmtAttr( RES_PAGEDESC, RES_FRMATR_END-1 );
            else
            {
                // --> OD 2007-01-25 #i73790# - method renamed
                pTargetFmt->ResetAllFmtAttr();
                // <--
            }

            if( USHRT_MAX != nPgDscPos )
                rDoc.ChgPageDesc( nPgDscPos,
                                  const_cast<const SwDoc &>(rDoc).
                                  GetPageDesc(nPgDscPos) );
        }
        ((SwDocStyleSheet&)rTarget).SetItemSet( rSource.GetItemSet() );
    }
}

SfxStyleSheetIteratorPtr SwDocStyleSheetPool::CreateIterator( SfxStyleFamily eFam, sal_uInt16 _nMask )
{
    return SfxStyleSheetIteratorPtr(new SwStyleSheetIterator( this, eFam, _nMask ));
}

void SwDocStyleSheetPool::dispose()
{
    mxStyleSheet.clear();
}

void SwDocStyleSheetPool::Remove( SfxStyleSheetBase* pStyle)
{
    if( !pStyle )
        return;

    sal_Bool bBroadcast = sal_True;
    SwImplShellAction aTmpSh( rDoc );
    const String& rName = pStyle->GetName();
    switch( pStyle->GetFamily() )
    {
    case SFX_STYLE_FAMILY_CHAR:
        {
            SwCharFmt* pFmt = lcl_FindCharFmt(rDoc, rName, 0, sal_False );
            if(pFmt)
                rDoc.DelCharFmt(pFmt);
        }
        break;
    case SFX_STYLE_FAMILY_PARA:
        {
            SwTxtFmtColl* pColl = lcl_FindParaFmt(rDoc, rName, 0, sal_False );
            if(pColl)
                rDoc.DelTxtFmtColl(pColl);
        }
        break;
    case SFX_STYLE_FAMILY_FRAME:
        {
            SwFrmFmt* pFmt = lcl_FindFrmFmt(rDoc, rName, 0, sal_False );
            if(pFmt)
                rDoc.DelFrmFmt(pFmt);
        }
        break;
    case SFX_STYLE_FAMILY_PAGE :
        {
            sal_uInt16 nPos;
            if( rDoc.FindPageDescByName( rName, &nPos ))
                rDoc.DelPageDesc( nPos );
        }
        break;

    case SFX_STYLE_FAMILY_PSEUDO:
        {
            if( !rDoc.DelNumRule( rName ) )
                // Broadcast nur versenden, wenn etwas geloescht wurde
                bBroadcast = sal_False;
        }
        break;

    default:
        ASSERT(!this, "unbekannte Style-Familie");
        bBroadcast = sal_False;
    }

    if( bBroadcast )
        Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_ERASED, *pStyle ) );
}



sal_Bool  SwDocStyleSheetPool::SetParent( SfxStyleFamily eFam,
                                const String &rStyle, const String &rParent )
{
    SwFmt* pFmt = 0, *pParent = 0;
    switch( eFam )
    {
    case SFX_STYLE_FAMILY_CHAR :
        if( 0 != ( pFmt = lcl_FindCharFmt( rDoc, rStyle ) ) && rParent.Len() )
            pParent = lcl_FindCharFmt(rDoc, rParent );
        break;

    case SFX_STYLE_FAMILY_PARA :
        if( 0 != ( pFmt = lcl_FindParaFmt( rDoc, rStyle ) ) && rParent.Len() )
            pParent = lcl_FindParaFmt( rDoc, rParent );
        break;

    case SFX_STYLE_FAMILY_FRAME:
        if( 0 != ( pFmt = lcl_FindFrmFmt( rDoc, rStyle ) ) && rParent.Len() )
            pParent = lcl_FindFrmFmt( rDoc, rParent );
        break;

    case SFX_STYLE_FAMILY_PAGE:
    case SFX_STYLE_FAMILY_PSEUDO:
        break;

    default:
        ASSERT(!this, "unbekannte Style-Familie");
    }

    sal_Bool bRet = sal_False;
    if( pFmt && pFmt->DerivedFrom() &&
        pFmt->DerivedFrom()->GetName() != rParent )
    {
        {
            SwImplShellAction aTmpSh( rDoc );
            bRet = pFmt->SetDerivedFrom( pParent );
        }

        if( bRet )
        {
            // nur fuer das Broadcasting
            mxStyleSheet->PresetName( rStyle );
            mxStyleSheet->PresetParent( rParent );
            if( SFX_STYLE_FAMILY_PARA == eFam )
                mxStyleSheet->PresetFollow( ((SwTxtFmtColl*)pFmt)->
                        GetNextTxtFmtColl().GetName() );
            else
                mxStyleSheet->PresetFollow( aEmptyStr );

            Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
                                            *(mxStyleSheet.get()) ) );
        }
    }

    return bRet;
}

SfxStyleSheetBase* SwDocStyleSheetPool::Find( const String& rName,
                                            SfxStyleFamily eFam, sal_uInt16 n )
{
    sal_uInt16 nSMask = n;
    if( SFX_STYLE_FAMILY_PARA == eFam && rDoc.get(IDocumentSettingAccess::HTML_MODE) )
    {
        // dann sind nur HTML-Vorlagen von Interesse
        if( USHRT_MAX == nSMask )
            nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF | SFXSTYLEBIT_USED;
        else
            nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
                                SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
        if( !nSMask )
            nSMask = SWSTYLEBIT_HTML;
    }

    const sal_Bool bSearchUsed = ( n != SFXSTYLEBIT_ALL &&
                             n & SFXSTYLEBIT_USED ) ? sal_True : sal_False;
    const SwModify* pMod = 0;

    mxStyleSheet->SetPhysical( sal_False );
    mxStyleSheet->PresetName( rName );
    mxStyleSheet->SetFamily( eFam );
    sal_Bool bFnd = mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );

    if( mxStyleSheet->IsPhysical() )
    {
        switch( eFam )
        {
        case SFX_STYLE_FAMILY_CHAR:
            pMod = mxStyleSheet->GetCharFmt();
            break;

        case SFX_STYLE_FAMILY_PARA:
            pMod = mxStyleSheet->GetCollection();
            break;

        case SFX_STYLE_FAMILY_FRAME:
            pMod = mxStyleSheet->GetFrmFmt();
            break;

        case SFX_STYLE_FAMILY_PAGE:
            pMod = mxStyleSheet->GetPageDesc();
            break;

        case SFX_STYLE_FAMILY_PSEUDO:
            {
                const SwNumRule* pRule = mxStyleSheet->GetNumRule();
                if( pRule &&
                    !(bSearchUsed && (bOrganizer || rDoc.IsUsed(*pRule)) ) &&
                    (( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
                            ? !(pRule->GetPoolFmtId() & USER_FMT)
                                // benutzte gesucht und keine gefunden
                            : bSearchUsed ))
                    bFnd = sal_False;
            }
            break;

        default:
            ASSERT(!this, "unbekannte Style-Familie");
        }
    }

    // dann noch die Maske auswerten:
    if( pMod && !(bSearchUsed && (bOrganizer || rDoc.IsUsed(*pMod)) ) )
    {
        const sal_uInt16 nId = SFX_STYLE_FAMILY_PAGE == eFam
                        ? ((SwPageDesc*)pMod)->GetPoolFmtId()
                        : ((SwFmt*)pMod)->GetPoolFmtId();

        if( ( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
            ? !(nId & USER_FMT)
                // benutzte gesucht und keine gefunden
            : bSearchUsed )
            bFnd = sal_False;
    }
    return bFnd ? mxStyleSheet.get() : 0;
}

/*  */

SwStyleSheetIterator::SwStyleSheetIterator( SwDocStyleSheetPool* pBase,
                                SfxStyleFamily eFam, sal_uInt16 n )
    : SfxStyleSheetIterator( pBase, eFam, n ),
    mxIterSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, *pBase, SFX_STYLE_FAMILY_CHAR, 0 ) ),
    mxStyleSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, *pBase, SFX_STYLE_FAMILY_CHAR, 0 ) )
{
    bFirstCalled = sal_False;
    nLastPos = 0;
    StartListening( *pBase );
}

 SwStyleSheetIterator::~SwStyleSheetIterator()
{
    EndListening( mxIterSheet->GetPool() );
}

sal_uInt16  SwStyleSheetIterator::Count()
{
    // Liste richtig fuellen lassen !!
    if( !bFirstCalled )
        First();
    return aLst.Count();
}

SfxStyleSheetBase*  SwStyleSheetIterator::operator[]( sal_uInt16 nIdx )
{
    // gefunden
    if( !bFirstCalled )
        First();
    mxStyleSheet->PresetNameAndFamily( *aLst[ nIdx ] );
    mxStyleSheet->SetPhysical( sal_False );
    mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );

    return mxStyleSheet.get();
}

SfxStyleSheetBase*  SwStyleSheetIterator::First()
{
    // Alte Liste loeschen
    bFirstCalled = sal_True;
    nLastPos = 0;
    aLst.Erase();

    // aktuellen loeschen
    mxIterSheet->Reset();

    SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
    const sal_uInt16 nSrchMask = nMask;
    const sal_Bool bIsSearchUsed = SearchUsed();

    const sal_Bool bOrganizer = ((SwDocStyleSheetPool*)pBasePool)->IsOrganizerMode();

    if( nSearchFamily == SFX_STYLE_FAMILY_CHAR
     || nSearchFamily == SFX_STYLE_FAMILY_ALL )
    {
        const sal_uInt16 nArrLen = rDoc.GetCharFmts()->Count();
        for( sal_uInt16 i = 0; i < nArrLen; i++ )
        {
            SwCharFmt* pFmt = (*rDoc.GetCharFmts())[ i ];
            if( pFmt->IsDefault() && pFmt != rDoc.GetDfltCharFmt() )
                continue;

            const sal_Bool  bUsed = bIsSearchUsed && (bOrganizer || rDoc.IsUsed(*pFmt));
            if( !bUsed )
            {
                // Standard ist keine Benutzervorlage #46181#
                const sal_uInt16 nId = rDoc.GetDfltCharFmt() == pFmt ?
                        sal_uInt16( RES_POOLCHR_INET_NORMAL ):
                                pFmt->GetPoolFmtId();
                if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
                    ? !(nId & USER_FMT)
                        // benutzte gesucht und keine gefunden
                    : bIsSearchUsed )
                continue;

                if( rDoc.get(IDocumentSettingAccess::HTML_MODE) && !(nId & USER_FMT) &&
                    !( RES_POOLCHR_HTML_BEGIN <= nId &&
                          nId < RES_POOLCHR_HTML_END ) &&
                    RES_POOLCHR_INET_NORMAL != nId &&
                    RES_POOLCHR_INET_VISIT != nId &&
                    RES_POOLCHR_FOOTNOTE  != nId &&
                    RES_POOLCHR_ENDNOTE != nId )
                    continue;
            }

            aLst.Append( cCHAR, pFmt == rDoc.GetDfltCharFmt()
                        ? (const String&) *SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
                                                RES_POOLCOLL_TEXT_BEGIN ]
                        : pFmt->GetName() );
        }

        // PoolFormate
        //
        if( nSrchMask == SFXSTYLEBIT_ALL )
        {
            if( !rDoc.get(IDocumentSettingAccess::HTML_MODE) )
                AppendStyleList(SwStyleNameMapper::GetChrFmtUINameArray(),
                                bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
            else
            {
                aLst.Append( cCHAR, *SwStyleNameMapper::GetChrFmtUINameArray()[
                        RES_POOLCHR_INET_NORMAL - RES_POOLCHR_BEGIN ] );
                aLst.Append( cCHAR, *SwStyleNameMapper::GetChrFmtUINameArray()[
                        RES_POOLCHR_INET_VISIT - RES_POOLCHR_BEGIN ] );
                aLst.Append( cCHAR, *SwStyleNameMapper::GetChrFmtUINameArray()[
                        RES_POOLCHR_ENDNOTE - RES_POOLCHR_BEGIN ] );
                aLst.Append( cCHAR, *SwStyleNameMapper::GetChrFmtUINameArray()[
                        RES_POOLCHR_FOOTNOTE - RES_POOLCHR_BEGIN ] );
            }
            AppendStyleList(SwStyleNameMapper::GetHTMLChrFmtUINameArray(),
                                bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
        }
    }

    if( nSearchFamily == SFX_STYLE_FAMILY_PARA ||
        nSearchFamily == SFX_STYLE_FAMILY_ALL )
    {
        sal_uInt16 nSMask = nSrchMask;
        if( rDoc.get(IDocumentSettingAccess::HTML_MODE) )
        {
            // dann sind nur HTML-Vorlagen von Interesse
            if( USHRT_MAX == nSMask )
                nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF |
                            SFXSTYLEBIT_USED;
            else
                nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
                                SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
            if( !nSMask )
                nSMask = SWSTYLEBIT_HTML;
        }

        const sal_uInt16 nArrLen = rDoc.GetTxtFmtColls()->Count();
        for( sal_uInt16 i = 0; i < nArrLen; i++ )
        {
            SwTxtFmtColl* pColl = (*rDoc.GetTxtFmtColls())[ i ];

            if(pColl->IsDefault())
                continue;

            const sal_Bool bUsed = bOrganizer || rDoc.IsUsed(*pColl);
            if( !(bIsSearchUsed && bUsed ))
            {
                const sal_uInt16 nId = pColl->GetPoolFmtId();
                switch ( (nSMask & ~SFXSTYLEBIT_USED) )
                {
                case SFXSTYLEBIT_USERDEF:
                    if(!IsPoolUserFmt(nId)) continue;
                    break;
                case SWSTYLEBIT_TEXT:
                    if((nId & COLL_GET_RANGE_BITS) != COLL_TEXT_BITS) continue;
                    break;
                case SWSTYLEBIT_CHAPTER:
                    if((nId  & COLL_GET_RANGE_BITS) != COLL_DOC_BITS) continue;
                    break;
                case SWSTYLEBIT_LIST:
                    if((nId  & COLL_GET_RANGE_BITS) != COLL_LISTS_BITS) continue;
                    break;
                case SWSTYLEBIT_IDX:
                    if((nId  & COLL_GET_RANGE_BITS) != COLL_REGISTER_BITS) continue;
                    break;
                case SWSTYLEBIT_EXTRA:
                    if((nId  & COLL_GET_RANGE_BITS) != COLL_EXTRA_BITS) continue;
                    break;

                case SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF:
                    if(IsPoolUserFmt(nId))
                        break;
                    // ansonten weiter
                case SWSTYLEBIT_HTML:
                    if( (nId  & COLL_GET_RANGE_BITS) != COLL_HTML_BITS)
                    {
                        // einige wollen wir aber auch in dieser Section sehen
                        sal_Bool bWeiter = sal_True;
                        switch( nId )
                        {
                        case RES_POOLCOLL_SENDADRESS:   //  --> ADDRESS
                        case RES_POOLCOLL_TABLE_HDLN:   //  --> TH
                        case RES_POOLCOLL_TABLE:        //  --> TD
                        case RES_POOLCOLL_TEXT:         //  --> P
                        case RES_POOLCOLL_HEADLINE_BASE://  --> H
                        case RES_POOLCOLL_HEADLINE1:    //  --> H1
                        case RES_POOLCOLL_HEADLINE2:    //  --> H2
                        case RES_POOLCOLL_HEADLINE3:    //  --> H3
                        case RES_POOLCOLL_HEADLINE4:    //  --> H4
                        case RES_POOLCOLL_HEADLINE5:    //  --> H5
                        case RES_POOLCOLL_HEADLINE6:    //  --> H6
                        case RES_POOLCOLL_STANDARD:     //  --> P
                        case RES_POOLCOLL_FOOTNOTE:
                        case RES_POOLCOLL_ENDNOTE:
                            bWeiter = sal_False;
                            break;
                        }
                        if( bWeiter )
                            continue;
                    }
                    break;
                case SWSTYLEBIT_CONDCOLL:
                    if( RES_CONDTXTFMTCOLL != pColl->Which() ) continue;
                    break;
                default:
                    // benutzte gesucht und keine gefunden
                    if( bIsSearchUsed )
                        continue;
                }
            }
            aLst.Append( cPARA, pColl->GetName() );
        }

        const sal_Bool bAll = nSMask == SFXSTYLEBIT_ALL;
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_TEXT )
            AppendStyleList(SwStyleNameMapper::GetTextUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA );
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CHAPTER )
            AppendStyleList(SwStyleNameMapper::GetDocUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_LIST )
            AppendStyleList(SwStyleNameMapper::GetListsUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_IDX )
            AppendStyleList(SwStyleNameMapper::GetRegisterUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_EXTRA )
            AppendStyleList(SwStyleNameMapper::GetExtraUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
        if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CONDCOLL )
        {
            if( !bIsSearchUsed ||
                rDoc.IsPoolTxtCollUsed( RES_POOLCOLL_TEXT ))
                aLst.Append( cPARA, *SwStyleNameMapper::GetTextUINameArray()[
                        RES_POOLCOLL_TEXT - RES_POOLCOLL_TEXT_BEGIN ] );
        }
        if ( bAll ||
            (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_HTML ||
            (nSMask & ~SFXSTYLEBIT_USED) ==
                        (SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF) )
        {
            AppendStyleList(SwStyleNameMapper::GetHTMLUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
            if( !bAll )
            {
                // dann auch die, die wir mappen:
                static sal_uInt16 aPoolIds[] = {
                    RES_POOLCOLL_SENDADRESS,    //  --> ADDRESS
                    RES_POOLCOLL_TABLE_HDLN,    //  --> TH
                    RES_POOLCOLL_TABLE,     //  --> TD
                    RES_POOLCOLL_STANDARD,      //  --> P
                    RES_POOLCOLL_TEXT,          //  --> P
                    RES_POOLCOLL_HEADLINE_BASE, //  --> H
                    RES_POOLCOLL_HEADLINE1, //  --> H1
                    RES_POOLCOLL_HEADLINE2, //  --> H2
                    RES_POOLCOLL_HEADLINE3, //  --> H3
                    RES_POOLCOLL_HEADLINE4, //  --> H4
                    RES_POOLCOLL_HEADLINE5, //  --> H5
                    RES_POOLCOLL_HEADLINE6, //  --> H6
                    RES_POOLCOLL_FOOTNOTE,
                    RES_POOLCOLL_ENDNOTE,
                    0
                    };

                sal_uInt16* pPoolIds = aPoolIds;
                String s;
                while( *pPoolIds )
                {
                    if( !bIsSearchUsed || rDoc.IsPoolTxtCollUsed( *pPoolIds ) )
                        aLst.Append( cPARA,
                            s = SwStyleNameMapper::GetUIName( *pPoolIds, s ));
                    ++pPoolIds;
                }
            }
        }
    }

    if( nSearchFamily == SFX_STYLE_FAMILY_FRAME ||
        nSearchFamily == SFX_STYLE_FAMILY_ALL )
    {
        const sal_uInt16 nArrLen = rDoc.GetFrmFmts()->Count();
        for( sal_uInt16 i = 0; i < nArrLen; i++ )
        {
            SwFrmFmt* pFmt = (*rDoc.GetFrmFmts())[ i ];

            if(pFmt->IsDefault() || pFmt->IsAuto())
            {
                continue;
            }

            const sal_uInt16 nId = pFmt->GetPoolFmtId();
            sal_Bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(*pFmt));
            if( !bUsed )
            {
                if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
                    ? !(nId & USER_FMT)
                    // benutzte gesucht und keine gefunden
                    : bIsSearchUsed )
                {
                    continue;
                }
            }

            aLst.Append( cFRAME, pFmt->GetName() );
        }

        // PoolFormate
        //
        if ( nSrchMask == SFXSTYLEBIT_ALL )
            AppendStyleList(SwStyleNameMapper::GetFrmFmtUINameArray(),
                                    bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, cFRAME);
    }

    if( nSearchFamily == SFX_STYLE_FAMILY_PAGE ||
        nSearchFamily == SFX_STYLE_FAMILY_ALL )
    {
        const sal_uInt16 nCount = rDoc.GetPageDescCnt();
        for(sal_uInt16 i = 0; i < nCount; ++i)
        {
            const SwPageDesc& rDesc =
                const_cast<const SwDoc &>(rDoc).GetPageDesc(i);
            const sal_uInt16 nId = rDesc.GetPoolFmtId();
            sal_Bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rDesc));
            if( !bUsed )
            {
                if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
                    ? !(nId & USER_FMT)
                    // benutzte gesucht und keine gefunden
                    : bIsSearchUsed )
                    continue;
            }

            aLst.Append( cPAGE, rDesc.GetName() );
        }
        if ( nSrchMask == SFXSTYLEBIT_ALL )
            AppendStyleList(SwStyleNameMapper::GetPageDescUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, cPAGE);
    }

    if( nSearchFamily == SFX_STYLE_FAMILY_PSEUDO ||
        nSearchFamily == SFX_STYLE_FAMILY_ALL )
    {
        const SwNumRuleTbl& rNumTbl = rDoc.GetNumRuleTbl();
        for(sal_uInt16 i = 0; i < rNumTbl.Count(); ++i)
        {
            const SwNumRule& rRule = *rNumTbl[ i ];
            if( !rRule.IsAutoRule() )
            {
                sal_Bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rRule) );
                if( !bUsed )
                {
                    if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
                        ? !(rRule.GetPoolFmtId() & USER_FMT)
                        // benutzte gesucht und keine gefunden
                        : bIsSearchUsed )
                        continue;
                }

                aLst.Append( cNUMRULE, rRule.GetName() );
            }
        }
        if ( nSrchMask == SFXSTYLEBIT_ALL )
            AppendStyleList(SwStyleNameMapper::GetNumRuleUINameArray(),
                            bIsSearchUsed, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, cNUMRULE);
    }

    if(aLst.Count() > 0)
    {
        nLastPos = USHRT_MAX;
        return Next();
    }
    return 0;
}

SfxStyleSheetBase*  SwStyleSheetIterator::Next()
{
    nLastPos++;
    if(aLst.Count() > 0 && nLastPos < aLst.Count())
    {
        mxIterSheet->PresetNameAndFamily(*aLst[nLastPos]);
        mxIterSheet->SetPhysical( sal_False );
        mxIterSheet->SetMask( nMask );
        if(mxIterSheet->pSet)
        {
            mxIterSheet->pSet->ClearItem(0);
            mxIterSheet->pSet= 0;
        }
        return mxIterSheet.get();
    }
    return 0;
}

SfxStyleSheetBase*  SwStyleSheetIterator::Find( const UniString& rName )
{
    // suchen
    if( !bFirstCalled )
        First();

    nLastPos = lcl_FindName( aLst, nSearchFamily, rName );
    if( USHRT_MAX != nLastPos )
    {
        // gefunden
        mxStyleSheet->PresetNameAndFamily(*aLst[nLastPos]);
        // neuer Name gesetzt, also bestimme seine Daten
        mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
        if( !mxStyleSheet->IsPhysical() )
            mxStyleSheet->SetPhysical( sal_False );

        return mxStyleSheet.get();
    }
    return 0;
}

void SwStyleSheetIterator::AppendStyleList(const SvStringsDtor& rList,
                                            sal_Bool    bTestUsed,
                                            sal_uInt16 nSection, char cType )
{
    if( bTestUsed )
    {
        SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
        for ( sal_uInt16 i=0; i < rList.Count(); ++i )
        {
            sal_Bool bUsed = sal_False;
            sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(*rList[i], (SwGetPoolIdFromName)nSection);
            switch ( nSection )
            {
                case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
                        bUsed = rDoc.IsPoolTxtCollUsed( nId );
                        break;
                case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
                        bUsed = rDoc.IsPoolFmtUsed( nId );
                        break;
                case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
                        bUsed = rDoc.IsPoolFmtUsed( nId );
                case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
                        bUsed = rDoc.IsPoolPageDescUsed( nId );
                        break;
                default:
                    ASSERT( !this, "unknown PoolFmt-Id" );
            }
            if ( bUsed )
                aLst.Append( cType, *rList[i] );
        }
    }
    else
        for ( sal_uInt16 i=0; i < rList.Count(); ++i )
            aLst.Append( cType, *rList[i] );
}

void  SwStyleSheetIterator::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
    // suchen und aus der Anzeige-Liste entfernen !!
    if( rHint.ISA( SfxStyleSheetHint ) &&
        SFX_STYLESHEET_ERASED == ((SfxStyleSheetHint&) rHint).GetHint() )
    {
        SfxStyleSheetBase* pStyle = ((SfxStyleSheetHint&)rHint).GetStyleSheet();

        if (pStyle)
        {
            sal_uInt16 nTmpPos = lcl_FindName( aLst, pStyle->GetFamily(),
                                           pStyle->GetName() );
            if( nTmpPos < aLst.Count() )
                aLst.DeleteAndDestroy( nTmpPos );
        }
    }
}