LCOV - code coverage report
Current view: top level - libreoffice/sw/source/ui/app - docstyle.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 756 1407 53.7 %
Date: 2012-12-27 Functions: 53 73 72.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <svl/smplhint.hxx>
      22             : #include <hintids.hxx>
      23             : #include <svl/itemiter.hxx>
      24             : #include <svl/eitem.hxx>
      25             : #include <unotools/syslocale.hxx>
      26             : #include <editeng/boxitem.hxx>
      27             : #include <editeng/numitem.hxx>
      28             : #include <editeng/lrspitem.hxx>
      29             : #include <fmtcol.hxx>
      30             : #include <uitool.hxx>
      31             : #include <swmodule.hxx>
      32             : #include <wrtsh.hxx>
      33             : #include <docsh.hxx>
      34             : #include <frmfmt.hxx>
      35             : #include <charfmt.hxx>
      36             : #include <poolfmt.hxx>
      37             : #include <pagedesc.hxx>
      38             : #include <docstyle.hxx>
      39             : #include <docary.hxx>
      40             : #include <ccoll.hxx>
      41             : #include <doc.hxx>
      42             : #include <IDocumentUndoRedo.hxx>
      43             : #include <cmdid.h>
      44             : #include <swstyle.h>
      45             : #include <app.hrc>
      46             : #include <paratr.hxx>
      47             : #include <SwStyleNameMapper.hxx>
      48             : #include <svl/cjkoptions.hxx>
      49             : #include <comphelper/processfactory.hxx>
      50             : #include <unotools/localedatawrapper.hxx>
      51             : #include <unotools/intlwrapper.hxx>
      52             : #include <numrule.hxx>
      53             : #include <fmthdft.hxx>
      54             : #include <svx/svxids.hrc>
      55             : #include <SwRewriter.hxx>
      56             : 
      57             : // The Format names in the list of all names have the
      58             : // following family as their first character:
      59             : 
      60             : #define cCHAR       (sal_Unicode)'c'
      61             : #define cPARA       (sal_Unicode)'p'
      62             : #define cFRAME      (sal_Unicode)'f'
      63             : #define cPAGE       (sal_Unicode)'g'
      64             : #define cNUMRULE    (sal_Unicode)'n'
      65             : 
      66             : // At the names' publication, this character is removed again and the
      67             : // family is newly generated.
      68             : 
      69             : // In addition now there is the Bit bPhysical. In case this Bit is
      70             : // TRUE, the Pool-Formatnames are not being submitted.
      71             : 
      72             : class SwImplShellAction
      73             : {
      74             :     SwWrtShell* pSh;
      75             :     CurrShell* pCurrSh;
      76             : public:
      77             :     SwImplShellAction( SwDoc& rDoc );
      78             :     ~SwImplShellAction();
      79             : 
      80             :     SwWrtShell* GetSh() { return pSh; }
      81             : };
      82             : 
      83        3300 : SwImplShellAction::SwImplShellAction( SwDoc& rDoc )
      84        3300 :     : pCurrSh( 0 )
      85             : {
      86        3300 :     if( rDoc.GetDocShell() )
      87        3300 :         pSh = rDoc.GetDocShell()->GetWrtShell();
      88             :     else
      89           0 :         pSh = 0;
      90             : 
      91        3300 :     if( pSh )
      92             :     {
      93           1 :         pCurrSh = new CurrShell( pSh );
      94           1 :         pSh->StartAllAction();
      95             :     }
      96        3300 : }
      97             : 
      98        3300 : SwImplShellAction::~SwImplShellAction()
      99             : {
     100        3300 :     if( pCurrSh )
     101             :     {
     102           1 :         pSh->EndAllAction();
     103           1 :         delete pCurrSh;
     104             :     }
     105        3300 : }
     106             : 
     107             : /*--------------------------------------------------------------------
     108             :     Description:    find/create SwCharFormate
     109             :                     possibly fill Style
     110             :  --------------------------------------------------------------------*/
     111             : 
     112        3191 : static SwCharFmt* lcl_FindCharFmt( SwDoc& rDoc,
     113             :                             const String& rName,
     114             :                             SwDocStyleSheet* pStyle = 0,
     115             :                             sal_Bool bCreate = sal_True )
     116             : {
     117        3191 :     SwCharFmt*  pFmt = 0;
     118        3191 :     if( rName.Len() )
     119             :     {
     120        3191 :         pFmt = rDoc.FindCharFmtByName( rName );
     121        4721 :         if( !pFmt && rName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
     122        1530 :                                                 RES_POOLCOLL_TEXT_BEGIN ] )
     123             :         {
     124             :             // Standard-Character template
     125          25 :             pFmt = (SwCharFmt*)rDoc.GetDfltCharFmt();
     126             :         }
     127             : 
     128        3191 :         if( !pFmt && bCreate )
     129             :         {   // explore Pool
     130         218 :             const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
     131         218 :             if(nId != USHRT_MAX)
     132          21 :                 pFmt = rDoc.GetCharFmtFromPool(nId);
     133             :         }
     134             :     }
     135        3191 :     if(pStyle)
     136             :     {
     137        2768 :         if(pFmt)
     138             :         {
     139        1481 :             pStyle->SetPhysical(sal_True);
     140        1481 :             SwFmt* p = pFmt->DerivedFrom();
     141        1481 :             if( p && !p->IsDefault() )
     142         938 :                 pStyle->PresetParent( p->GetName() );
     143             :             else
     144         543 :                 pStyle->PresetParent( aEmptyStr );
     145             :         }
     146             :         else
     147        1287 :             pStyle->SetPhysical(sal_False);
     148             :     }
     149        3191 :     return pFmt;
     150             : }
     151             : 
     152             : 
     153             : /*--------------------------------------------------------------------
     154             :     Description:    find/create ParaFormats
     155             :                     fill Style
     156             :  --------------------------------------------------------------------*/
     157             : 
     158        9548 : static SwTxtFmtColl* lcl_FindParaFmt(  SwDoc& rDoc,
     159             :                                 const String& rName,
     160             :                                 SwDocStyleSheet* pStyle = 0,
     161             :                                 sal_Bool bCreate = sal_True )
     162             : {
     163        9548 :     SwTxtFmtColl*   pColl = 0;
     164             : 
     165        9548 :     if( rName.Len() )
     166             :     {
     167        9548 :         pColl = rDoc.FindTxtFmtCollByName( rName );
     168        9548 :         if( !pColl && bCreate )
     169             :         {   // explore Pool
     170         271 :             const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
     171         271 :             if(nId != USHRT_MAX)
     172         174 :                 pColl = rDoc.GetTxtCollFromPool(nId);
     173             :         }
     174             :     }
     175             : 
     176        9548 :     if(pStyle)
     177             :     {
     178        9132 :         if(pColl)
     179             :         {
     180        6889 :             pStyle->SetPhysical(sal_True);
     181        6889 :             if( pColl->DerivedFrom() && !pColl->DerivedFrom()->IsDefault() )
     182        4102 :                 pStyle->PresetParent( pColl->DerivedFrom()->GetName() );
     183             :             else
     184        2787 :                 pStyle->PresetParent( aEmptyStr );
     185             : 
     186        6889 :             SwTxtFmtColl& rNext = pColl->GetNextTxtFmtColl();
     187        6889 :             pStyle->PresetFollow(rNext.GetName());
     188             :         }
     189             :         else
     190        2243 :             pStyle->SetPhysical(sal_False);
     191             :     }
     192        9548 :     return pColl;
     193             : }
     194             : 
     195             : 
     196             : /*--------------------------------------------------------------------
     197             :     Description:    Border formats
     198             :  --------------------------------------------------------------------*/
     199             : 
     200             : 
     201         300 : static SwFrmFmt* lcl_FindFrmFmt(   SwDoc& rDoc,
     202             :                             const String& rName,
     203             :                             SwDocStyleSheet* pStyle = 0,
     204             :                             sal_Bool bCreate = sal_True )
     205             : {
     206         300 :     SwFrmFmt* pFmt = 0;
     207         300 :     if( rName.Len() )
     208             :     {
     209         300 :         pFmt = rDoc.FindFrmFmtByName( rName );
     210         300 :         if( !pFmt && bCreate )
     211             :         {   // explore Pool
     212           5 :             const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT);
     213           5 :             if(nId != USHRT_MAX)
     214           5 :                 pFmt = rDoc.GetFrmFmtFromPool(nId);
     215             :         }
     216             :     }
     217             : 
     218         300 :     if(pStyle)
     219             :     {
     220         300 :         if(pFmt)
     221             :         {
     222          58 :             pStyle->SetPhysical(sal_True);
     223          58 :             if( pFmt->DerivedFrom() && !pFmt->DerivedFrom()->IsDefault() )
     224           0 :                 pStyle->PresetParent( pFmt->DerivedFrom()->GetName() );
     225             :             else
     226          58 :                 pStyle->PresetParent( aEmptyStr );
     227             :         }
     228             :         else
     229         242 :             pStyle->SetPhysical(sal_False);
     230             :     }
     231         300 :     return pFmt;
     232             : }
     233             : 
     234             : /*--------------------------------------------------------------------
     235             :     Description:    Page descriptors
     236             :  --------------------------------------------------------------------*/
     237             : 
     238             : 
     239        2797 : static const SwPageDesc* lcl_FindPageDesc( SwDoc&  rDoc,
     240             :                                     const String&    rName,
     241             :                                     SwDocStyleSheet* pStyle = 0,
     242             :                                     sal_Bool bCreate = sal_True )
     243             : {
     244        2797 :     const SwPageDesc* pDesc = 0;
     245             : 
     246        2797 :     if( rName.Len() )
     247             :     {
     248        2797 :         pDesc = rDoc.FindPageDescByName( rName );
     249        2797 :         if( !pDesc && bCreate )
     250             :         {
     251          39 :             sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC);
     252          39 :             if(nId != USHRT_MAX)
     253          14 :                 pDesc = rDoc.GetPageDescFromPool(nId);
     254             :         }
     255             :     }
     256             : 
     257        2797 :     if(pStyle)
     258             :     {
     259        2770 :         if(pDesc)
     260             :         {
     261        2241 :             pStyle->SetPhysical(sal_True);
     262        2241 :             if(pDesc->GetFollow())
     263        2241 :                 pStyle->PresetFollow(pDesc->GetFollow()->GetName());
     264             :             else
     265           0 :                 pStyle->PresetParent( aEmptyStr );
     266             :         }
     267             :         else
     268         529 :             pStyle->SetPhysical(sal_False);
     269             :     }
     270        2797 :     return pDesc;
     271             : }
     272             : 
     273         526 : static const SwNumRule* lcl_FindNumRule(   SwDoc&  rDoc,
     274             :                                     const String&    rName,
     275             :                                     SwDocStyleSheet* pStyle = 0,
     276             :                                     sal_Bool bCreate = sal_True )
     277             : {
     278         526 :     const SwNumRule* pRule = 0;
     279             : 
     280         526 :     if( rName.Len() )
     281             :     {
     282         526 :         pRule = rDoc.FindNumRulePtr( rName );
     283         526 :         if( !pRule && bCreate )
     284             :         {
     285          72 :             sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE);
     286          72 :             if(nId != USHRT_MAX)
     287           2 :                 pRule = rDoc.GetNumRuleFromPool(nId);
     288             :         }
     289             :     }
     290             : 
     291         526 :     if(pStyle)
     292             :     {
     293         456 :         if(pRule)
     294             :         {
     295         242 :             pStyle->SetPhysical(sal_True);
     296         242 :             pStyle->PresetParent( aEmptyStr );
     297             :         }
     298             :         else
     299         214 :             pStyle->SetPhysical(sal_False);
     300             :     }
     301         526 :     return pRule;
     302             : }
     303             : 
     304             : 
     305           0 : static sal_uInt16 lcl_FindName(const SwPoolFmtList& rLst, SfxStyleFamily eFam,
     306             :     const rtl::OUString& rName)
     307             : {
     308           0 :     if(!rLst.empty())
     309             :     {
     310           0 :         String sSrch = rtl::OUString(' ');
     311           0 :         switch( eFam )
     312             :         {
     313           0 :         case SFX_STYLE_FAMILY_CHAR:  sSrch = cCHAR;     break;
     314           0 :         case SFX_STYLE_FAMILY_PARA:  sSrch = cPARA;     break;
     315           0 :         case SFX_STYLE_FAMILY_FRAME: sSrch = cFRAME;    break;
     316           0 :         case SFX_STYLE_FAMILY_PAGE:  sSrch = cPAGE;     break;
     317           0 :         case SFX_STYLE_FAMILY_PSEUDO: sSrch = cNUMRULE; break;
     318             :         default:; //prevent warning
     319             :         }
     320           0 :         sSrch += rName;
     321           0 :         for(size_t i = 0; i < rLst.size(); ++i)
     322           0 :             if(rLst[i] == sSrch)
     323           0 :                 return i;
     324             :     }
     325           0 :     return USHRT_MAX;
     326             : }
     327             : 
     328           0 : sal_Bool FindPhyStyle( SwDoc& rDoc, const String& rName, SfxStyleFamily eFam )
     329             : {
     330           0 :     switch( eFam )
     331             :     {
     332             :     case SFX_STYLE_FAMILY_CHAR :
     333           0 :         return 0 != lcl_FindCharFmt( rDoc, rName, 0, sal_False );
     334             :     case SFX_STYLE_FAMILY_PARA :
     335           0 :         return 0 != lcl_FindParaFmt( rDoc, rName, 0, sal_False );
     336             :     case SFX_STYLE_FAMILY_FRAME:
     337           0 :         return 0 != lcl_FindFrmFmt( rDoc, rName, 0, sal_False );
     338             :     case SFX_STYLE_FAMILY_PAGE :
     339           0 :         return 0 != lcl_FindPageDesc( rDoc, rName, 0, sal_False );
     340             :     case SFX_STYLE_FAMILY_PSEUDO:
     341           0 :         return 0 != lcl_FindNumRule( rDoc, rName, 0, sal_False );
     342             :     default:; //prevent warning
     343             :     }
     344           0 :     return sal_False;
     345             : }
     346             : 
     347             : 
     348             : /*--------------------------------------------------------------------
     349             :     Description:    Add Strings to the list of templates
     350             :  --------------------------------------------------------------------*/
     351             : 
     352             : 
     353       23271 : void SwPoolFmtList::Append( char cChar, const String& rStr )
     354             : {
     355       23271 :     String aStr = rtl::OUString(cChar);
     356       23271 :     aStr += rStr;
     357     1282760 :     for(std::vector<String>::const_iterator i = begin(); i != end(); ++i)
     358     1261011 :         if(*i == aStr)
     359       23271 :             return;
     360       21749 :     push_back(aStr);
     361             : }
     362             : 
     363             : /*--------------------------------------------------------------------
     364             :     Description:    Erase the list completely
     365             :  --------------------------------------------------------------------*/
     366             : 
     367             : 
     368         262 : void SwPoolFmtList::Erase()
     369             : {
     370         262 :     clear();
     371         262 : }
     372             : 
     373             : /*--------------------------------------------------------------------
     374             :     Description:  UI-sided implementation of StyleSheets
     375             :                   uses the Core-Engine
     376             :  --------------------------------------------------------------------*/
     377             : 
     378         453 : SwDocStyleSheet::SwDocStyleSheet(   SwDoc&          rDocument,
     379             :                                     const String&           rName,
     380             :                                     SwDocStyleSheetPool*    _rPool,
     381             :                                     SfxStyleFamily          eFam,
     382             :                                     sal_uInt16                  _nMask) :
     383             : 
     384             :     SfxStyleSheetBase( rName, _rPool, eFam, _nMask ),
     385             :     pCharFmt(0),
     386             :     pColl(0),
     387             :     pFrmFmt(0),
     388             :     pDesc(0),
     389             :     pNumRule(0),
     390             : 
     391             :     rDoc(rDocument),
     392         453 :     aCoreSet(GetPool().GetPool(),
     393             :             RES_CHRATR_BEGIN,       RES_CHRATR_END - 1,
     394             :             RES_PARATR_BEGIN,       RES_PARATR_END - 1,
     395             :             RES_PARATR_LIST_BEGIN,  RES_PARATR_LIST_END - 1,
     396             :             RES_FRMATR_BEGIN,       RES_FRMATR_END - 1,
     397             :             RES_UNKNOWNATR_BEGIN,   RES_UNKNOWNATR_END-1,
     398             :             SID_ATTR_PAGE,          SID_ATTR_PAGE_EXT1,
     399             :             SID_ATTR_PAGE_HEADERSET,SID_ATTR_PAGE_FOOTERSET,
     400             :             SID_ATTR_BORDER_INNER,  SID_ATTR_BORDER_INNER,
     401             :             FN_PARAM_FTN_INFO,      FN_PARAM_FTN_INFO,
     402             :             SID_ATTR_PARA_MODEL,    SID_ATTR_PARA_MODEL,
     403             :             SID_ATTR_PARA_PAGENUM, SID_ATTR_PARA_PAGENUM,
     404             :             SID_SWREGISTER_MODE,    SID_SWREGISTER_MODE,
     405             :             SID_SWREGISTER_COLLECTION, SID_SWREGISTER_COLLECTION,
     406             :             FN_COND_COLL,           FN_COND_COLL,
     407             :             SID_ATTR_AUTO_STYLE_UPDATE, SID_ATTR_AUTO_STYLE_UPDATE,
     408             :             SID_ATTR_NUMBERING_RULE,    SID_ATTR_NUMBERING_RULE,
     409             :             SID_PARA_BACKGRND_DESTINATION,  SID_ATTR_BRUSH_CHAR,
     410             :             SID_ATTR_NUMBERING_RULE,    SID_ATTR_NUMBERING_RULE,
     411             :             0),
     412         906 :     bPhysical(sal_False)
     413             : {
     414         453 :     nHelpId = UCHAR_MAX;
     415         453 : }
     416             : 
     417             : 
     418        5287 : SwDocStyleSheet::SwDocStyleSheet( const SwDocStyleSheet& rOrg) :
     419             :     SfxStyleSheetBase(rOrg),
     420             :     pCharFmt(rOrg.pCharFmt),
     421             :     pColl(rOrg.pColl),
     422             :     pFrmFmt(rOrg.pFrmFmt),
     423             :     pDesc(rOrg.pDesc),
     424             :     pNumRule(rOrg.pNumRule),
     425             :     rDoc(rOrg.rDoc),
     426             :     aCoreSet(rOrg.aCoreSet),
     427        5287 :     bPhysical(rOrg.bPhysical)
     428             : {
     429        5287 : }
     430             : 
     431             : 
     432       11102 :  SwDocStyleSheet::~SwDocStyleSheet()
     433             : {
     434       11102 : }
     435             : 
     436             : /*--------------------------------------------------------------------
     437             :     Description:    Reset
     438             :  --------------------------------------------------------------------*/
     439             : 
     440             : 
     441         262 : void  SwDocStyleSheet::Reset()
     442             : {
     443         262 :     aName.Erase();
     444         262 :     aFollow.Erase();
     445         262 :     aParent.Erase();
     446         262 :     SetPhysical(sal_False);
     447         262 : }
     448             : 
     449             : /*--------------------------------------------------------------------
     450             :     Description:    virtual methods
     451             :  --------------------------------------------------------------------*/
     452             : 
     453         219 : void SwDocStyleSheet::SetHidden( sal_Bool bValue )
     454             : {
     455         219 :     bool bChg = false;
     456         219 :     if(!bPhysical)
     457           0 :         FillStyleSheet( FillPhysical );
     458             : 
     459         219 :     SwFmt* pFmt = 0;
     460         219 :     switch(nFamily)
     461             :     {
     462             :         case SFX_STYLE_FAMILY_CHAR:
     463          29 :             pFmt = rDoc.FindCharFmtByName( aName );
     464          29 :             if ( pFmt )
     465             :             {
     466          29 :                 pFmt->SetHidden( bValue );
     467          29 :                 bChg = true;
     468             :             }
     469          29 :             break;
     470             : 
     471             :         case SFX_STYLE_FAMILY_PARA:
     472         151 :             pFmt = rDoc.FindTxtFmtCollByName( aName );
     473         151 :             if ( pFmt )
     474             :             {
     475         151 :                 pFmt->SetHidden( bValue );
     476         151 :                 bChg = true;
     477             :             }
     478         151 :             break;
     479             : 
     480             :         case SFX_STYLE_FAMILY_FRAME:
     481           3 :             pFmt = rDoc.FindFrmFmtByName( aName );
     482           3 :             if ( pFmt )
     483             :             {
     484           3 :                 pFmt->SetHidden( bValue );
     485           3 :                 bChg = true;
     486             :             }
     487           3 :             break;
     488             : 
     489             :         case SFX_STYLE_FAMILY_PAGE:
     490             :             {
     491          28 :                 SwPageDesc* pPgDesc = rDoc.FindPageDescByName( aName );
     492          28 :                 if ( pPgDesc )
     493             :                 {
     494          28 :                     pPgDesc->SetHidden( bValue );
     495          28 :                     bChg = true;
     496             :                 }
     497             :             }
     498          28 :             break;
     499             : 
     500             :         case SFX_STYLE_FAMILY_PSEUDO:
     501             :             {
     502           8 :                 SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
     503           8 :                 if ( pRule )
     504             :                 {
     505           8 :                     pRule->SetHidden( bValue );
     506           8 :                     bChg = true;
     507             :                 }
     508             :             }
     509             :         default:;
     510             :     }
     511             : 
     512         219 :     if( bChg )
     513             :     {
     514         219 :         pPool->First();  // internal list has to be updated
     515         219 :         pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED, *this ) );
     516         219 :         SwEditShell* pSh = rDoc.GetEditShell();
     517         219 :         if( pSh )
     518           0 :             pSh->CallChgLnk();
     519             :     }
     520         219 : }
     521             : 
     522          26 : sal_Bool SwDocStyleSheet::IsHidden( ) const
     523             : {
     524          26 :     sal_Bool bRet = sal_False;
     525             : 
     526          26 :     SwFmt* pFmt = 0;
     527          26 :     switch(nFamily)
     528             :     {
     529             :         case SFX_STYLE_FAMILY_CHAR:
     530           5 :             pFmt = rDoc.FindCharFmtByName( aName );
     531           5 :             bRet = pFmt && pFmt->IsHidden( );
     532           5 :             break;
     533             : 
     534             :         case SFX_STYLE_FAMILY_PARA:
     535          17 :             pFmt = rDoc.FindTxtFmtCollByName( aName );
     536          17 :             bRet = pFmt && pFmt->IsHidden( );
     537          17 :             break;
     538             : 
     539             :         case SFX_STYLE_FAMILY_FRAME:
     540           0 :             pFmt = rDoc.FindFrmFmtByName( aName );
     541           0 :             bRet = pFmt && pFmt->IsHidden( );
     542           0 :             break;
     543             : 
     544             :         case SFX_STYLE_FAMILY_PAGE:
     545             :             {
     546           4 :                 SwPageDesc* pPgDesc = rDoc.FindPageDescByName( aName );
     547           4 :                 bRet = pPgDesc && pPgDesc->IsHidden( );
     548             :             }
     549           4 :             break;
     550             :         case SFX_STYLE_FAMILY_PSEUDO:
     551             :             {
     552           0 :                 SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
     553           0 :                 bRet = pRule && pRule->IsHidden( );
     554             :             }
     555             :         default:;
     556             :     }
     557             : 
     558          26 :     return bRet;
     559             : }
     560             : 
     561        1005 : const String&  SwDocStyleSheet::GetParent() const
     562             : {
     563        1005 :     if( !bPhysical )
     564             :     {
     565             :         // check if it's already in document
     566           0 :         SwFmt* pFmt = 0;
     567             :         SwGetPoolIdFromName eGetType;
     568           0 :         switch(nFamily)
     569             :         {
     570             :         case SFX_STYLE_FAMILY_CHAR:
     571           0 :             pFmt = rDoc.FindCharFmtByName( aName );
     572           0 :             eGetType = nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
     573           0 :             break;
     574             : 
     575             :         case SFX_STYLE_FAMILY_PARA:
     576           0 :             pFmt = rDoc.FindTxtFmtCollByName( aName );
     577           0 :             eGetType = nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL;
     578           0 :             break;
     579             : 
     580             :         case SFX_STYLE_FAMILY_FRAME:
     581           0 :             pFmt = rDoc.FindFrmFmtByName( aName );
     582           0 :             eGetType = nsSwGetPoolIdFromName::GET_POOLID_FRMFMT;
     583           0 :             break;
     584             : 
     585             :         case SFX_STYLE_FAMILY_PAGE:
     586             :         case SFX_STYLE_FAMILY_PSEUDO:
     587             :         default:
     588           0 :             return aEmptyStr;       // there's no parent
     589             :         }
     590             : 
     591           0 :         String sTmp;
     592           0 :         if( !pFmt )         // not yet there, so default Parent
     593             :         {
     594           0 :             sal_uInt16 i = SwStyleNameMapper::GetPoolIdFromUIName( aName, eGetType );
     595           0 :             i = ::GetPoolParent( i );
     596           0 :             if( i && USHRT_MAX != i )
     597           0 :                 SwStyleNameMapper::FillUIName( i, sTmp );
     598             :         }
     599             :         else
     600             :         {
     601           0 :             SwFmt* p = pFmt->DerivedFrom();
     602           0 :             if( p && !p->IsDefault() )
     603           0 :                 sTmp = p->GetName();
     604             :         }
     605           0 :         SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
     606           0 :         pThis->aParent = sTmp;
     607             :     }
     608        1005 :     return aParent;
     609             : }
     610             : 
     611             : /*--------------------------------------------------------------------
     612             :    Description:     Follower
     613             :  --------------------------------------------------------------------*/
     614             : 
     615             : 
     616         200 : const String&  SwDocStyleSheet::GetFollow() const
     617             : {
     618         200 :     if( !bPhysical )
     619             :     {
     620           0 :         SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
     621           0 :         pThis->FillStyleSheet( FillAllInfo );
     622             :     }
     623         200 :     return aFollow;
     624             : }
     625             : 
     626             : /*--------------------------------------------------------------------
     627             :     Description:    What Linkage is possible
     628             :  --------------------------------------------------------------------*/
     629             : 
     630             : 
     631           0 : bool  SwDocStyleSheet::HasFollowSupport() const
     632             : {
     633           0 :     switch(nFamily)
     634             :     {
     635             :         case SFX_STYLE_FAMILY_PARA :
     636           0 :         case SFX_STYLE_FAMILY_PAGE : return true;
     637             :         case SFX_STYLE_FAMILY_FRAME:
     638             :         case SFX_STYLE_FAMILY_CHAR :
     639           0 :         case SFX_STYLE_FAMILY_PSEUDO: return false;
     640             :         default:
     641             :             OSL_ENSURE(!this, "unknown style family");
     642             :     }
     643           0 :     return false;
     644             : }
     645             : 
     646             : /*--------------------------------------------------------------------
     647             :     Description:    Parent ?
     648             :  --------------------------------------------------------------------*/
     649             : 
     650             : 
     651           0 : bool  SwDocStyleSheet::HasParentSupport() const
     652             : {
     653           0 :     bool bRet = false;
     654           0 :     switch(nFamily)
     655             :     {
     656             :         case SFX_STYLE_FAMILY_CHAR :
     657             :         case SFX_STYLE_FAMILY_PARA :
     658           0 :         case SFX_STYLE_FAMILY_FRAME: bRet = true;
     659             :         default:; //prevent warning
     660             :     }
     661           0 :     return bRet;
     662             : }
     663             : 
     664             : 
     665           0 : bool  SwDocStyleSheet::HasClearParentSupport() const
     666             : {
     667           0 :     bool bRet = false;
     668           0 :     switch(nFamily)
     669             :     {
     670             :         case SFX_STYLE_FAMILY_PARA :
     671             :         case SFX_STYLE_FAMILY_CHAR :
     672           0 :         case SFX_STYLE_FAMILY_FRAME: bRet = true;
     673             :         default:; //prevent warning
     674             :     }
     675           0 :     return bRet;
     676             : }
     677             : 
     678             : /*--------------------------------------------------------------------
     679             :     Description:    determine textual description
     680             :  --------------------------------------------------------------------*/
     681           0 : String  SwDocStyleSheet::GetDescription(SfxMapUnit eUnit)
     682             : {
     683           0 :     IntlWrapper aIntlWrapper( SvtSysLocale().GetLanguageTag() );
     684             : 
     685           0 :     rtl::OUString sPlus(" + ");
     686           0 :     if ( SFX_STYLE_FAMILY_PAGE == nFamily )
     687             :     {
     688           0 :         if( !pSet )
     689           0 :             GetItemSet();
     690             : 
     691           0 :         SfxItemIter aIter( *pSet );
     692           0 :         String aDesc;
     693           0 :         const SfxPoolItem* pItem = aIter.FirstItem();
     694             : 
     695           0 :         while ( pItem )
     696             :         {
     697           0 :             if(!IsInvalidItem(pItem))
     698           0 :                 switch ( pItem->Which() )
     699             :                 {
     700             :                     case RES_LR_SPACE:
     701             :                     case SID_ATTR_PAGE_SIZE:
     702             :                     case SID_ATTR_PAGE_MAXSIZE:
     703             :                     case SID_ATTR_PAGE_PAPERBIN:
     704             :                     case SID_ATTR_PAGE_APP:
     705             :                     case SID_ATTR_BORDER_INNER:
     706           0 :                         break;
     707             :                     default:
     708             :                     {
     709           0 :                         String aItemPresentation;
     710           0 :                         if ( !IsInvalidItem( pItem ) &&
     711           0 :                              pPool->GetPool().GetPresentation(
     712             :                                 *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
     713           0 :                                 eUnit, aItemPresentation, &aIntlWrapper ) )
     714             :                         {
     715           0 :                             if ( aDesc.Len() && aItemPresentation.Len() )
     716           0 :                                 aDesc += sPlus;
     717           0 :                             aDesc += aItemPresentation;
     718           0 :                         }
     719             :                     }
     720             :                 }
     721           0 :             pItem = aIter.NextItem();
     722             :         }
     723           0 :         return aDesc;
     724             :     }
     725           0 :     else if ( SFX_STYLE_FAMILY_FRAME == nFamily ||
     726             :                     SFX_STYLE_FAMILY_PARA == nFamily)
     727             :     {
     728           0 :         if( !pSet )
     729           0 :             GetItemSet();
     730             : 
     731           0 :         SfxItemIter aIter( *pSet );
     732           0 :         String aDesc;
     733           0 :         const SfxPoolItem* pItem = aIter.FirstItem();
     734             : 
     735           0 :         rtl::OUString sPageNum;
     736           0 :         String sModel, sBreak;
     737           0 :         sal_Bool bHasWesternFontPrefix = sal_False;
     738           0 :         sal_Bool bHasCJKFontPrefix = sal_False;
     739           0 :         SvtCJKOptions aCJKOptions;
     740             : 
     741           0 :         while ( pItem )
     742             :         {
     743           0 :             if(!IsInvalidItem(pItem))
     744           0 :                 switch ( pItem->Which() )
     745             :                 {
     746             :                     case SID_ATTR_AUTO_STYLE_UPDATE:
     747             :                     case SID_PARA_BACKGRND_DESTINATION:
     748             :                     case RES_PAGEDESC:
     749             :                     //CTL not yet supported
     750             :                     case RES_CHRATR_CTL_FONT:
     751             :                     case RES_CHRATR_CTL_FONTSIZE:
     752             :                     case RES_CHRATR_CTL_LANGUAGE:
     753             :                     case RES_CHRATR_CTL_POSTURE:
     754             :                     case RES_CHRATR_CTL_WEIGHT:
     755           0 :                         break;
     756             :                     default:
     757             :                     {
     758           0 :                         String aItemPresentation;
     759           0 :                         if ( !IsInvalidItem( pItem ) &&
     760           0 :                              pPool->GetPool().GetPresentation(
     761             :                                 *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
     762           0 :                                 eUnit, aItemPresentation, &aIntlWrapper ) )
     763             :                         {
     764           0 :                             sal_Bool bIsDefault = sal_False;
     765           0 :                             switch ( pItem->Which() )
     766             :                             {
     767             :                                 case SID_ATTR_PARA_PAGENUM:
     768           0 :                                     sPageNum = aItemPresentation;
     769           0 :                                     break;
     770             :                                 case SID_ATTR_PARA_MODEL:
     771           0 :                                     sModel = aItemPresentation;
     772           0 :                                     break;
     773             :                                 case RES_BREAK:
     774           0 :                                     sBreak = aItemPresentation;
     775           0 :                                     break;
     776             :                                 case RES_CHRATR_CJK_FONT:
     777             :                                 case RES_CHRATR_CJK_FONTSIZE:
     778             :                                 case RES_CHRATR_CJK_LANGUAGE:
     779             :                                 case RES_CHRATR_CJK_POSTURE:
     780             :                                 case RES_CHRATR_CJK_WEIGHT:
     781           0 :                                 if(aCJKOptions.IsCJKFontEnabled())
     782           0 :                                     bIsDefault = sal_True;
     783           0 :                                 if(!bHasCJKFontPrefix)
     784             :                                 {
     785           0 :                                     aItemPresentation.Insert(SW_RESSTR(STR_CJK_FONT), 0);
     786           0 :                                     bHasCJKFontPrefix = sal_True;
     787             :                                 }
     788           0 :                                 break;
     789             :                                 case RES_CHRATR_FONT:
     790             :                                 case RES_CHRATR_FONTSIZE:
     791             :                                 case RES_CHRATR_LANGUAGE:
     792             :                                 case RES_CHRATR_POSTURE:
     793             :                                 case RES_CHRATR_WEIGHT:
     794           0 :                                 if(!bHasWesternFontPrefix)
     795             :                                 {
     796           0 :                                     aItemPresentation.Insert(SW_RESSTR(STR_WESTERN_FONT), 0);
     797           0 :                                     bHasWesternFontPrefix = sal_True;
     798           0 :                                     bIsDefault = sal_True;
     799             :                                 }
     800             :                                 // no break;
     801             :                                 default:
     802           0 :                                     bIsDefault = sal_True;
     803             :                             }
     804           0 :                             if(bIsDefault)
     805             :                             {
     806           0 :                                 if ( aDesc.Len() && aItemPresentation.Len() )
     807           0 :                                     aDesc += sPlus;
     808           0 :                                 aDesc += aItemPresentation;
     809             :                             }
     810           0 :                         }
     811             :                     }
     812             :                 }
     813           0 :             pItem = aIter.NextItem();
     814             :         }
     815             :         // Special treatment for Break, Page template and Site offset
     816           0 :         if(sBreak.Len() && !sModel.Len())  // when Model, break is invalid
     817             :         {
     818           0 :             if(aDesc.Len())
     819           0 :                 aDesc += sPlus;
     820           0 :             aDesc += sBreak;
     821             :         }
     822           0 :         if(sModel.Len())
     823             :         {
     824           0 :             if(aDesc.Len())
     825           0 :                 aDesc += sPlus;
     826           0 :             aDesc += SW_RESSTR(STR_PAGEBREAK);
     827           0 :             aDesc += sPlus;
     828           0 :             aDesc += sModel;
     829           0 :             if (sPageNum != "0")
     830             :             {
     831           0 :                 aDesc += sPlus;
     832           0 :                 aDesc += SW_RESSTR(STR_PAGEOFFSET);
     833           0 :                 aDesc += sPageNum;
     834             :             }
     835             :         }
     836           0 :         return aDesc;
     837             :     }
     838           0 :     else if( SFX_STYLE_FAMILY_PSEUDO == nFamily )
     839             :     {
     840           0 :         return aEmptyStr;
     841             :     }
     842             : 
     843           0 :     return SfxStyleSheetBase::GetDescription(eUnit);
     844             : }
     845             : 
     846             : 
     847           0 : String  SwDocStyleSheet::GetDescription()
     848             : {
     849           0 :     return GetDescription(SFX_MAPUNIT_CM);
     850             : }
     851             : 
     852             : /*--------------------------------------------------------------------
     853             :     Description:    Set names
     854             :  --------------------------------------------------------------------*/
     855             : 
     856             : 
     857           0 : bool  SwDocStyleSheet::SetName( const String& rStr)
     858             : {
     859           0 :     if( !rStr.Len() )
     860           0 :         return false;
     861             : 
     862           0 :     if( aName != rStr )
     863             :     {
     864           0 :         if( !SfxStyleSheetBase::SetName( rStr ))
     865           0 :             return false;
     866             :     }
     867           0 :     else if(!bPhysical)
     868           0 :         FillStyleSheet( FillPhysical );
     869             : 
     870           0 :     int bChg = false;
     871           0 :     switch(nFamily)
     872             :     {
     873             :         case SFX_STYLE_FAMILY_CHAR :
     874             :         {
     875             :             OSL_ENSURE(pCharFmt, "SwCharFormat missing!");
     876           0 :             if( pCharFmt && pCharFmt->GetName() != rStr )
     877             :             {
     878           0 :                 pCharFmt->SetName( rStr );
     879           0 :                 bChg = true;
     880             :             }
     881           0 :             break;
     882             :         }
     883             :         case SFX_STYLE_FAMILY_PARA :
     884             :         {
     885             :             OSL_ENSURE(pColl, "Collection missing!");
     886           0 :             if( pColl && pColl->GetName() != rStr )
     887             :             {
     888           0 :                 if (pColl->GetName().Len() > 0)
     889           0 :                     rDoc.RenameFmt(*pColl, rStr);
     890             :                 else
     891           0 :                     pColl->SetName(rStr);
     892             : 
     893           0 :                 bChg = true;
     894             :             }
     895           0 :             break;
     896             :         }
     897             :         case SFX_STYLE_FAMILY_FRAME:
     898             :         {
     899             :             OSL_ENSURE(pFrmFmt, "FrmFmt missing!");
     900           0 :             if( pFrmFmt && pFrmFmt->GetName() != rStr )
     901             :             {
     902           0 :                 if (pFrmFmt->GetName().Len() > 0)
     903           0 :                     rDoc.RenameFmt(*pFrmFmt, rStr);
     904             :                 else
     905           0 :                     pFrmFmt->SetName( rStr );
     906             : 
     907           0 :                 bChg = true;
     908             :             }
     909           0 :             break;
     910             :         }
     911             :         case SFX_STYLE_FAMILY_PAGE :
     912             :             OSL_ENSURE(pDesc, "PageDesc missing!");
     913           0 :             if( pDesc && pDesc->GetName() != rStr )
     914             :             {
     915             :                 // Set PageDesc - copy with earlier one - probably not
     916             :                 // necessary for setting the name. So here we allow a
     917             :                 // cast.
     918           0 :                 SwPageDesc aPageDesc(*((SwPageDesc*)pDesc));
     919           0 :                 String aOldName(aPageDesc.GetName());
     920             : 
     921           0 :                 aPageDesc.SetName( rStr );
     922           0 :                 bool const bDoesUndo = rDoc.GetIDocumentUndoRedo().DoesUndo();
     923             : 
     924           0 :                 rDoc.GetIDocumentUndoRedo().DoUndo(aOldName.Len() > 0);
     925           0 :                 rDoc.ChgPageDesc(aOldName, aPageDesc);
     926           0 :                 rDoc.GetIDocumentUndoRedo().DoUndo(bDoesUndo);
     927             : 
     928           0 :                 rDoc.SetModified();
     929           0 :                 bChg = true;
     930             :             }
     931           0 :             break;
     932             :         case SFX_STYLE_FAMILY_PSEUDO:
     933             :             OSL_ENSURE(pNumRule, "NumRule missing!");
     934             : 
     935           0 :             if (pNumRule)
     936             :             {
     937           0 :                 String aOldName = pNumRule->GetName();
     938             : 
     939           0 :                 if (aOldName.Len() > 0)
     940             :                 {
     941           0 :                     if ( aOldName != rStr &&
     942           0 :                          rDoc.RenameNumRule(aOldName, rStr))
     943             :                     {
     944           0 :                         pNumRule = rDoc.FindNumRulePtr(rStr);
     945           0 :                         rDoc.SetModified();
     946             : 
     947           0 :                         bChg = true;
     948             :                     }
     949             :                 }
     950             :                 else
     951             :                 {
     952             :                     // #i91400#
     953           0 :                     ((SwNumRule*)pNumRule)->SetName( rStr, rDoc );
     954           0 :                     rDoc.SetModified();
     955             : 
     956           0 :                     bChg = true;
     957           0 :                 }
     958             :             }
     959             : 
     960           0 :             break;
     961             : 
     962             :         default:
     963             :             OSL_ENSURE(!this, "unknown style family");
     964             :     }
     965             : 
     966           0 :     if( bChg )
     967             :     {
     968           0 :         pPool->First();  // internal list has to be updated
     969           0 :         pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED, *this ) );
     970           0 :         SwEditShell* pSh = rDoc.GetEditShell();
     971           0 :         if( pSh )
     972           0 :             pSh->CallChgLnk();
     973             :     }
     974           0 :     return true;
     975             : }
     976             : 
     977             : /*--------------------------------------------------------------------
     978             :     Description:    hierarchy of deduction
     979             :  --------------------------------------------------------------------*/
     980             : 
     981             : 
     982         324 : bool   SwDocStyleSheet::SetParent( const String& rStr)
     983             : {
     984         324 :     SwFmt* pFmt = 0, *pParent = 0;
     985         324 :     switch(nFamily)
     986             :     {
     987             :         case SFX_STYLE_FAMILY_CHAR :
     988             :             OSL_ENSURE( pCharFmt, "SwCharFormat missing!" );
     989          22 :             if( 0 != ( pFmt = pCharFmt ) && rStr.Len() )
     990          22 :                 pParent = lcl_FindCharFmt(rDoc, rStr);
     991          22 :             break;
     992             : 
     993             :         case SFX_STYLE_FAMILY_PARA :
     994             :             OSL_ENSURE( pColl, "Collektion missing!");
     995         302 :             if( 0 != ( pFmt = pColl ) && rStr.Len() )
     996         195 :                 pParent = lcl_FindParaFmt( rDoc, rStr );
     997         302 :             break;
     998             : 
     999             :         case SFX_STYLE_FAMILY_FRAME:
    1000             :             OSL_ENSURE(pFrmFmt, "FrameFormat missing!");
    1001           0 :             if( 0 != ( pFmt = pFrmFmt ) && rStr.Len() )
    1002           0 :                 pParent = lcl_FindFrmFmt( rDoc, rStr );
    1003           0 :             break;
    1004             : 
    1005             :         case SFX_STYLE_FAMILY_PAGE:
    1006             :         case SFX_STYLE_FAMILY_PSEUDO:
    1007           0 :             break;
    1008             :         default:
    1009             :             OSL_ENSURE(!this, "unknown style family");
    1010             :     }
    1011             : 
    1012         324 :     bool bRet = false;
    1013         648 :     if( pFmt && pFmt->DerivedFrom() &&
    1014         324 :         pFmt->DerivedFrom()->GetName() != rStr )
    1015             :     {
    1016             :         {
    1017         324 :             SwImplShellAction aTmp( rDoc );
    1018         324 :             bRet = pFmt->SetDerivedFrom( pParent );
    1019             :         }
    1020             : 
    1021         324 :         if( bRet )
    1022             :         {
    1023         324 :             aParent = rStr;
    1024             :             pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
    1025         324 :                             *this ) );
    1026             :         }
    1027             :     }
    1028             : 
    1029         324 :     return bRet;
    1030             : }
    1031             : 
    1032             : /*--------------------------------------------------------------------
    1033             :     Description:    Set Follower
    1034             :  --------------------------------------------------------------------*/
    1035             : 
    1036             : 
    1037           6 : bool   SwDocStyleSheet::SetFollow( const String& rStr)
    1038             : {
    1039           6 :     if( rStr.Len() && !SfxStyleSheetBase::SetFollow( rStr ))
    1040           0 :         return false;
    1041             : 
    1042           6 :     SwImplShellAction aTmpSh( rDoc );
    1043           6 :     switch(nFamily)
    1044             :     {
    1045             :     case SFX_STYLE_FAMILY_PARA :
    1046             :     {
    1047             :         OSL_ENSURE(pColl, "Collection missing!");
    1048           4 :         if( pColl )
    1049             :         {
    1050           4 :             SwTxtFmtColl* pFollow = pColl;
    1051           4 :             if( rStr.Len() && 0 == (pFollow = lcl_FindParaFmt(rDoc, rStr) ))
    1052           0 :                 pFollow = pColl;
    1053             : 
    1054           4 :             pColl->SetNextTxtFmtColl(*pFollow);
    1055             :         }
    1056           4 :         break;
    1057             :     }
    1058             :     case SFX_STYLE_FAMILY_PAGE :
    1059             :     {
    1060             :         OSL_ENSURE(pDesc, "PageDesc missing!");
    1061           2 :         if( pDesc )
    1062             :         {
    1063           2 :             const SwPageDesc* pFollowDesc = rStr.Len()
    1064           2 :                                             ? lcl_FindPageDesc(rDoc, rStr)
    1065           4 :                                             : 0;
    1066             :             sal_uInt16 nId;
    1067           4 :             if( pFollowDesc != pDesc->GetFollow() &&
    1068           2 :                 rDoc.FindPageDescByName( pDesc->GetName(), &nId ) )
    1069             :             {
    1070           2 :                 SwPageDesc aDesc( *pDesc );
    1071           2 :                 aDesc.SetFollow( pFollowDesc );
    1072           2 :                 rDoc.ChgPageDesc( nId, aDesc );
    1073           2 :                 pDesc = &rDoc.GetPageDesc( nId );
    1074             :             }
    1075             :         }
    1076           2 :         break;
    1077             :     }
    1078             :     case SFX_STYLE_FAMILY_CHAR:
    1079             :     case SFX_STYLE_FAMILY_FRAME:
    1080             :     case SFX_STYLE_FAMILY_PSEUDO:
    1081           0 :         break;
    1082             :     default:
    1083             :         OSL_ENSURE(!this, "unknwown style family");
    1084             :     }
    1085             : 
    1086           6 :     return true;
    1087             : }
    1088             : 
    1089             : /*--------------------------------------------------------------------
    1090             :     Description:    extract ItemSet to Name and Family, Mask
    1091             :  --------------------------------------------------------------------*/
    1092             : 
    1093        4613 : SfxItemSet&   SwDocStyleSheet::GetItemSet()
    1094             : {
    1095        4613 :     if(!bPhysical)
    1096         111 :         FillStyleSheet( FillPhysical );
    1097             : 
    1098        4613 :     switch(nFamily)
    1099             :     {
    1100             :         case SFX_STYLE_FAMILY_CHAR:
    1101             :             {
    1102             :                 OSL_ENSURE(pCharFmt, "Where's SwCharFmt");
    1103         815 :                 aCoreSet.Put(pCharFmt->GetAttrSet());
    1104             : 
    1105         815 :                 if(pCharFmt->DerivedFrom())
    1106         815 :                     aCoreSet.SetParent(&pCharFmt->DerivedFrom()->GetAttrSet());
    1107             :             }
    1108         815 :             break;
    1109             :         case SFX_STYLE_FAMILY_PARA :
    1110             :         case SFX_STYLE_FAMILY_FRAME:
    1111             :             {
    1112        2587 :                 SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
    1113        2587 :                 aBoxInfo.SetTable( sal_False );
    1114        2587 :                 aBoxInfo.SetDist( sal_True );   // always show gap field
    1115        2587 :                 aBoxInfo.SetMinDist( sal_True );// set minimum size in tables and paragraphs
    1116        2587 :                 aBoxInfo.SetDefDist( MIN_BORDER_DIST );// always set Default-Gap
    1117             :                     // Single lines can only have DontCare-Status in tables
    1118        2587 :                 aBoxInfo.SetValid( VALID_DISABLE, sal_True );
    1119        2587 :                 if ( nFamily == SFX_STYLE_FAMILY_PARA )
    1120             :                 {
    1121             :                     OSL_ENSURE(pColl, "Where's Collection");
    1122        2566 :                     aCoreSet.Put(pColl->GetAttrSet());
    1123        2566 :                     aCoreSet.Put( aBoxInfo );
    1124        2566 :                     aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pColl->IsAutoUpdateFmt()));
    1125             : 
    1126        2566 :                     if(pColl->DerivedFrom())
    1127        2566 :                         aCoreSet.SetParent(&pColl->DerivedFrom()->GetAttrSet());
    1128             :                 }
    1129             :                 else
    1130             :                 {
    1131             :                     OSL_ENSURE(pFrmFmt, "Where's FrmFmt");
    1132          21 :                     aCoreSet.Put(pFrmFmt->GetAttrSet());
    1133          21 :                     aCoreSet.Put( aBoxInfo );
    1134          21 :                     aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pFrmFmt->IsAutoUpdateFmt()));
    1135             : 
    1136          21 :                     if(pFrmFmt->DerivedFrom())
    1137          21 :                         aCoreSet.SetParent(&pFrmFmt->DerivedFrom()->GetAttrSet());
    1138        2587 :                 }
    1139             :             }
    1140        2587 :             break;
    1141             : 
    1142             :         case SFX_STYLE_FAMILY_PAGE :
    1143             :             {
    1144             :                 OSL_ENSURE(pDesc, "No PageDescriptor");
    1145        1123 :                 ::PageDescToItemSet(*((SwPageDesc*)pDesc), aCoreSet);
    1146             :             }
    1147        1123 :             break;
    1148             : 
    1149             :         case SFX_STYLE_FAMILY_PSEUDO:
    1150             :             {
    1151             :                 OSL_ENSURE(pNumRule, "No NumRule");
    1152          88 :                 SvxNumRule aRule = pNumRule->MakeSvxNumRule();
    1153          88 :                 aCoreSet.Put(SvxNumBulletItem(aRule));
    1154             :             }
    1155          88 :             break;
    1156             : 
    1157             :         default:
    1158             :             OSL_ENSURE(!this, "unknown style family");
    1159             :     }
    1160             :     // Member of Baseclass
    1161        4613 :     pSet = &aCoreSet;
    1162             : 
    1163        4613 :     return aCoreSet;
    1164             : }
    1165             : 
    1166           0 : void SwDocStyleSheet::MergeIndentAttrsOfListStyle( SfxItemSet& rSet )
    1167             : {
    1168           0 :     if ( nFamily != SFX_STYLE_FAMILY_PARA )
    1169             :     {
    1170           0 :         return;
    1171             :     }
    1172             : 
    1173             :     OSL_ENSURE( pColl, "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - missing paragraph style");
    1174           0 :     if ( pColl->AreListLevelIndentsApplicable() )
    1175             :     {
    1176             :         OSL_ENSURE( pColl->GetItemState( RES_PARATR_NUMRULE ) == SFX_ITEM_SET,
    1177             :                 "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - list level indents are applicable at paragraph style, but no list style found. Serious defect -> please inform OD." );
    1178           0 :         const String sNumRule = pColl->GetNumRule().GetValue();
    1179           0 :         if( sNumRule.Len() )
    1180             :         {
    1181           0 :             const SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
    1182           0 :             if( pRule )
    1183             :             {
    1184           0 :                 const SwNumFmt& rFmt = pRule->Get( 0 );
    1185           0 :                 if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
    1186             :                 {
    1187           0 :                     SvxLRSpaceItem aLR( RES_LR_SPACE );
    1188           0 :                     aLR.SetTxtLeft( rFmt.GetIndentAt() );
    1189           0 :                     aLR.SetTxtFirstLineOfst( static_cast<short>(rFmt.GetFirstLineIndent()) );
    1190           0 :                     rSet.Put( aLR );
    1191             :                 }
    1192             :             }
    1193           0 :         }
    1194             :     }
    1195             : }
    1196             : 
    1197             : // handling of parameter <bResetIndentAttrsAtParagraphStyle>
    1198        2808 : void SwDocStyleSheet::SetItemSet( const SfxItemSet& rSet,
    1199             :                                   const bool bResetIndentAttrsAtParagraphStyle )
    1200             : {
    1201             :     // if applicable determine format first
    1202        2808 :     if(!bPhysical)
    1203           0 :         FillStyleSheet( FillPhysical );
    1204             : 
    1205        2808 :     SwImplShellAction aTmpSh( rDoc );
    1206             : 
    1207             :     OSL_ENSURE( &rSet != &aCoreSet, "SetItemSet with own Set is not allowed" );
    1208             : 
    1209        2808 :     if (rDoc.GetIDocumentUndoRedo().DoesUndo())
    1210             :     {
    1211           0 :         SwRewriter aRewriter;
    1212           0 :         aRewriter.AddRule( UndoArg1, GetName() );
    1213           0 :         rDoc.GetIDocumentUndoRedo().StartUndo( UNDO_INSFMTATTR, &aRewriter );
    1214             :     }
    1215             : 
    1216        2808 :     SwFmt* pFmt = 0;
    1217        2808 :     SwPageDesc* pNewDsc = 0;
    1218        2808 :     sal_uInt16 nPgDscPos = 0;
    1219             : 
    1220        2808 :     switch(nFamily)
    1221             :     {
    1222             :         case SFX_STYLE_FAMILY_CHAR :
    1223             :             {
    1224             :                 OSL_ENSURE(pCharFmt, "Where's CharFormat");
    1225         726 :                 pFmt = pCharFmt;
    1226             :             }
    1227         726 :             break;
    1228             : 
    1229             :         case SFX_STYLE_FAMILY_PARA :
    1230             :         {
    1231             :             OSL_ENSURE(pColl, "Where's Collection");
    1232             :             const SfxPoolItem* pAutoUpdate;
    1233        1582 :             if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
    1234             :             {
    1235        1582 :                 pColl->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
    1236             :             }
    1237             : 
    1238             :             const SwCondCollItem* pCondItem;
    1239        1582 :             if( SFX_ITEM_SET != rSet.GetItemState( FN_COND_COLL, sal_False,
    1240        1582 :                 (const SfxPoolItem**)&pCondItem ))
    1241        1582 :                 pCondItem = 0;
    1242             : 
    1243        1582 :             if( RES_CONDTXTFMTCOLL == pColl->Which() && pCondItem )
    1244             :             {
    1245             :                 SwFmt* pFindFmt;
    1246           0 :                 const CommandStruct* pCmds = SwCondCollItem::GetCmds();
    1247           0 :                 for(sal_uInt16 i = 0; i < COND_COMMAND_COUNT; i++)
    1248             :                 {
    1249           0 :                     SwCollCondition aCond( 0, pCmds[ i ].nCnd, pCmds[ i ].nSubCond );
    1250           0 :                     ((SwConditionTxtFmtColl*)pColl)->RemoveCondition( aCond );
    1251           0 :                     const String& rStyle = pCondItem->GetStyle( i );
    1252           0 :                     if( rStyle.Len() &&
    1253           0 :                         0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
    1254             :                     {
    1255           0 :                         aCond.RegisterToFormat( *pFindFmt );
    1256           0 :                         ((SwConditionTxtFmtColl*)pColl)->InsertCondition( aCond );
    1257             :                     }
    1258           0 :                 }
    1259             : 
    1260             :                 // Update document to new conditions
    1261           0 :                 SwCondCollCondChg aMsg( pColl );
    1262           0 :                 pColl->ModifyNotification( &aMsg, &aMsg );
    1263             :             }
    1264        1582 :             else if( pCondItem && !pColl->GetDepends() )
    1265             :             {
    1266             :                 // no conditional template, then first create and adopt
    1267             :                 // all important values
    1268             :                 SwConditionTxtFmtColl* pCColl = rDoc.MakeCondTxtFmtColl(
    1269           0 :                         pColl->GetName(), (SwTxtFmtColl*)pColl->DerivedFrom() );
    1270           0 :                 if( pColl != &pColl->GetNextTxtFmtColl() )
    1271           0 :                     pCColl->SetNextTxtFmtColl( pColl->GetNextTxtFmtColl() );
    1272             : 
    1273           0 :                 if( pColl->IsAssignedToListLevelOfOutlineStyle())
    1274           0 :                     pCColl->AssignToListLevelOfOutlineStyle(pColl->GetAssignedOutlineStyleLevel());
    1275             :                 else
    1276           0 :                     pCColl->DeleteAssignmentToListLevelOfOutlineStyle();
    1277             : 
    1278             : 
    1279             : 
    1280             :                 SwTxtFmtColl* pFindFmt;
    1281           0 :                 const CommandStruct* pCmds = SwCondCollItem::GetCmds();
    1282           0 :                 for( sal_uInt16 i = 0; i < COND_COMMAND_COUNT; ++i )
    1283             :                 {
    1284           0 :                     const String& rStyle = pCondItem->GetStyle( i );
    1285           0 :                     if( rStyle.Len() &&
    1286           0 :                         0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
    1287             :                     {
    1288             :                         pCColl->InsertCondition( SwCollCondition( pFindFmt,
    1289           0 :                                     pCmds[ i ].nCnd, pCmds[ i ].nSubCond ) );
    1290             :                     }
    1291             :                 }
    1292             : 
    1293           0 :                 rDoc.DelTxtFmtColl( pColl );
    1294           0 :                 pColl = pCColl;
    1295             :             }
    1296        1582 :             if ( bResetIndentAttrsAtParagraphStyle &&
    1297           0 :                  rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, 0 ) == SFX_ITEM_SET &&
    1298           0 :                  rSet.GetItemState( RES_LR_SPACE, sal_False, 0 ) != SFX_ITEM_SET &&
    1299           0 :                  pColl->GetItemState( RES_LR_SPACE, sal_False, 0 ) == SFX_ITEM_SET )
    1300             :             {
    1301           0 :                 rDoc.ResetAttrAtFormat( RES_LR_SPACE, *pColl );
    1302             :             }
    1303             : 
    1304             :             // #i56252: If a standard numbering style is assigned to a standard paragraph style
    1305             :             // we have to create a physical instance of the numbering style. If we do not and
    1306             :             // neither the paragraph style nor the numbering style is used in the document
    1307             :             // the numbering style will not be saved with the document and the assignment got lost.
    1308        1582 :             const SfxPoolItem* pNumRuleItem = 0;
    1309        1582 :             if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, &pNumRuleItem ) )
    1310             :             {   // Setting a numbering rule?
    1311          29 :                 String sNumRule = ((SwNumRuleItem*)pNumRuleItem)->GetValue();
    1312          29 :                 if( sNumRule.Len() )
    1313             :                 {
    1314           9 :                     SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
    1315           9 :                     if( !pRule )
    1316             :                     {   // Numbering rule not in use yet.
    1317           0 :                         sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( sNumRule, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
    1318           0 :                         if( USHRT_MAX != nPoolId ) // It's a standard numbering rule
    1319             :                         {
    1320           0 :                             pRule = rDoc.GetNumRuleFromPool( nPoolId ); // Create numbering rule (physical)
    1321             :                         }
    1322             :                     }
    1323          29 :                 }
    1324             :             }
    1325             : 
    1326        1582 :             pFmt = pColl;
    1327             : 
    1328        1582 :             sal_uInt16 nId = pColl->GetPoolFmtId() &
    1329        1582 :                             ~ ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID );
    1330        1582 :             switch( GetMask() & ( 0x0fff & ~SWSTYLEBIT_CONDCOLL ) )
    1331             :             {
    1332             :                 case SWSTYLEBIT_TEXT:
    1333         515 :                     nId |= COLL_TEXT_BITS;
    1334         515 :                     break;
    1335             :                 case SWSTYLEBIT_CHAPTER:
    1336           7 :                     nId |= COLL_DOC_BITS;
    1337           7 :                     break;
    1338             :                 case SWSTYLEBIT_LIST:
    1339         127 :                     nId |= COLL_LISTS_BITS;
    1340         127 :                     break;
    1341             :                 case SWSTYLEBIT_IDX:
    1342         145 :                     nId |= COLL_REGISTER_BITS;
    1343         145 :                     break;
    1344             :                 case SWSTYLEBIT_EXTRA:
    1345         188 :                     nId |= COLL_EXTRA_BITS;
    1346         188 :                     break;
    1347             :                 case SWSTYLEBIT_HTML:
    1348           0 :                     nId |= COLL_HTML_BITS;
    1349           0 :                     break;
    1350             :             }
    1351        1582 :             pColl->SetPoolFmtId( nId );
    1352             :             break;
    1353             :         }
    1354             :         case SFX_STYLE_FAMILY_FRAME:
    1355             :         {
    1356             :             OSL_ENSURE(pFrmFmt, "Where's FrmFmt");
    1357             :             const SfxPoolItem* pAutoUpdate;
    1358           9 :             if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
    1359             :             {
    1360           9 :                 pFrmFmt->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
    1361             :             }
    1362           9 :             pFmt = pFrmFmt;
    1363             :         }
    1364           9 :         break;
    1365             : 
    1366             :         case SFX_STYLE_FAMILY_PAGE :
    1367             :             {
    1368             :                 OSL_ENSURE(pDesc, "Where's PageDescriptor");
    1369             : 
    1370         411 :                 if( rDoc.FindPageDescByName( pDesc->GetName(), &nPgDscPos ))
    1371             :                 {
    1372         411 :                     pNewDsc = new SwPageDesc( *pDesc );
    1373             :                     // #i48949# - no undo actions for the
    1374             :                     // copy of the page style
    1375         411 :                     ::sw::UndoGuard const ug(rDoc.GetIDocumentUndoRedo());
    1376         411 :                     rDoc.CopyPageDesc(*pDesc, *pNewDsc); // #i7983#
    1377             : 
    1378         411 :                     pFmt = &pNewDsc->GetMaster();
    1379             :                 }
    1380             :             }
    1381         411 :             break;
    1382             : 
    1383             :         case SFX_STYLE_FAMILY_PSEUDO:
    1384             :             {
    1385             :                 OSL_ENSURE(pNumRule, "Where's NumRule");
    1386             : 
    1387          80 :                 if (!pNumRule)
    1388             :                     break;
    1389             : 
    1390             :                 const SfxPoolItem* pItem;
    1391          80 :                 switch( rSet.GetItemState( SID_ATTR_NUMBERING_RULE, sal_False, &pItem ))
    1392             :                 {
    1393             :                 case SFX_ITEM_SET:
    1394             :                 {
    1395          80 :                     SvxNumRule* pSetRule = ((SvxNumBulletItem*)pItem)->GetNumRule();
    1396          80 :                     pSetRule->UnLinkGraphics();
    1397          80 :                     SwNumRule aSetRule(*pNumRule);
    1398          80 :                     aSetRule.SetSvxRule(*pSetRule, &rDoc);
    1399          80 :                     rDoc.ChgNumRuleFmts( aSetRule );
    1400             :                 }
    1401          80 :                 break;
    1402             :                 case SFX_ITEM_DONTCARE:
    1403             :                     // set NumRule to default values
    1404             :                     // what are the default values?
    1405             :                     {
    1406           0 :                         SwNumRule aRule( pNumRule->GetName(),
    1407             :                                          // #i89178#
    1408           0 :                                          numfunc::GetDefaultPositionAndSpaceMode() );
    1409           0 :                         rDoc.ChgNumRuleFmts( aRule );
    1410             :                     }
    1411           0 :                     break;
    1412             :                 }
    1413             :             }
    1414          80 :             break;
    1415             : 
    1416             :         default:
    1417             :             OSL_ENSURE(!this, "unknown style family");
    1418             :     }
    1419             : 
    1420        2808 :     if( pFmt && rSet.Count())
    1421             :     {
    1422        2718 :         SfxItemIter aIter( rSet );
    1423        2718 :         const SfxPoolItem* pItem = aIter.GetCurItem();
    1424       17773 :         while( sal_True )
    1425             :         {
    1426       20491 :             if( IsInvalidItem( pItem ) )            // Clear
    1427             :             {
    1428             :                 // use method <SwDoc::ResetAttrAtFormat(..)> in order to
    1429             :                 // create an Undo object for the attribute reset.
    1430           0 :                 rDoc.ResetAttrAtFormat( rSet.GetWhichByPos(aIter.GetCurPos()),
    1431           0 :                                         *pFmt );
    1432             :             }
    1433             : 
    1434       20491 :             if( aIter.IsAtEnd() )
    1435        2718 :                 break;
    1436       17773 :             pItem = aIter.NextItem();
    1437             :         }
    1438        2718 :         SfxItemSet aSet(rSet);
    1439        2718 :         aSet.ClearInvalidItems();
    1440             : 
    1441        2718 :         aCoreSet.ClearItem();
    1442             : 
    1443        2718 :         if( pNewDsc )
    1444             :         {
    1445         411 :             ::ItemSetToPageDesc( aSet, *pNewDsc );
    1446         411 :             rDoc.ChgPageDesc( nPgDscPos, *pNewDsc );
    1447         411 :             pDesc = &rDoc.GetPageDesc( nPgDscPos );
    1448         411 :             rDoc.PreDelPageDesc(pNewDsc); // #i7983#
    1449         411 :             delete pNewDsc;
    1450             :         }
    1451             :         else
    1452        2307 :             rDoc.ChgFmt(*pFmt, aSet);       // put all that is set
    1453             :     }
    1454             :     else
    1455             :     {
    1456          90 :         aCoreSet.ClearItem();
    1457          90 :         if( pNewDsc )       // we still need to delete it
    1458             :         {
    1459           0 :             rDoc.PreDelPageDesc(pNewDsc); // #i7983#
    1460           0 :             delete pNewDsc;
    1461             :         }
    1462             :     }
    1463             : 
    1464        2808 :     if (rDoc.GetIDocumentUndoRedo().DoesUndo())
    1465             :     {
    1466           0 :         rDoc.GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
    1467        2808 :     }
    1468        2808 : }
    1469             : 
    1470           0 : static void lcl_SaveStyles( sal_uInt16 nFamily, std::vector<void*>& rArr, SwDoc& rDoc )
    1471             : {
    1472           0 :     switch( nFamily )
    1473             :     {
    1474             :     case SFX_STYLE_FAMILY_CHAR:
    1475             :         {
    1476           0 :             const SwCharFmts& rTbl = *rDoc.GetCharFmts();
    1477           0 :             for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1478             :             {
    1479           0 :                 rArr.push_back( rTbl[ n ] );
    1480             :             }
    1481             :         }
    1482           0 :         break;
    1483             :     case SFX_STYLE_FAMILY_PARA:
    1484             :         {
    1485           0 :             const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
    1486           0 :             for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1487             :             {
    1488           0 :                 rArr.push_back( rTbl[ n ] );
    1489             :             }
    1490             :         }
    1491           0 :         break;
    1492             :     case SFX_STYLE_FAMILY_FRAME:
    1493             :         {
    1494           0 :             const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
    1495           0 :             for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1496             :             {
    1497           0 :                 rArr.push_back( rTbl[ n ] );
    1498             :             }
    1499             :         }
    1500           0 :         break;
    1501             : 
    1502             :     case SFX_STYLE_FAMILY_PAGE:
    1503             :         {
    1504           0 :             for( sal_uInt16 n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
    1505             :             {
    1506           0 :                 rArr.push_back( &rDoc.GetPageDesc( n ) );
    1507             :             }
    1508             :         }
    1509           0 :         break;
    1510             : 
    1511             :     case SFX_STYLE_FAMILY_PSEUDO:
    1512             :         {
    1513           0 :             const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
    1514           0 :             for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1515             :             {
    1516           0 :                 rArr.push_back( rTbl[ n ] );
    1517             :             }
    1518             :         }
    1519           0 :         break;
    1520             :     }
    1521           0 : }
    1522             : 
    1523           0 : static bool lcl_Contains(const std::vector<void*>& rArr, const void* p)
    1524             : {
    1525           0 :     return std::find( rArr.begin(), rArr.end(), p ) != rArr.end();
    1526             : }
    1527             : 
    1528           0 : static void lcl_DeleteInfoStyles( sal_uInt16 nFamily, std::vector<void*>& rArr, SwDoc& rDoc )
    1529             : {
    1530             :     sal_uInt16 n, nCnt;
    1531           0 :     switch( nFamily )
    1532             :     {
    1533             :     case SFX_STYLE_FAMILY_CHAR:
    1534             :         {
    1535           0 :             std::deque<sal_uInt16> aDelArr;
    1536           0 :             const SwCharFmts& rTbl = *rDoc.GetCharFmts();
    1537           0 :             for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1538             :             {
    1539           0 :                 if( !lcl_Contains( rArr, rTbl[ n ] ))
    1540           0 :                     aDelArr.push_front( n );
    1541             :             }
    1542           0 :             for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
    1543           0 :                 rDoc.DelCharFmt( aDelArr[ n ] );
    1544             :         }
    1545           0 :         break;
    1546             : 
    1547             :     case SFX_STYLE_FAMILY_PARA :
    1548             :         {
    1549           0 :             std::deque<sal_uInt16> aDelArr;
    1550           0 :             const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
    1551           0 :             for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1552             :             {
    1553           0 :                 if( !lcl_Contains( rArr, rTbl[ n ] ))
    1554           0 :                     aDelArr.push_front( n );
    1555             :             }
    1556           0 :             for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
    1557           0 :                 rDoc.DelTxtFmtColl( aDelArr[ n ] );
    1558             :         }
    1559           0 :         break;
    1560             : 
    1561             :     case SFX_STYLE_FAMILY_FRAME:
    1562             :         {
    1563           0 :             std::deque<SwFrmFmt*> aDelArr;
    1564           0 :             const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
    1565           0 :             for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1566             :             {
    1567           0 :                 if( !lcl_Contains( rArr, rTbl[ n ] ))
    1568           0 :                     aDelArr.push_front( rTbl[ n ] );
    1569             :             }
    1570           0 :             for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
    1571           0 :                 rDoc.DelFrmFmt( aDelArr[ n ] );
    1572             :         }
    1573           0 :         break;
    1574             : 
    1575             :     case SFX_STYLE_FAMILY_PAGE:
    1576             :         {
    1577           0 :             std::deque<sal_uInt16> aDelArr;
    1578           0 :             for( n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
    1579             :             {
    1580           0 :                 if( !lcl_Contains( rArr, &rDoc.GetPageDesc( n ) ))
    1581           0 :                     aDelArr.push_front( n );
    1582             :             }
    1583           0 :             for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
    1584           0 :                 rDoc.DelPageDesc( aDelArr[ n ] );
    1585             :         }
    1586           0 :         break;
    1587             : 
    1588             : 
    1589             :     case SFX_STYLE_FAMILY_PSEUDO:
    1590             :         {
    1591           0 :             std::deque<SwNumRule*> aDelArr;
    1592           0 :             const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
    1593           0 :             for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
    1594             :             {
    1595           0 :                 if( !lcl_Contains( rArr, rTbl[ n ] ))
    1596           0 :                     aDelArr.push_front( rTbl[ n ] );
    1597             :             }
    1598           0 :             for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
    1599           0 :                 rDoc.DelNumRule( aDelArr[ n ]->GetName() );
    1600             :         }
    1601           0 :         break;
    1602             :     }
    1603           0 : }
    1604             : 
    1605             : /*--------------------------------------------------------------------
    1606             :     Description:    determine the format
    1607             :  --------------------------------------------------------------------*/
    1608             : 
    1609       15426 : sal_Bool SwDocStyleSheet::FillStyleSheet( FillStyleType eFType )
    1610             : {
    1611       15426 :     sal_Bool bRet = sal_False;
    1612       15426 :     sal_uInt16 nPoolId = USHRT_MAX;
    1613       15426 :     SwFmt* pFmt = 0;
    1614             : 
    1615       15426 :     sal_Bool bCreate = FillPhysical == eFType;
    1616       15426 :     sal_Bool bDeleteInfo = sal_False;
    1617       15426 :     sal_Bool bFillOnlyInfo = FillAllInfo == eFType;
    1618       15426 :     std::vector<void*> aDelArr;
    1619             : 
    1620       15426 :     switch(nFamily)
    1621             :     {
    1622             :     case SFX_STYLE_FAMILY_CHAR:
    1623        2768 :         pCharFmt = lcl_FindCharFmt(rDoc, aName, this, bCreate );
    1624        2768 :         bPhysical = 0 != pCharFmt;
    1625        2768 :         if( bFillOnlyInfo && !bPhysical )
    1626             :         {
    1627           0 :             bDeleteInfo = sal_True;
    1628           0 :             ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1629           0 :             pCharFmt = lcl_FindCharFmt(rDoc, aName, this, sal_True );
    1630             :         }
    1631             : 
    1632        2768 :         pFmt = pCharFmt;
    1633        2768 :         if( !bCreate && !pFmt )
    1634             :         {
    1635        2574 :             if( aName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
    1636        1287 :                                             RES_POOLCOLL_TEXT_BEGIN ] )
    1637           0 :                 nPoolId = 0;
    1638             :             else
    1639        1287 :                 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
    1640             :         }
    1641             : 
    1642        2768 :         bRet = 0 != pCharFmt || USHRT_MAX != nPoolId;
    1643             : 
    1644        2768 :         if( bDeleteInfo )
    1645           0 :             pCharFmt = 0;
    1646        2768 :         break;
    1647             : 
    1648             :     case SFX_STYLE_FAMILY_PARA:
    1649             :         {
    1650        9132 :             pColl = lcl_FindParaFmt(rDoc, aName, this, bCreate);
    1651        9132 :             bPhysical = 0 != pColl;
    1652        9132 :             if( bFillOnlyInfo && !bPhysical )
    1653             :             {
    1654           0 :                 bDeleteInfo = sal_True;
    1655           0 :                 ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1656           0 :                 pColl = lcl_FindParaFmt(rDoc, aName, this, sal_True );
    1657             :             }
    1658             : 
    1659        9132 :             pFmt = pColl;
    1660        9132 :             if( pColl )
    1661        6889 :                 PresetFollow( pColl->GetNextTxtFmtColl().GetName() );
    1662        2243 :             else if( !bCreate )
    1663        2243 :                 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
    1664             : 
    1665        9132 :             bRet = 0 != pColl || USHRT_MAX != nPoolId;
    1666             : 
    1667        9132 :             if( bDeleteInfo )
    1668           0 :                 pColl = 0;
    1669             :         }
    1670        9132 :         break;
    1671             : 
    1672             :     case SFX_STYLE_FAMILY_FRAME:
    1673         300 :         pFrmFmt = lcl_FindFrmFmt(rDoc,  aName, this, bCreate);
    1674         300 :         bPhysical = 0 != pFrmFmt;
    1675         300 :         if( bFillOnlyInfo && bPhysical )
    1676             :         {
    1677           0 :             bDeleteInfo = sal_True;
    1678           0 :             ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1679           0 :             pFrmFmt = lcl_FindFrmFmt(rDoc, aName, this, sal_True );
    1680             :         }
    1681         300 :         pFmt = pFrmFmt;
    1682         300 :         if( !bCreate && !pFmt )
    1683         242 :             nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
    1684             : 
    1685         300 :         bRet = 0 != pFrmFmt || USHRT_MAX != nPoolId;
    1686             : 
    1687         300 :         if( bDeleteInfo )
    1688           0 :             pFrmFmt = 0;
    1689         300 :         break;
    1690             : 
    1691             :     case SFX_STYLE_FAMILY_PAGE:
    1692        2770 :         pDesc = lcl_FindPageDesc(rDoc, aName, this, bCreate);
    1693        2770 :         bPhysical = 0 != pDesc;
    1694        2770 :         if( bFillOnlyInfo && !pDesc )
    1695             :         {
    1696           0 :             bDeleteInfo = sal_True;
    1697           0 :             ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1698           0 :             pDesc = lcl_FindPageDesc( rDoc, aName, this, sal_True );
    1699             :         }
    1700             : 
    1701        2770 :         if( pDesc )
    1702             :         {
    1703        2241 :             nPoolId = pDesc->GetPoolFmtId();
    1704        2241 :             nHelpId = pDesc->GetPoolHelpId();
    1705        2241 :             if( pDesc->GetPoolHlpFileId() != UCHAR_MAX )
    1706           0 :                 aHelpFile = *rDoc.GetDocPattern( pDesc->GetPoolHlpFileId() );
    1707             :             else
    1708        2241 :                 aHelpFile.Erase();
    1709             :         }
    1710         529 :         else if( !bCreate )
    1711         529 :             nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
    1712        2770 :         SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
    1713             : 
    1714        2770 :         bRet = 0 != pDesc || USHRT_MAX != nPoolId;
    1715        2770 :         if( bDeleteInfo )
    1716           0 :             pDesc = 0;
    1717        2770 :         break;
    1718             : 
    1719             :     case SFX_STYLE_FAMILY_PSEUDO:
    1720         456 :         pNumRule = lcl_FindNumRule(rDoc, aName, this, bCreate);
    1721         456 :         bPhysical = 0 != pNumRule;
    1722         456 :         if( bFillOnlyInfo && !pNumRule )
    1723             :         {
    1724           0 :             bDeleteInfo = sal_True;
    1725           0 :             ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1726           0 :             pNumRule = lcl_FindNumRule( rDoc, aName, this, sal_True );
    1727             :         }
    1728             : 
    1729         456 :         if( pNumRule )
    1730             :         {
    1731         242 :             nPoolId = pNumRule->GetPoolFmtId();
    1732         242 :             nHelpId = pNumRule->GetPoolHelpId();
    1733         242 :             if( pNumRule->GetPoolHlpFileId() != UCHAR_MAX )
    1734           0 :                 aHelpFile = *rDoc.GetDocPattern( pNumRule->GetPoolHlpFileId() );
    1735             :             else
    1736         242 :                 aHelpFile.Erase();
    1737             :         }
    1738         214 :         else if( !bCreate )
    1739         214 :             nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
    1740         456 :         SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
    1741             : 
    1742         456 :         bRet = 0 != pNumRule || USHRT_MAX != nPoolId;
    1743             : 
    1744         456 :         if( bDeleteInfo )
    1745           0 :             pNumRule = 0;
    1746         456 :         break;
    1747             :         default:; //prevent warning
    1748             :     }
    1749             : 
    1750       15426 :     if( SFX_STYLE_FAMILY_CHAR == nFamily ||
    1751             :         SFX_STYLE_FAMILY_PARA == nFamily ||
    1752             :         SFX_STYLE_FAMILY_FRAME == nFamily )
    1753             :     {
    1754       12200 :         if( pFmt )
    1755        8428 :             nPoolId = pFmt->GetPoolFmtId();
    1756             : 
    1757       12200 :         sal_uInt16 _nMask = 0;
    1758       12200 :         if( pFmt == rDoc.GetDfltCharFmt() )
    1759          25 :             _nMask |= SFXSTYLEBIT_READONLY;
    1760       12175 :         else if( USER_FMT & nPoolId )
    1761        3147 :             _nMask |= SFXSTYLEBIT_USERDEF;
    1762             : 
    1763       12200 :         switch ( COLL_GET_RANGE_BITS & nPoolId )
    1764             :         {
    1765        4440 :         case COLL_TEXT_BITS:     _nMask |= SWSTYLEBIT_TEXT;   break;
    1766          65 :         case COLL_DOC_BITS :     _nMask |= SWSTYLEBIT_CHAPTER; break;
    1767        1067 :         case COLL_LISTS_BITS:    _nMask |= SWSTYLEBIT_LIST;   break;
    1768        1125 :         case COLL_REGISTER_BITS: _nMask |= SWSTYLEBIT_IDX;    break;
    1769        1499 :         case COLL_EXTRA_BITS:    _nMask |= SWSTYLEBIT_EXTRA;      break;
    1770          50 :         case COLL_HTML_BITS:     _nMask |= SWSTYLEBIT_HTML;   break;
    1771             :         }
    1772             : 
    1773       12200 :         if( pFmt )
    1774             :         {
    1775             :             OSL_ENSURE( bPhysical, "Format not found" );
    1776             : 
    1777        8428 :             nHelpId = pFmt->GetPoolHelpId();
    1778        8428 :             if( pFmt->GetPoolHlpFileId() != UCHAR_MAX )
    1779           0 :                 aHelpFile = *rDoc.GetDocPattern( pFmt->GetPoolHlpFileId() );
    1780             :             else
    1781        8428 :                 aHelpFile.Erase();
    1782             : 
    1783        8428 :             if( RES_CONDTXTFMTCOLL == pFmt->Which() )
    1784         723 :                 _nMask |= SWSTYLEBIT_CONDCOLL;
    1785             :         }
    1786             : 
    1787       12200 :         SetMask( _nMask );
    1788             :     }
    1789       15426 :     if( bDeleteInfo && bFillOnlyInfo )
    1790           0 :         ::lcl_DeleteInfoStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
    1791       15426 :     return bRet;
    1792             : }
    1793             : 
    1794             : /*--------------------------------------------------------------------
    1795             :     Description:    Create new format in Core
    1796             :  --------------------------------------------------------------------*/
    1797             : 
    1798             : 
    1799         389 : void SwDocStyleSheet::Create()
    1800             : {
    1801         389 :     switch(nFamily)
    1802             :     {
    1803             :         case SFX_STYLE_FAMILY_CHAR :
    1804         197 :             pCharFmt = lcl_FindCharFmt( rDoc, aName );
    1805         197 :             if( !pCharFmt )
    1806             :                 pCharFmt = rDoc.MakeCharFmt(aName,
    1807         197 :                                             rDoc.GetDfltCharFmt());
    1808         197 :             pCharFmt->SetAuto( false );
    1809         197 :             break;
    1810             : 
    1811             :         case SFX_STYLE_FAMILY_PARA :
    1812          97 :             pColl = lcl_FindParaFmt( rDoc, aName );
    1813          97 :             if( !pColl )
    1814             :             {
    1815          97 :                 SwTxtFmtColl *pPar = (*rDoc.GetTxtFmtColls())[0];
    1816          97 :                 if( nMask & SWSTYLEBIT_CONDCOLL )
    1817           0 :                     pColl = rDoc.MakeCondTxtFmtColl( aName, pPar );
    1818             :                 else
    1819          97 :                     pColl = rDoc.MakeTxtFmtColl( aName, pPar );
    1820             :             }
    1821          97 :             break;
    1822             : 
    1823             :         case SFX_STYLE_FAMILY_FRAME:
    1824           0 :             pFrmFmt = lcl_FindFrmFmt( rDoc, aName );
    1825           0 :             if( !pFrmFmt )
    1826           0 :                 pFrmFmt = rDoc.MakeFrmFmt(aName, rDoc.GetDfltFrmFmt(), false, false);
    1827             : 
    1828           0 :             break;
    1829             : 
    1830             :         case SFX_STYLE_FAMILY_PAGE :
    1831          25 :             pDesc = lcl_FindPageDesc( rDoc, aName );
    1832          25 :             if( !pDesc )
    1833             :             {
    1834          25 :                 sal_uInt16 nId = rDoc.MakePageDesc(aName);
    1835          25 :                 pDesc = &rDoc.GetPageDesc(nId);
    1836             :             }
    1837          25 :             break;
    1838             : 
    1839             :         case SFX_STYLE_FAMILY_PSEUDO:
    1840          70 :             pNumRule = lcl_FindNumRule( rDoc, aName );
    1841          70 :             if( !pNumRule )
    1842             :             {
    1843          70 :                 String sTmpNm( aName );
    1844          70 :                 if( !aName.Len() )
    1845           0 :                     sTmpNm = rDoc.GetUniqueNumRuleName();
    1846             : 
    1847          70 :                 SwNumRule* pRule = rDoc.GetNumRuleTbl()[
    1848             :                     rDoc.MakeNumRule( sTmpNm, 0, false,
    1849             :                                       // #i89178#
    1850         140 :                                       numfunc::GetDefaultPositionAndSpaceMode() ) ];
    1851          70 :                 pRule->SetAutoRule( sal_False );
    1852          70 :                 if( !aName.Len() )
    1853             :                 {
    1854             :                     // #i91400#
    1855           0 :                     pRule->SetName( aName, rDoc );
    1856             :                 }
    1857          70 :                 pNumRule = pRule;
    1858             :             }
    1859          70 :             break;
    1860             :         default:; //prevent warning
    1861             :     }
    1862         389 :     bPhysical = sal_True;
    1863         389 :     aCoreSet.ClearItem();
    1864         389 : }
    1865             : 
    1866        1166 : SwCharFmt* SwDocStyleSheet::GetCharFmt()
    1867             : {
    1868        1166 :     if(!bPhysical)
    1869           8 :         FillStyleSheet( FillPhysical );
    1870        1166 :     return pCharFmt;
    1871             : }
    1872             : 
    1873        9318 : SwTxtFmtColl* SwDocStyleSheet::GetCollection()
    1874             : {
    1875        9318 :     if(!bPhysical)
    1876          91 :         FillStyleSheet( FillPhysical );
    1877        9318 :     return pColl;
    1878             : }
    1879             : 
    1880        2214 : const SwPageDesc* SwDocStyleSheet::GetPageDesc()
    1881             : {
    1882        2214 :     if(!bPhysical)
    1883           2 :         FillStyleSheet( FillPhysical );
    1884        2214 :     return pDesc;
    1885             : }
    1886             : 
    1887         319 : const SwNumRule * SwDocStyleSheet::GetNumRule()
    1888             : {
    1889         319 :     if(!bPhysical)
    1890           0 :         FillStyleSheet( FillPhysical );
    1891         319 :     return pNumRule;
    1892             : }
    1893             : 
    1894          72 : void SwDocStyleSheet::SetNumRule(const SwNumRule& rRule)
    1895             : {
    1896             :     OSL_ENSURE(pNumRule, "Wo ist die NumRule");
    1897          72 :     rDoc.ChgNumRuleFmts( rRule );
    1898          72 : }
    1899             : 
    1900             : // re-generate Name AND Family from String
    1901             : // First() and Next() (see below) insert an identification letter at Pos.1
    1902             : 
    1903        1549 : void SwDocStyleSheet::PresetNameAndFamily(const String& rName)
    1904             : {
    1905        1549 :     switch( rName.GetChar(0) )
    1906             :     {
    1907         400 :         case cPARA:     nFamily = SFX_STYLE_FAMILY_PARA; break;
    1908          19 :         case cFRAME:    nFamily = SFX_STYLE_FAMILY_FRAME; break;
    1909         261 :         case cPAGE:     nFamily = SFX_STYLE_FAMILY_PAGE; break;
    1910           8 :         case cNUMRULE:  nFamily = SFX_STYLE_FAMILY_PSEUDO; break;
    1911         861 :         default:        nFamily = SFX_STYLE_FAMILY_CHAR; break;
    1912             :     }
    1913        1549 :     aName = rName;
    1914        1549 :     aName.Erase( 0, 1 );
    1915        1549 : }
    1916             : 
    1917             : /*--------------------------------------------------------------------
    1918             :     Description:    Is the format physically present yet
    1919             :  --------------------------------------------------------------------*/
    1920             : 
    1921             : 
    1922       31550 : void SwDocStyleSheet::SetPhysical(sal_Bool bPhys)
    1923             : {
    1924       31550 :     bPhysical = bPhys;
    1925             : 
    1926       31550 :     if(!bPhys)
    1927             :     {
    1928       20250 :         pCharFmt = 0;
    1929       20250 :         pColl    = 0;
    1930       20250 :         pFrmFmt  = 0;
    1931       20250 :         pDesc    = 0;
    1932             :     }
    1933       31550 : }
    1934             : 
    1935          63 : SwFrmFmt* SwDocStyleSheet::GetFrmFmt()
    1936             : {
    1937          63 :     if(!bPhysical)
    1938           3 :         FillStyleSheet( FillPhysical );
    1939          63 :     return pFrmFmt;
    1940             : }
    1941             : 
    1942           0 : bool  SwDocStyleSheet::IsUsed() const
    1943             : {
    1944           0 :     if( !bPhysical )
    1945             :     {
    1946           0 :         SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
    1947           0 :         pThis->FillStyleSheet( FillOnlyName );
    1948             :     }
    1949             : 
    1950           0 :     if( !bPhysical )
    1951           0 :         return false;
    1952             : 
    1953             :     const SwModify* pMod;
    1954           0 :     switch( nFamily )
    1955             :     {
    1956           0 :     case SFX_STYLE_FAMILY_CHAR : pMod = pCharFmt;   break;
    1957           0 :     case SFX_STYLE_FAMILY_PARA : pMod = pColl;      break;
    1958           0 :     case SFX_STYLE_FAMILY_FRAME: pMod = pFrmFmt;    break;
    1959           0 :     case SFX_STYLE_FAMILY_PAGE : pMod = pDesc;      break;
    1960             : 
    1961             :     case SFX_STYLE_FAMILY_PSEUDO:
    1962           0 :             return pNumRule ? rDoc.IsUsed( *pNumRule ) : false;
    1963             : 
    1964             :     default:
    1965             :         OSL_ENSURE(!this, "unknown style family");
    1966           0 :         return false;
    1967             :     }
    1968           0 :     return rDoc.IsUsed( *pMod );
    1969             : }
    1970             : 
    1971             : 
    1972           0 : sal_uLong  SwDocStyleSheet::GetHelpId( String& rFile )
    1973             : {
    1974           0 :     sal_uInt16 nId = 0;
    1975           0 :     sal_uInt16 nPoolId = 0;
    1976           0 :     unsigned char nFileId = UCHAR_MAX;
    1977             : 
    1978           0 :     rFile = rtl::OUString("swrhlppi.hlp");
    1979             : 
    1980           0 :     const SwFmt* pTmpFmt = 0;
    1981           0 :     switch( nFamily )
    1982             :     {
    1983             :     case SFX_STYLE_FAMILY_CHAR :
    1984           0 :         if( !pCharFmt &&
    1985           0 :             0 == (pCharFmt = lcl_FindCharFmt( rDoc, aName, 0, sal_False )) )
    1986             :         {
    1987           0 :             nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
    1988           0 :             return USHRT_MAX == nId ? 0 : nId;
    1989             :         }
    1990           0 :         pTmpFmt = pCharFmt;
    1991           0 :         break;
    1992             : 
    1993             :     case SFX_STYLE_FAMILY_PARA:
    1994           0 :         if( !pColl &&
    1995           0 :             0 == ( pColl = lcl_FindParaFmt( rDoc, aName, 0, sal_False )) )
    1996             :         {
    1997           0 :             nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
    1998           0 :             return USHRT_MAX == nId ? 0 : nId;
    1999             :         }
    2000           0 :         pTmpFmt = pColl;
    2001           0 :         break;
    2002             : 
    2003             :     case SFX_STYLE_FAMILY_FRAME:
    2004           0 :         if( !pFrmFmt &&
    2005           0 :             0 == ( pFrmFmt = lcl_FindFrmFmt( rDoc, aName, 0, sal_False ) ) )
    2006             :         {
    2007           0 :             nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
    2008           0 :             return USHRT_MAX == nId ? 0 : nId;
    2009             :         }
    2010           0 :         pTmpFmt = pFrmFmt;
    2011           0 :         break;
    2012             : 
    2013             :     case SFX_STYLE_FAMILY_PAGE:
    2014           0 :         if( !pDesc &&
    2015           0 :             0 == ( pDesc = lcl_FindPageDesc( rDoc, aName, 0, sal_False ) ) )
    2016             :         {
    2017           0 :             nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
    2018           0 :             return USHRT_MAX == nId ? 0 : nId;
    2019             :         }
    2020             : 
    2021           0 :         nId = pDesc->GetPoolHelpId();
    2022           0 :         nFileId = pDesc->GetPoolHlpFileId();
    2023           0 :         nPoolId = pDesc->GetPoolFmtId();
    2024           0 :         break;
    2025             : 
    2026             :     case SFX_STYLE_FAMILY_PSEUDO:
    2027           0 :         if( !pNumRule &&
    2028           0 :             0 == ( pNumRule = lcl_FindNumRule( rDoc, aName, 0, sal_False ) ) )
    2029             :         {
    2030           0 :             nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
    2031           0 :             return USHRT_MAX == nId ? 0 : nId;
    2032             :         }
    2033             : 
    2034           0 :         nId = pNumRule->GetPoolHelpId();
    2035           0 :         nFileId = pNumRule->GetPoolHlpFileId();
    2036           0 :         nPoolId = pNumRule->GetPoolFmtId();
    2037           0 :         break;
    2038             : 
    2039             :     default:
    2040             :         OSL_ENSURE(!this, "unknown style family");
    2041           0 :         return 0;
    2042             :     }
    2043             : 
    2044           0 :     if( pTmpFmt )
    2045             :     {
    2046           0 :         nId = pTmpFmt->GetPoolHelpId();
    2047           0 :         nFileId = pTmpFmt->GetPoolHlpFileId();
    2048           0 :         nPoolId = pTmpFmt->GetPoolFmtId();
    2049             :     }
    2050             : 
    2051           0 :     if( UCHAR_MAX != nFileId )
    2052             :     {
    2053           0 :         const String *pTemplate = rDoc.GetDocPattern( nFileId );
    2054           0 :         if( pTemplate )
    2055             :         {
    2056           0 :             rFile = *pTemplate;
    2057             :         }
    2058             :     }
    2059           0 :     else if( !IsPoolUserFmt( nPoolId ) )
    2060             :     {
    2061           0 :         nId = nPoolId;
    2062             :     }
    2063             : 
    2064             :     // because SFX acts like that, with HelpId:
    2065           0 :     if( USHRT_MAX == nId )
    2066           0 :         nId = 0;        // don't show Help accordingly
    2067             : 
    2068           0 :     return nId;
    2069             : }
    2070             : 
    2071             : 
    2072           0 : void  SwDocStyleSheet::SetHelpId( const String& r, sal_uLong nId )
    2073             : {
    2074           0 :     sal_uInt8 nFileId = static_cast< sal_uInt8 >(rDoc.SetDocPattern( r ));
    2075           0 :     sal_uInt16 nHId = static_cast< sal_uInt16 >(nId); //!! SFX changed over to ULONG arbitrarily!
    2076             : 
    2077           0 :     SwFmt* pTmpFmt = 0;
    2078           0 :     switch( nFamily )
    2079             :     {
    2080           0 :     case SFX_STYLE_FAMILY_CHAR : pTmpFmt = pCharFmt;    break;
    2081           0 :     case SFX_STYLE_FAMILY_PARA : pTmpFmt = pColl;       break;
    2082           0 :     case SFX_STYLE_FAMILY_FRAME: pTmpFmt = pFrmFmt;     break;
    2083             :     case SFX_STYLE_FAMILY_PAGE :
    2084           0 :         ((SwPageDesc*)pDesc)->SetPoolHelpId( nHId );
    2085           0 :         ((SwPageDesc*)pDesc)->SetPoolHlpFileId( nFileId );
    2086           0 :         break;
    2087             : 
    2088             :     case SFX_STYLE_FAMILY_PSEUDO:
    2089           0 :         ((SwNumRule*)pNumRule)->SetPoolHelpId( nHId );
    2090           0 :         ((SwNumRule*)pNumRule)->SetPoolHlpFileId( nFileId );
    2091           0 :         break;
    2092             : 
    2093             :     default:
    2094             :         OSL_ENSURE(!this, "unknown style family");
    2095           0 :         return ;
    2096             :     }
    2097           0 :     if( pTmpFmt )
    2098             :     {
    2099           0 :         pTmpFmt->SetPoolHelpId( nHId );
    2100           0 :         pTmpFmt->SetPoolHlpFileId( nFileId );
    2101             :     }
    2102             : }
    2103             : 
    2104             : /*--------------------------------------------------------------------
    2105             :     Description:    methods for DocStyleSheetPool
    2106             :  --------------------------------------------------------------------*/
    2107             : 
    2108         275 : SwDocStyleSheetPool::SwDocStyleSheetPool( SwDoc& rDocument, sal_Bool bOrg )
    2109         275 : : SfxStyleSheetBasePool( rDocument.GetAttrPool() )
    2110         275 : , mxStyleSheet( new SwDocStyleSheet( rDocument, aEmptyStr, this, SFX_STYLE_FAMILY_CHAR, 0 ) )
    2111         550 : , rDoc( rDocument )
    2112             : {
    2113         275 :     bOrganizer = bOrg;
    2114         275 : }
    2115             : 
    2116         188 :  SwDocStyleSheetPool::~SwDocStyleSheetPool()
    2117             : {
    2118         188 : }
    2119             : 
    2120         275 : void SAL_CALL SwDocStyleSheetPool::acquire(  ) throw ()
    2121             : {
    2122         275 :     comphelper::OWeakTypeObject::acquire();
    2123         275 : }
    2124             : 
    2125          94 : void SAL_CALL SwDocStyleSheetPool::release(  ) throw ()
    2126             : {
    2127          94 :     comphelper::OWeakTypeObject::release();
    2128          94 : }
    2129             : 
    2130         389 : SfxStyleSheetBase&   SwDocStyleSheetPool::Make(
    2131             :         const String&   rName,
    2132             :         SfxStyleFamily  eFam,
    2133             :         sal_uInt16          _nMask,
    2134             :         sal_uInt16          /*nPos*/ )
    2135             : {
    2136         389 :     mxStyleSheet->PresetName(rName);
    2137         389 :     mxStyleSheet->PresetParent(aEmptyStr);
    2138         389 :     mxStyleSheet->PresetFollow(aEmptyStr);
    2139         389 :     mxStyleSheet->SetMask(_nMask) ;
    2140         389 :     mxStyleSheet->SetFamily(eFam);
    2141         389 :     mxStyleSheet->SetPhysical(sal_True);
    2142         389 :     mxStyleSheet->Create();
    2143             : 
    2144         389 :     return *mxStyleSheet.get();
    2145             : }
    2146             : 
    2147             : 
    2148           0 : SfxStyleSheetBase*   SwDocStyleSheetPool::Create( const SfxStyleSheetBase& /*rOrg*/)
    2149             : {
    2150             :     OSL_ENSURE(!this , "Create im SW-Stylesheet-Pool geht nicht" );
    2151           0 :     return NULL;
    2152             : }
    2153             : 
    2154             : 
    2155           0 : SfxStyleSheetBase*   SwDocStyleSheetPool::Create( const String &,
    2156             :                                                 SfxStyleFamily, sal_uInt16 )
    2157             : {
    2158             :     OSL_ENSURE( !this, "Create im SW-Stylesheet-Pool geht nicht" );
    2159           0 :     return NULL;
    2160             : }
    2161             : 
    2162           0 : void  SwDocStyleSheetPool::Replace( SfxStyleSheetBase& rSource,
    2163             :                                             SfxStyleSheetBase& rTarget )
    2164             : {
    2165           0 :     SfxStyleFamily eFamily( rSource.GetFamily() );
    2166           0 :     if( rSource.HasParentSupport())
    2167             :     {
    2168           0 :         const String& rParentName = rSource.GetParent();
    2169           0 :         if( 0 != rParentName.Len() )
    2170             :         {
    2171           0 :             SfxStyleSheetBase* pParentOfNew = Find( rParentName, eFamily );
    2172           0 :             if( pParentOfNew )
    2173           0 :                 rTarget.SetParent( rParentName );
    2174             :         }
    2175             :     }
    2176           0 :     if( rSource.HasFollowSupport())
    2177             :     {
    2178           0 :         const String& rFollowName = rSource.GetFollow();
    2179           0 :         if( 0 != rFollowName.Len() )
    2180             :         {
    2181           0 :             SfxStyleSheetBase* pFollowOfNew = Find( rFollowName, eFamily );
    2182           0 :             if( pFollowOfNew )
    2183           0 :                 rTarget.SetFollow( rFollowName );
    2184             :         }
    2185             :     }
    2186             : 
    2187           0 :     SwImplShellAction aTmpSh( rDoc );
    2188             : 
    2189           0 :     sal_Bool bSwSrcPool = GetAppName() == rSource.GetPool().GetAppName();
    2190           0 :     if( SFX_STYLE_FAMILY_PAGE == eFamily && bSwSrcPool )
    2191             :     {
    2192             :         // deal with separately!
    2193             :         SwPageDesc* pDestDsc =
    2194           0 :             (SwPageDesc*)((SwDocStyleSheet&)rTarget).GetPageDesc();
    2195             :         SwPageDesc* pCpyDsc =
    2196           0 :             (SwPageDesc*)((SwDocStyleSheet&)rSource).GetPageDesc();
    2197           0 :         rDoc.CopyPageDesc( *pCpyDsc, *pDestDsc );
    2198             :     }
    2199             :     else
    2200             :     {
    2201           0 :         const SwFmt *pSourceFmt = 0;
    2202           0 :         SwFmt *pTargetFmt = 0;
    2203           0 :         sal_uInt16 nPgDscPos = USHRT_MAX;
    2204           0 :         switch( eFamily )
    2205             :         {
    2206             :         case SFX_STYLE_FAMILY_CHAR :
    2207           0 :             if( bSwSrcPool )
    2208           0 :                 pSourceFmt = ((SwDocStyleSheet&)rSource).GetCharFmt();
    2209           0 :             pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCharFmt();
    2210           0 :             break;
    2211             :         case SFX_STYLE_FAMILY_PARA :
    2212           0 :             if( bSwSrcPool )
    2213           0 :                 pSourceFmt = ((SwDocStyleSheet&)rSource).GetCollection();
    2214           0 :             pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCollection();
    2215           0 :             break;
    2216             :         case SFX_STYLE_FAMILY_FRAME:
    2217           0 :             if( bSwSrcPool )
    2218           0 :                 pSourceFmt = ((SwDocStyleSheet&)rSource).GetFrmFmt();
    2219           0 :             pTargetFmt = ((SwDocStyleSheet&)rTarget).GetFrmFmt();
    2220           0 :             break;
    2221             :         case SFX_STYLE_FAMILY_PAGE:
    2222           0 :             if( bSwSrcPool )
    2223             :                 pSourceFmt = &((SwDocStyleSheet&)rSource).GetPageDesc()
    2224           0 :                                 ->GetMaster();
    2225             :             {
    2226             :                 SwPageDesc *pDesc = rDoc.FindPageDescByName(
    2227           0 :                     ((SwDocStyleSheet&)rTarget).GetPageDesc()->GetName(),
    2228           0 :                     &nPgDscPos );
    2229             : 
    2230           0 :                 if( pDesc )
    2231           0 :                     pTargetFmt = &pDesc->GetMaster();
    2232             :             }
    2233           0 :             break;
    2234             :         case SFX_STYLE_FAMILY_PSEUDO:
    2235             :             // A NumRule only consists of one Item, so nothing has
    2236             :             // to be deleted here.
    2237           0 :             break;
    2238             :         default:; //prevent warning
    2239             :         }
    2240           0 :         if( pTargetFmt )
    2241             :         {
    2242           0 :             if( pSourceFmt )
    2243           0 :                 pTargetFmt->DelDiffs( *pSourceFmt );
    2244           0 :             else if( USHRT_MAX != nPgDscPos )
    2245           0 :                 pTargetFmt->ResetFmtAttr( RES_PAGEDESC, RES_FRMATR_END-1 );
    2246             :             else
    2247             :             {
    2248             :                 // #i73790# - method renamed
    2249           0 :                 pTargetFmt->ResetAllFmtAttr();
    2250             :             }
    2251             : 
    2252           0 :             if( USHRT_MAX != nPgDscPos )
    2253             :                 rDoc.ChgPageDesc( nPgDscPos,
    2254           0 :                                   rDoc.GetPageDesc(nPgDscPos) );
    2255             :         }
    2256           0 :         ((SwDocStyleSheet&)rTarget).SetItemSet( rSource.GetItemSet() );
    2257           0 :     }
    2258           0 : }
    2259             : 
    2260          89 : SfxStyleSheetIterator*  SwDocStyleSheetPool::CreateIterator(
    2261             :                         SfxStyleFamily eFam, sal_uInt16 _nMask )
    2262             : {
    2263          89 :     return new SwStyleSheetIterator( this, eFam, _nMask );
    2264             : }
    2265             : 
    2266          94 : void SwDocStyleSheetPool::dispose()
    2267             : {
    2268          94 :     mxStyleSheet.clear();
    2269          94 : }
    2270             : 
    2271           0 : void SwDocStyleSheetPool::Remove( SfxStyleSheetBase* pStyle)
    2272             : {
    2273           0 :     if( !pStyle )
    2274           0 :         return;
    2275             : 
    2276           0 :     sal_Bool bBroadcast = sal_True;
    2277           0 :     SwImplShellAction aTmpSh( rDoc );
    2278           0 :     const String& rName = pStyle->GetName();
    2279           0 :     switch( pStyle->GetFamily() )
    2280             :     {
    2281             :     case SFX_STYLE_FAMILY_CHAR:
    2282             :         {
    2283           0 :             SwCharFmt* pFmt = lcl_FindCharFmt(rDoc, rName, 0, sal_False );
    2284           0 :             if(pFmt)
    2285           0 :                 rDoc.DelCharFmt(pFmt);
    2286             :         }
    2287           0 :         break;
    2288             :     case SFX_STYLE_FAMILY_PARA:
    2289             :         {
    2290           0 :             SwTxtFmtColl* pColl = lcl_FindParaFmt(rDoc, rName, 0, sal_False );
    2291           0 :             if(pColl)
    2292           0 :                 rDoc.DelTxtFmtColl(pColl);
    2293             :         }
    2294           0 :         break;
    2295             :     case SFX_STYLE_FAMILY_FRAME:
    2296             :         {
    2297           0 :             SwFrmFmt* pFmt = lcl_FindFrmFmt(rDoc, rName, 0, sal_False );
    2298           0 :             if(pFmt)
    2299           0 :                 rDoc.DelFrmFmt(pFmt);
    2300             :         }
    2301           0 :         break;
    2302             :     case SFX_STYLE_FAMILY_PAGE :
    2303             :         {
    2304             :             sal_uInt16 nPos;
    2305           0 :             if( rDoc.FindPageDescByName( rName, &nPos ))
    2306           0 :                 rDoc.DelPageDesc( nPos );
    2307             :         }
    2308           0 :         break;
    2309             : 
    2310             :     case SFX_STYLE_FAMILY_PSEUDO:
    2311             :         {
    2312           0 :             if( !rDoc.DelNumRule( rName ) )
    2313             :                 // Only send Broadcast, when something was deleted
    2314           0 :                 bBroadcast = sal_False;
    2315             :         }
    2316           0 :         break;
    2317             : 
    2318             :     default:
    2319             :         OSL_ENSURE(!this, "unknown style family");
    2320           0 :         bBroadcast = sal_False;
    2321             :     }
    2322             : 
    2323           0 :     if( bBroadcast )
    2324           0 :         Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_ERASED, *pStyle ) );
    2325             : }
    2326             : 
    2327             : 
    2328             : 
    2329         162 : bool  SwDocStyleSheetPool::SetParent( SfxStyleFamily eFam,
    2330             :                                 const String &rStyle, const String &rParent )
    2331             : {
    2332         162 :     SwFmt* pFmt = 0, *pParent = 0;
    2333         162 :     switch( eFam )
    2334             :     {
    2335             :     case SFX_STYLE_FAMILY_CHAR :
    2336         102 :         if( 0 != ( pFmt = lcl_FindCharFmt( rDoc, rStyle ) ) && rParent.Len() )
    2337         102 :             pParent = lcl_FindCharFmt(rDoc, rParent );
    2338         102 :         break;
    2339             : 
    2340             :     case SFX_STYLE_FAMILY_PARA :
    2341          60 :         if( 0 != ( pFmt = lcl_FindParaFmt( rDoc, rStyle ) ) && rParent.Len() )
    2342          60 :             pParent = lcl_FindParaFmt( rDoc, rParent );
    2343          60 :         break;
    2344             : 
    2345             :     case SFX_STYLE_FAMILY_FRAME:
    2346           0 :         if( 0 != ( pFmt = lcl_FindFrmFmt( rDoc, rStyle ) ) && rParent.Len() )
    2347           0 :             pParent = lcl_FindFrmFmt( rDoc, rParent );
    2348           0 :         break;
    2349             : 
    2350             :     case SFX_STYLE_FAMILY_PAGE:
    2351             :     case SFX_STYLE_FAMILY_PSEUDO:
    2352           0 :         break;
    2353             : 
    2354             :     default:
    2355             :         OSL_ENSURE(!this, "unknown style family");
    2356             :     }
    2357             : 
    2358         162 :     bool bRet = false;
    2359         324 :     if( pFmt && pFmt->DerivedFrom() &&
    2360         162 :         pFmt->DerivedFrom()->GetName() != rParent )
    2361             :     {
    2362             :         {
    2363         162 :             SwImplShellAction aTmpSh( rDoc );
    2364         162 :             bRet = pFmt->SetDerivedFrom( pParent );
    2365             :         }
    2366             : 
    2367         162 :         if( bRet )
    2368             :         {
    2369             :             // only for Broadcasting
    2370         162 :             mxStyleSheet->PresetName( rStyle );
    2371         162 :             mxStyleSheet->PresetParent( rParent );
    2372         162 :             if( SFX_STYLE_FAMILY_PARA == eFam )
    2373             :                 mxStyleSheet->PresetFollow( ((SwTxtFmtColl*)pFmt)->
    2374          60 :                         GetNextTxtFmtColl().GetName() );
    2375             :             else
    2376         102 :                 mxStyleSheet->PresetFollow( aEmptyStr );
    2377             : 
    2378             :             Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
    2379         162 :                                             *(mxStyleSheet.get()) ) );
    2380             :         }
    2381             :     }
    2382             : 
    2383         162 :     return bRet;
    2384             : }
    2385             : 
    2386       13924 : SfxStyleSheetBase* SwDocStyleSheetPool::Find( const String& rName,
    2387             :                                             SfxStyleFamily eFam, sal_uInt16 n )
    2388             : {
    2389       13924 :     sal_uInt16 nSMask = n;
    2390       13924 :     if( SFX_STYLE_FAMILY_PARA == eFam && rDoc.get(IDocumentSettingAccess::HTML_MODE) )
    2391             :     {
    2392             :         // then only HTML-Templates are of interest
    2393           0 :         if( USHRT_MAX == nSMask )
    2394           0 :             nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF | SFXSTYLEBIT_USED;
    2395             :         else
    2396             :             nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
    2397           0 :                                 SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
    2398           0 :         if( !nSMask )
    2399           0 :             nSMask = SWSTYLEBIT_HTML;
    2400             :     }
    2401             : 
    2402             :     const sal_Bool bSearchUsed = ( n != SFXSTYLEBIT_ALL &&
    2403       13924 :                              n & SFXSTYLEBIT_USED ) ? sal_True : sal_False;
    2404       13924 :     const SwModify* pMod = 0;
    2405             : 
    2406       13924 :     mxStyleSheet->SetPhysical( sal_False );
    2407       13924 :     mxStyleSheet->PresetName( rName );
    2408       13924 :     mxStyleSheet->SetFamily( eFam );
    2409       13924 :     sal_Bool bFnd = mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
    2410             : 
    2411       13924 :     if( mxStyleSheet->IsPhysical() )
    2412             :     {
    2413       10295 :         switch( eFam )
    2414             :         {
    2415             :         case SFX_STYLE_FAMILY_CHAR:
    2416        1117 :             pMod = mxStyleSheet->GetCharFmt();
    2417        1117 :             break;
    2418             : 
    2419             :         case SFX_STYLE_FAMILY_PARA:
    2420        6699 :             pMod = mxStyleSheet->GetCollection();
    2421        6699 :             break;
    2422             : 
    2423             :         case SFX_STYLE_FAMILY_FRAME:
    2424          53 :             pMod = mxStyleSheet->GetFrmFmt();
    2425          53 :             break;
    2426             : 
    2427             :         case SFX_STYLE_FAMILY_PAGE:
    2428        2186 :             pMod = mxStyleSheet->GetPageDesc();
    2429        2186 :             break;
    2430             : 
    2431             :         case SFX_STYLE_FAMILY_PSEUDO:
    2432             :             {
    2433         240 :                 const SwNumRule* pRule = mxStyleSheet->GetNumRule();
    2434         240 :                 if( pRule &&
    2435             :                     !bSearchUsed &&
    2436             :                     (( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2437           0 :                             ? !(pRule->GetPoolFmtId() & USER_FMT)
    2438             :                                 // searched for used and found none
    2439         240 :                             : bSearchUsed ))
    2440           0 :                     bFnd = sal_False;
    2441             :             }
    2442         240 :             break;
    2443             : 
    2444             :         default:
    2445             :             OSL_ENSURE(!this, "unknown style family");
    2446             :         }
    2447             :     }
    2448             : 
    2449             :     // then evaluate the mask:
    2450       13924 :     if( pMod && !bSearchUsed )
    2451             :     {
    2452             :         const sal_uInt16 nId = SFX_STYLE_FAMILY_PAGE == eFam
    2453             :                         ? ((SwPageDesc*)pMod)->GetPoolFmtId()
    2454       10055 :                         : ((SwFmt*)pMod)->GetPoolFmtId();
    2455             : 
    2456       10055 :         if( ( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2457             :             ? !(nId & USER_FMT)
    2458             :                 // searched for used and found none
    2459       10055 :             : bSearchUsed )
    2460           0 :             bFnd = sal_False;
    2461             :     }
    2462       13924 :     return bFnd ? mxStyleSheet.get() : 0;
    2463             : }
    2464             : 
    2465          89 : SwStyleSheetIterator::SwStyleSheetIterator( SwDocStyleSheetPool* pBase,
    2466             :                                 SfxStyleFamily eFam, sal_uInt16 n )
    2467             :     : SfxStyleSheetIterator( pBase, eFam, n ),
    2468          89 :     mxIterSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, pBase, SFX_STYLE_FAMILY_CHAR, 0 ) ),
    2469         178 :     mxStyleSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, pBase, SFX_STYLE_FAMILY_CHAR, 0 ) )
    2470             : {
    2471          89 :     bFirstCalled = sal_False;
    2472          89 :     nLastPos = 0;
    2473          89 :     StartListening( *pBase );
    2474          89 : }
    2475             : 
    2476         255 : SwStyleSheetIterator::~SwStyleSheetIterator()
    2477             : {
    2478          85 :     EndListening( mxIterSheet->GetPool() );
    2479         170 : }
    2480             : 
    2481          43 : sal_uInt16  SwStyleSheetIterator::Count()
    2482             : {
    2483             :     // let the list fill correctly!!
    2484          43 :     if( !bFirstCalled )
    2485          43 :         First();
    2486          43 :     return aLst.size();
    2487             : }
    2488             : 
    2489        1287 : SfxStyleSheetBase*  SwStyleSheetIterator::operator[]( sal_uInt16 nIdx )
    2490             : {
    2491             :     // found
    2492        1287 :     if( !bFirstCalled )
    2493           0 :         First();
    2494        1287 :     mxStyleSheet->PresetNameAndFamily( aLst[ nIdx ] );
    2495        1287 :     mxStyleSheet->SetPhysical( sal_False );
    2496        1287 :     mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
    2497             : 
    2498        1287 :     return mxStyleSheet.get();
    2499             : }
    2500             : 
    2501         262 : SfxStyleSheetBase*  SwStyleSheetIterator::First()
    2502             : {
    2503             :     // Delete old list
    2504         262 :     bFirstCalled = sal_True;
    2505         262 :     nLastPos = 0;
    2506         262 :     aLst.Erase();
    2507             : 
    2508             :     // Delete current
    2509         262 :     mxIterSheet->Reset();
    2510             : 
    2511         262 :     SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
    2512         262 :     const sal_uInt16 nSrchMask = nMask;
    2513         262 :     const sal_Bool bIsSearchUsed = SearchUsed();
    2514             : 
    2515         262 :     bool bSearchHidden = ( nMask & SFXSTYLEBIT_HIDDEN );
    2516         262 :     bool bOnlyHidden = nMask == SFXSTYLEBIT_HIDDEN;
    2517             : 
    2518         262 :     const sal_Bool bOrganizer = ((SwDocStyleSheetPool*)pBasePool)->IsOrganizerMode();
    2519         262 :     bool bAll = ( nSrchMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
    2520             : 
    2521         262 :     if( nSearchFamily == SFX_STYLE_FAMILY_CHAR
    2522             :      || nSearchFamily == SFX_STYLE_FAMILY_ALL )
    2523             :     {
    2524          48 :         const sal_uInt16 nArrLen = rDoc.GetCharFmts()->size();
    2525         595 :         for( sal_uInt16 i = 0; i < nArrLen; i++ )
    2526             :         {
    2527         547 :             SwCharFmt* pFmt = (*rDoc.GetCharFmts())[ i ];
    2528             : 
    2529         547 :             const bool bUsed = bIsSearchUsed && (bOrganizer || rDoc.IsUsed(*pFmt));
    2530         547 :             if( ( !bSearchHidden && pFmt->IsHidden() && !bUsed ) || ( pFmt->IsDefault() && pFmt != rDoc.GetDfltCharFmt() ) )
    2531           0 :                 continue;
    2532             : 
    2533         547 :             if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFmt->IsHidden( ) )
    2534           0 :                 continue;
    2535             : 
    2536         547 :             if( !bUsed )
    2537             :             {
    2538             :                 // Standard is no User template
    2539         547 :                 const sal_uInt16 nId = rDoc.GetDfltCharFmt() == pFmt ?
    2540             :                         sal_uInt16( RES_POOLCHR_INET_NORMAL ):
    2541         547 :                                 pFmt->GetPoolFmtId();
    2542         547 :                 if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2543             :                     ? !(nId & USER_FMT)
    2544             :                         // searched for used and found none
    2545         547 :                     : bIsSearchUsed )
    2546             :                 {
    2547           0 :                     continue;
    2548             :                 }
    2549             : 
    2550         547 :                 if( rDoc.get(IDocumentSettingAccess::HTML_MODE) && !(nId & USER_FMT) &&
    2551             :                     !( RES_POOLCHR_HTML_BEGIN <= nId &&
    2552           0 :                           nId < RES_POOLCHR_HTML_END ) &&
    2553             :                     RES_POOLCHR_INET_NORMAL != nId &&
    2554             :                     RES_POOLCHR_INET_VISIT != nId &&
    2555             :                     RES_POOLCHR_FOOTNOTE  != nId &&
    2556             :                     RES_POOLCHR_ENDNOTE != nId )
    2557           0 :                     continue;
    2558             :             }
    2559             : 
    2560         547 :             aLst.Append( cCHAR, pFmt == rDoc.GetDfltCharFmt()
    2561          48 :                         ? SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
    2562          48 :                                                 RES_POOLCOLL_TEXT_BEGIN ]
    2563         595 :                         : pFmt->GetName() );
    2564             :         }
    2565             : 
    2566             :         // PoolFormate
    2567             :         //
    2568          48 :         if( bAll )
    2569             :         {
    2570          48 :             if( !rDoc.get(IDocumentSettingAccess::HTML_MODE) )
    2571          48 :                 AppendStyleList(SwStyleNameMapper::GetChrFmtUINameArray(),
    2572             :                                 bIsSearchUsed, bSearchHidden, bOnlyHidden,
    2573          96 :                                 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
    2574             :             else
    2575             :             {
    2576           0 :                 aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
    2577           0 :                         RES_POOLCHR_INET_NORMAL - RES_POOLCHR_BEGIN ] );
    2578           0 :                 aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
    2579           0 :                         RES_POOLCHR_INET_VISIT - RES_POOLCHR_BEGIN ] );
    2580           0 :                 aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
    2581           0 :                         RES_POOLCHR_ENDNOTE - RES_POOLCHR_BEGIN ] );
    2582           0 :                 aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
    2583           0 :                         RES_POOLCHR_FOOTNOTE - RES_POOLCHR_BEGIN ] );
    2584             :             }
    2585          48 :             AppendStyleList(SwStyleNameMapper::GetHTMLChrFmtUINameArray(),
    2586             :                                 bIsSearchUsed, bSearchHidden, bOnlyHidden,
    2587          96 :                                 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
    2588             :         }
    2589             :     }
    2590             : 
    2591         262 :     if( nSearchFamily == SFX_STYLE_FAMILY_PARA ||
    2592             :         nSearchFamily == SFX_STYLE_FAMILY_ALL )
    2593             :     {
    2594         153 :         sal_uInt16 nSMask = nSrchMask;
    2595         153 :         if( rDoc.get(IDocumentSettingAccess::HTML_MODE) )
    2596             :         {
    2597             :             // then only HTML-Template are of interest
    2598           0 :             if( SFXSTYLEBIT_ALL_VISIBLE == ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) )
    2599             :                 nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF |
    2600           0 :                             SFXSTYLEBIT_USED;
    2601             :             else
    2602             :                 nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
    2603           0 :                                 SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
    2604           0 :             if( !nSMask )
    2605           0 :                 nSMask = SWSTYLEBIT_HTML;
    2606             :         }
    2607             : 
    2608         153 :         const sal_uInt16 nArrLen = rDoc.GetTxtFmtColls()->size();
    2609        2232 :         for( sal_uInt16 i = 0; i < nArrLen; i++ )
    2610             :         {
    2611        2079 :             SwTxtFmtColl* pColl = (*rDoc.GetTxtFmtColls())[ i ];
    2612             : 
    2613        2079 :             const bool bUsed = bOrganizer || rDoc.IsUsed(*pColl);
    2614        2079 :             if ( ( !bSearchHidden && pColl->IsHidden( ) && !bUsed ) || pColl->IsDefault() )
    2615         153 :                 continue;
    2616             : 
    2617        1926 :             if ( nSMask == SFXSTYLEBIT_HIDDEN && !pColl->IsHidden( ) )
    2618           0 :                 continue;
    2619             : 
    2620        1926 :             if( !(bIsSearchUsed && bUsed ))
    2621             :             {
    2622        1926 :                 const sal_uInt16 nId = pColl->GetPoolFmtId();
    2623        1926 :                 switch ( (nSMask & ~SFXSTYLEBIT_USED) )
    2624             :                 {
    2625             :                 case SFXSTYLEBIT_USERDEF:
    2626           0 :                     if(!IsPoolUserFmt(nId)) continue;
    2627           0 :                     break;
    2628             :                 case SWSTYLEBIT_TEXT:
    2629           0 :                     if((nId & COLL_GET_RANGE_BITS) != COLL_TEXT_BITS) continue;
    2630           0 :                     break;
    2631             :                 case SWSTYLEBIT_CHAPTER:
    2632           0 :                     if((nId  & COLL_GET_RANGE_BITS) != COLL_DOC_BITS) continue;
    2633           0 :                     break;
    2634             :                 case SWSTYLEBIT_LIST:
    2635           0 :                     if((nId  & COLL_GET_RANGE_BITS) != COLL_LISTS_BITS) continue;
    2636           0 :                     break;
    2637             :                 case SWSTYLEBIT_IDX:
    2638           0 :                     if((nId  & COLL_GET_RANGE_BITS) != COLL_REGISTER_BITS) continue;
    2639           0 :                     break;
    2640             :                 case SWSTYLEBIT_EXTRA:
    2641           0 :                     if((nId  & COLL_GET_RANGE_BITS) != COLL_EXTRA_BITS) continue;
    2642           0 :                     break;
    2643             :                 case SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF:
    2644           0 :                     if(IsPoolUserFmt(nId))
    2645           0 :                         break;
    2646             :                     // otherwise move on
    2647             :                 case SWSTYLEBIT_HTML:
    2648           0 :                     if( (nId  & COLL_GET_RANGE_BITS) != COLL_HTML_BITS)
    2649             :                     {
    2650             :                         // but some we also want to see in this section
    2651           0 :                         sal_Bool bWeiter = sal_True;
    2652           0 :                         switch( nId )
    2653             :                         {
    2654             :                         case RES_POOLCOLL_SENDADRESS:   //  --> ADDRESS
    2655             :                         case RES_POOLCOLL_TABLE_HDLN:   //  --> TH
    2656             :                         case RES_POOLCOLL_TABLE:        //  --> TD
    2657             :                         case RES_POOLCOLL_TEXT:         //  --> P
    2658             :                         case RES_POOLCOLL_HEADLINE_BASE://  --> H
    2659             :                         case RES_POOLCOLL_HEADLINE1:    //  --> H1
    2660             :                         case RES_POOLCOLL_HEADLINE2:    //  --> H2
    2661             :                         case RES_POOLCOLL_HEADLINE3:    //  --> H3
    2662             :                         case RES_POOLCOLL_HEADLINE4:    //  --> H4
    2663             :                         case RES_POOLCOLL_HEADLINE5:    //  --> H5
    2664             :                         case RES_POOLCOLL_HEADLINE6:    //  --> H6
    2665             :                         case RES_POOLCOLL_STANDARD:     //  --> P
    2666             :                         case RES_POOLCOLL_FOOTNOTE:
    2667             :                         case RES_POOLCOLL_ENDNOTE:
    2668           0 :                             bWeiter = sal_False;
    2669           0 :                             break;
    2670             :                         }
    2671           0 :                         if( bWeiter )
    2672           0 :                             continue;
    2673             :                     }
    2674           0 :                     break;
    2675             :                 case SWSTYLEBIT_CONDCOLL:
    2676           0 :                     if( RES_CONDTXTFMTCOLL != pColl->Which() ) continue;
    2677           0 :                     break;
    2678             :                 default:
    2679             :                     // searched for used and found none
    2680        1926 :                     if( bIsSearchUsed )
    2681           0 :                         continue;
    2682             :                 }
    2683             :             }
    2684        1926 :             aLst.Append( cPARA, pColl->GetName() );
    2685             :         }
    2686             : 
    2687         153 :         bAll = ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
    2688         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_TEXT )
    2689         153 :             AppendStyleList(SwStyleNameMapper::GetTextUINameArray(),
    2690         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA );
    2691         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CHAPTER )
    2692         153 :             AppendStyleList(SwStyleNameMapper::GetDocUINameArray(),
    2693         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
    2694         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_LIST )
    2695         153 :             AppendStyleList(SwStyleNameMapper::GetListsUINameArray(),
    2696         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
    2697         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_IDX )
    2698         153 :             AppendStyleList(SwStyleNameMapper::GetRegisterUINameArray(),
    2699         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
    2700         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_EXTRA )
    2701         153 :             AppendStyleList(SwStyleNameMapper::GetExtraUINameArray(),
    2702         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
    2703         153 :         if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CONDCOLL )
    2704             :         {
    2705         153 :             if( !bIsSearchUsed ||
    2706           0 :                 rDoc.IsPoolTxtCollUsed( RES_POOLCOLL_TEXT ))
    2707         153 :                 aLst.Append( cPARA, SwStyleNameMapper::GetTextUINameArray()[
    2708         153 :                         RES_POOLCOLL_TEXT - RES_POOLCOLL_TEXT_BEGIN ] );
    2709             :         }
    2710         153 :         if ( bAll ||
    2711             :             (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_HTML ||
    2712             :             (nSMask & ~SFXSTYLEBIT_USED) ==
    2713             :                         (SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF) )
    2714             :         {
    2715         153 :             AppendStyleList(SwStyleNameMapper::GetHTMLUINameArray(),
    2716         306 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
    2717         153 :             if( !bAll )
    2718             :             {
    2719             :                 // then also the ones, that we are mapping:
    2720             :                 static sal_uInt16 aPoolIds[] = {
    2721             :                     RES_POOLCOLL_SENDADRESS,    //  --> ADDRESS
    2722             :                     RES_POOLCOLL_TABLE_HDLN,    //  --> TH
    2723             :                     RES_POOLCOLL_TABLE,     //  --> TD
    2724             :                     RES_POOLCOLL_STANDARD,      //  --> P
    2725             :                     RES_POOLCOLL_TEXT,          //  --> P
    2726             :                     RES_POOLCOLL_HEADLINE_BASE, //  --> H
    2727             :                     RES_POOLCOLL_HEADLINE1, //  --> H1
    2728             :                     RES_POOLCOLL_HEADLINE2, //  --> H2
    2729             :                     RES_POOLCOLL_HEADLINE3, //  --> H3
    2730             :                     RES_POOLCOLL_HEADLINE4, //  --> H4
    2731             :                     RES_POOLCOLL_HEADLINE5, //  --> H5
    2732             :                     RES_POOLCOLL_HEADLINE6, //  --> H6
    2733             :                     RES_POOLCOLL_FOOTNOTE,
    2734             :                     RES_POOLCOLL_ENDNOTE,
    2735             :                     0
    2736             :                     };
    2737             : 
    2738           0 :                 sal_uInt16* pPoolIds = aPoolIds;
    2739           0 :                 String s;
    2740           0 :                 while( *pPoolIds )
    2741             :                 {
    2742           0 :                     if( !bIsSearchUsed || rDoc.IsPoolTxtCollUsed( *pPoolIds ) )
    2743             :                         aLst.Append( cPARA,
    2744           0 :                             s = SwStyleNameMapper::GetUIName( *pPoolIds, s ));
    2745           0 :                     ++pPoolIds;
    2746           0 :                 }
    2747             :             }
    2748             :         }
    2749             :     }
    2750             : 
    2751         262 :     if( nSearchFamily == SFX_STYLE_FAMILY_FRAME ||
    2752             :         nSearchFamily == SFX_STYLE_FAMILY_ALL )
    2753             :     {
    2754           5 :         const sal_uInt16 nArrLen = rDoc.GetFrmFmts()->size();
    2755          15 :         for( sal_uInt16 i = 0; i < nArrLen; i++ )
    2756             :         {
    2757          10 :             SwFrmFmt* pFmt = (*rDoc.GetFrmFmts())[ i ];
    2758             : 
    2759          10 :             bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(*pFmt));
    2760          10 :             if( ( !bSearchHidden && pFmt->IsHidden( ) && !bUsed ) || pFmt->IsDefault() || pFmt->IsAuto() )
    2761           7 :                 continue;
    2762             : 
    2763           3 :             if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFmt->IsHidden( ) )
    2764           0 :                 continue;
    2765             : 
    2766           3 :             const sal_uInt16 nId = pFmt->GetPoolFmtId();
    2767           3 :             if( !bUsed )
    2768             :             {
    2769           3 :                 if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2770             :                     ? !(nId & USER_FMT)
    2771             :                     // searched for used and found none
    2772           3 :                     : bIsSearchUsed )
    2773             :                 {
    2774           0 :                     continue;
    2775             :                 }
    2776             :             }
    2777             : 
    2778           3 :             aLst.Append( cFRAME, pFmt->GetName() );
    2779             :         }
    2780             : 
    2781             :         // PoolFormate
    2782             :         //
    2783           5 :         if ( bAll )
    2784           5 :             AppendStyleList(SwStyleNameMapper::GetFrmFmtUINameArray(),
    2785          10 :                                     bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, cFRAME);
    2786             :     }
    2787             : 
    2788         262 :     if( nSearchFamily == SFX_STYLE_FAMILY_PAGE ||
    2789             :         nSearchFamily == SFX_STYLE_FAMILY_ALL )
    2790             :     {
    2791          48 :         const sal_uInt16 nCount = rDoc.GetPageDescCnt();
    2792         157 :         for(sal_uInt16 i = 0; i < nCount; ++i)
    2793             :         {
    2794         109 :             const SwPageDesc& rDesc = rDoc.GetPageDesc(i);
    2795         109 :             const sal_uInt16 nId = rDesc.GetPoolFmtId();
    2796         109 :             bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rDesc));
    2797         109 :             if( !bUsed )
    2798             :             {
    2799         109 :                 if ( ( !bSearchHidden && rDesc.IsHidden() ) ||
    2800             :                        ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2801             :                     ? !(nId & USER_FMT)
    2802             :                     // searched for used and found none
    2803         109 :                     : bIsSearchUsed ) )
    2804           0 :                     continue;
    2805             :             }
    2806             : 
    2807         109 :             if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rDesc.IsHidden( ) )
    2808           0 :                 continue;
    2809             : 
    2810         109 :             aLst.Append( cPAGE, rDesc.GetName() );
    2811             :         }
    2812          48 :         if ( bAll )
    2813          48 :             AppendStyleList(SwStyleNameMapper::GetPageDescUINameArray(),
    2814          96 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, cPAGE);
    2815             :     }
    2816             : 
    2817         262 :     if( nSearchFamily == SFX_STYLE_FAMILY_PSEUDO ||
    2818             :         nSearchFamily == SFX_STYLE_FAMILY_ALL )
    2819             :     {
    2820           8 :         const SwNumRuleTbl& rNumTbl = rDoc.GetNumRuleTbl();
    2821          40 :         for(sal_uInt16 i = 0; i < rNumTbl.size(); ++i)
    2822             :         {
    2823          32 :             const SwNumRule& rRule = *rNumTbl[ i ];
    2824          32 :             if( !rRule.IsAutoRule() )
    2825             :             {
    2826          24 :                 if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rRule.IsHidden( ) )
    2827           0 :                     continue;
    2828             : 
    2829          24 :                 bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rRule) );
    2830          24 :                 if( !bUsed )
    2831             :                 {
    2832          24 :                     if( ( !bSearchHidden && rRule.IsHidden() ) ||
    2833             :                            ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
    2834           0 :                         ? !(rRule.GetPoolFmtId() & USER_FMT)
    2835             :                         // searched for used and found none
    2836          24 :                         : bIsSearchUsed ) )
    2837           0 :                         continue;
    2838             :                 }
    2839             : 
    2840          24 :                 aLst.Append( cNUMRULE, rRule.GetName() );
    2841             :             }
    2842             :         }
    2843           8 :         if ( bAll )
    2844           8 :             AppendStyleList(SwStyleNameMapper::GetNumRuleUINameArray(),
    2845          16 :                             bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, cNUMRULE);
    2846             :     }
    2847             : 
    2848         262 :     if(!aLst.empty())
    2849             :     {
    2850         262 :         nLastPos = USHRT_MAX;
    2851         262 :         return Next();
    2852             :     }
    2853           0 :     return 0;
    2854             : }
    2855             : 
    2856         262 : SfxStyleSheetBase*  SwStyleSheetIterator::Next()
    2857             : {
    2858         262 :     ++nLastPos;
    2859         262 :     if(!aLst.empty() && nLastPos < aLst.size())
    2860             :     {
    2861         262 :         mxIterSheet->PresetNameAndFamily(aLst[nLastPos]);
    2862         262 :         mxIterSheet->SetPhysical( sal_False );
    2863         262 :         mxIterSheet->SetMask( nMask );
    2864         262 :         if(mxIterSheet->pSet)
    2865             :         {
    2866           0 :             mxIterSheet->pSet->ClearItem(0);
    2867           0 :             mxIterSheet->pSet= 0;
    2868             :         }
    2869         262 :         return mxIterSheet.get();
    2870             :     }
    2871           0 :     return 0;
    2872             : }
    2873             : 
    2874           0 : SfxStyleSheetBase*  SwStyleSheetIterator::Find(const rtl::OUString& rName)
    2875             : {
    2876             :     // searching
    2877           0 :     if( !bFirstCalled )
    2878           0 :         First();
    2879             : 
    2880           0 :     nLastPos = lcl_FindName( aLst, nSearchFamily, rName );
    2881           0 :     if( USHRT_MAX != nLastPos )
    2882             :     {
    2883             :         // found
    2884           0 :         mxStyleSheet->PresetNameAndFamily(aLst[nLastPos]);
    2885             :         // new name is set, so determine its Data
    2886           0 :         mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
    2887           0 :         if( !mxStyleSheet->IsPhysical() )
    2888           0 :             mxStyleSheet->SetPhysical( sal_False );
    2889             : 
    2890           0 :         return mxStyleSheet.get();
    2891             :     }
    2892           0 :     return 0;
    2893             : }
    2894             : 
    2895        1075 : void SwStyleSheetIterator::AppendStyleList(const boost::ptr_vector<String>& rList,
    2896             :                                             sal_Bool bTestUsed, sal_Bool bTestHidden, bool bOnlyHidden,
    2897             :                                             sal_uInt16 nSection, char cType )
    2898             : {
    2899        1075 :     SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
    2900        1075 :     sal_Bool bUsed = sal_False;
    2901       21584 :     for ( sal_uInt16 i=0; i < rList.size(); ++i )
    2902             :     {
    2903       20509 :         sal_Bool bHidden = sal_False;
    2904       20509 :         sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rList[i], (SwGetPoolIdFromName)nSection);
    2905       20509 :         switch ( nSection )
    2906             :         {
    2907             :             case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
    2908             :                 {
    2909       18666 :                     bUsed = rDoc.IsPoolTxtCollUsed( nId );
    2910       18666 :                     SwFmt* pFmt = rDoc.FindTxtFmtCollByName( rList[i] );
    2911       18666 :                     bHidden = pFmt && pFmt->IsHidden( );
    2912             :                 }
    2913       18666 :                 break;
    2914             :             case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
    2915             :                 {
    2916        1248 :                     bUsed = rDoc.IsPoolFmtUsed( nId );
    2917        1248 :                     SwFmt* pFmt = rDoc.FindCharFmtByName( rList[i] );
    2918        1248 :                     bHidden = pFmt && pFmt->IsHidden( );
    2919             :                 }
    2920        1248 :                 break;
    2921             :             case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
    2922             :                 {
    2923          35 :                     bUsed = rDoc.IsPoolFmtUsed( nId );
    2924          35 :                     SwFmt* pFmt = rDoc.FindFrmFmtByName( rList[i] );
    2925          35 :                     bHidden = pFmt && pFmt->IsHidden( );
    2926             :                 }
    2927          35 :                 break;
    2928             :             case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
    2929             :                 {
    2930         480 :                     bUsed = rDoc.IsPoolPageDescUsed( nId );
    2931         480 :                     SwPageDesc* pPgDesc = rDoc.FindPageDescByName( rList[i] );
    2932         480 :                     bHidden = pPgDesc && pPgDesc->IsHidden( );
    2933             :                 }
    2934         480 :                 break;
    2935             :             case nsSwGetPoolIdFromName::GET_POOLID_NUMRULE:
    2936             :                 {
    2937          80 :                     SwNumRule* pRule = rDoc.FindNumRulePtr( rList[i] );
    2938          80 :                     bUsed = pRule && rDoc.IsUsed( *pRule );
    2939          80 :                     bHidden = pRule && pRule->IsHidden( );
    2940             :                 }
    2941          80 :                 break;
    2942             :             default:
    2943             :                 OSL_ENSURE( !this, "unknown PoolFmt-Id" );
    2944             :         }
    2945             : 
    2946       20509 :         bool bMatchHidden = ( bTestHidden && ( bHidden || !bOnlyHidden ) ) || ( !bTestHidden && ( !bHidden || bUsed ) );
    2947       20509 :         if ( ( !bTestUsed && bMatchHidden ) || ( bTestUsed && bUsed ) )
    2948       20509 :             aLst.Append( cType, rList[i] );
    2949             :     }
    2950        1075 : }
    2951             : 
    2952         389 : void  SwStyleSheetIterator::Notify( SfxBroadcaster&, const SfxHint& rHint )
    2953             : {
    2954             :     // search and remove from View-List!!
    2955         765 :     if( rHint.ISA( SfxStyleSheetHint ) &&
    2956         376 :         SFX_STYLESHEET_ERASED == ((SfxStyleSheetHint&) rHint).GetHint() )
    2957             :     {
    2958           0 :         SfxStyleSheetBase* pStyle = ((SfxStyleSheetHint&)rHint).GetStyleSheet();
    2959             : 
    2960           0 :         if (pStyle)
    2961             :         {
    2962             :             sal_uInt16 nTmpPos = lcl_FindName( aLst, pStyle->GetFamily(),
    2963           0 :                                            pStyle->GetName() );
    2964           0 :             if( nTmpPos < aLst.size() )
    2965           0 :                 aLst.erase(aLst.begin() + nTmpPos);
    2966             :         }
    2967             :     }
    2968         419 : }
    2969             : 
    2970             : 
    2971             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10