xref: /aoo42x/main/sw/source/core/doc/poolfmt.cxx (revision 870262e3)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 #include <hintids.hxx>
28 #include <i18npool/mslangid.hxx>
29 #include <unotools/localedatawrapper.hxx>
30 #include <svx/xdef.hxx>
31 #include <editeng/paperinf.hxx>
32 #include <editeng/wghtitem.hxx>
33 #include <editeng/fontitem.hxx>
34 #include <editeng/fhgtitem.hxx>
35 #include <editeng/tstpitem.hxx>
36 #include <editeng/lrspitem.hxx>
37 #include <editeng/ulspitem.hxx>
38 #include <editeng/adjitem.hxx>
39 #include <editeng/postitem.hxx>
40 #include <editeng/keepitem.hxx>
41 #include <editeng/opaqitem.hxx>
42 #include <editeng/boxitem.hxx>
43 #include <editeng/cmapitem.hxx>
44 #include <editeng/udlnitem.hxx>
45 #include <editeng/colritem.hxx>
46 #include <editeng/protitem.hxx>
47 #include <editeng/escpitem.hxx>
48 #include <editeng/langitem.hxx>
49 #include <editeng/charrotateitem.hxx>
50 #include <editeng/frmdiritem.hxx>
51 #include <editeng/emphitem.hxx>
52 #include <editeng/scriptspaceitem.hxx>
53 #include <viewopt.hxx>
54 #include <doc.hxx>
55 #include <IDocumentUndoRedo.hxx>
56 #include <fmtanchr.hxx>
57 #include <fmtornt.hxx>
58 #include <fmtsrnd.hxx>
59 #include <fmtfsize.hxx>
60 #include <poolfmt.hxx>
61 #include <paratr.hxx>
62 #include <pagedesc.hxx>
63 #include <frmtool.hxx>
64 #include <charfmt.hxx>
65 #include <docary.hxx>
66 #include <fmtcol.hxx>
67 #include <ndtxt.hxx>
68 #include <fmtline.hxx>
69 #include <poolfmt.hrc>
70 #include <GetMetricVal.hxx>
71 #include <numrule.hxx>
72 
73 //UUUU
74 #include <svx/xfillit0.hxx>
75 
76 using namespace ::com::sun::star;
77 
78 const sal_uInt16 PT_3	=  3 * 20;		//  3 pt
79 const sal_uInt16 PT_6	=  6 * 20;		//  6 pt
80 const sal_uInt16 PT_7	=  7 * 20;		//  6 pt
81 const sal_uInt16 PT_8	=  8 * 20;		//  8 pt
82 const sal_uInt16 PT_9	=  9 * 20;		//  9 pt
83 const sal_uInt16 PT_10 	= 10 * 20;		// 10 pt
84 const sal_uInt16 PT_11 	= 11 * 20;		// 11 pt
85 const sal_uInt16 PT_12 	= 12 * 20;		// 12 pt
86 const sal_uInt16 PT_14	= 14 * 20;		// 14 pt
87 const sal_uInt16 PT_16	= 16 * 20;		// 16 pt
88 const sal_uInt16 PT_18	= 18 * 20;		// 18 pt
89 const sal_uInt16 PT_22	= 22 * 20;		// 22 pt
90 const sal_uInt16 PT_24	= 24 * 20;		// 22 pt
91 
92 
93 //const sal_uInt16 HTML_PARSPACE = ((CM_05 * 7) / 10);
94 #define HTML_PARSPACE 	GetMetricVal( CM_05 )
95 
96 static const sal_Char __FAR_DATA sKomma[] = ", ";
97 
98 static const sal_uInt16 aHeadlineSizes[ 2 * MAXLEVEL ] = {
99 //	PT_16, PT_14, PT_14, PT_12, PT_12, 			// normal
100 //JP 10.12.96: jetzt soll alles prozentual sein:
101     115, 100, 100, 85, 85,
102     75,   75,  75, 75, 75,	// normal
103 //	PT_22, PT_16, PT_12, PT_11, PT_9			// HTML-Mode
104     PT_24, PT_18, PT_14, PT_12, PT_10,
105     PT_7, PT_7, PT_7, PT_7, PT_7 			// HTML-Mode
106 };
107 
lcl_GetRightMargin(SwDoc & rDoc)108 long lcl_GetRightMargin( SwDoc& rDoc )
109 {
110     // sorge dafuer, dass die Druckereinstellungen in die Standard-
111     // Seitenvorlage uebernommen wurden.
112     const SwFrmFmt& rPgDscFmt =
113             const_cast<const SwDoc *>(&rDoc)->GetPageDesc( 0 ).GetMaster();
114     const SvxLRSpaceItem& rLR = rPgDscFmt.GetLRSpace();
115     const long nLeft = rLR.GetLeft();
116     const long nRight = rLR.GetRight();
117     const long nWidth = rPgDscFmt.GetFrmSize().GetWidth();
118     return nWidth - nLeft - nRight;
119 }
120 
SetAllScriptItem(SfxItemSet & rSet,const SfxPoolItem & rItem)121 void SetAllScriptItem( SfxItemSet& rSet, const SfxPoolItem& rItem )
122 {
123     rSet.Put( rItem );
124     sal_uInt16 nWhCJK = 0, nWhCTL = 0;
125     switch( rItem.Which() )
126     {
127     case RES_CHRATR_FONTSIZE:
128         nWhCJK = RES_CHRATR_CJK_FONTSIZE, nWhCTL = RES_CHRATR_CTL_FONTSIZE;
129         break;
130     case RES_CHRATR_FONT:
131         nWhCJK = RES_CHRATR_CJK_FONT, nWhCTL = RES_CHRATR_CTL_FONT;
132         break;
133     case RES_CHRATR_LANGUAGE:
134         nWhCJK = RES_CHRATR_CJK_LANGUAGE, nWhCTL = RES_CHRATR_CTL_LANGUAGE;
135         break;
136     case RES_CHRATR_POSTURE:
137         nWhCJK = RES_CHRATR_CJK_POSTURE, nWhCTL = RES_CHRATR_CTL_POSTURE;
138         break;
139     case RES_CHRATR_WEIGHT:
140         nWhCJK = RES_CHRATR_CJK_WEIGHT, nWhCTL = RES_CHRATR_CTL_WEIGHT;
141         break;
142     }
143 
144     if( nWhCJK )
145         rSet.Put( rItem, nWhCJK );
146     if( nWhCTL )
147         rSet.Put( rItem, nWhCTL );
148 }
149 
lcl_SetDfltFont(sal_uInt16 nFntType,SfxItemSet & rSet)150 void lcl_SetDfltFont( sal_uInt16 nFntType, SfxItemSet& rSet )
151 {
152     static struct {
153         sal_uInt16 nResLngId;
154         sal_uInt16 nResFntId;
155     } aArr[ 3 ] = {
156         { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT },
157         { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT },
158         { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT }
159     };
160     for( sal_uInt16 n = 0; n < 3; ++n )
161     {
162         sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem(
163                             aArr[n].nResLngId )).GetLanguage();
164         Font aFnt( OutputDevice::GetDefaultFont( nFntType,
165                                 nLng, DEFAULTFONT_FLAGS_ONLYONE ) );
166 
167         rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
168                             aEmptyStr, aFnt.GetPitch(),
169                             aFnt.GetCharSet(), aArr[n].nResFntId ));
170     }
171 }
172 
lcl_SetDfltFont(sal_uInt16 nLatinFntType,sal_uInt16 nCJKFntType,sal_uInt16 nCTLFntType,SfxItemSet & rSet)173 void lcl_SetDfltFont( sal_uInt16 nLatinFntType, sal_uInt16 nCJKFntType,
174                         sal_uInt16 nCTLFntType, SfxItemSet& rSet )
175 {
176     static struct {
177         sal_uInt16 nResLngId;
178         sal_uInt16 nResFntId;
179         sal_uInt16 nFntType;
180     } aArr[ 3 ] = {
181         { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT, 0 },
182         { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT, 0 },
183         { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT, 0 }
184     };
185     aArr[0].nFntType = nLatinFntType;
186     aArr[1].nFntType = nCJKFntType;
187     aArr[2].nFntType = nCTLFntType;
188 
189     for( sal_uInt16 n = 0; n < 3; ++n )
190     {
191         sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem(
192                             aArr[n].nResLngId )).GetLanguage();
193         Font aFnt( OutputDevice::GetDefaultFont( aArr[n].nFntType,
194                                 nLng, DEFAULTFONT_FLAGS_ONLYONE ) );
195 
196         rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
197                             aEmptyStr, aFnt.GetPitch(),
198                             aFnt.GetCharSet(), aArr[n].nResFntId ));
199     }
200 }
201 
lcl_SetHeadline(SwDoc * pDoc,SwTxtFmtColl * pColl,SfxItemSet & rSet,sal_uInt16 nOutLvlBits,sal_uInt8 nLevel,sal_Bool bItalic)202 void lcl_SetHeadline( SwDoc* pDoc, SwTxtFmtColl* pColl,
203                         SfxItemSet& rSet,
204                         sal_uInt16 nOutLvlBits, sal_uInt8 nLevel, sal_Bool bItalic )
205 {
206     SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
207     SvxFontHeightItem aHItem(240, 100, RES_CHRATR_FONTSIZE);
208     const bool bHTMLMode = pDoc->get(IDocumentSettingAccess::HTML_MODE);
209     if( bHTMLMode )
210         aHItem.SetHeight( aHeadlineSizes[ MAXLEVEL + nLevel ] );
211     else
212         aHItem.SetHeight( PT_14, aHeadlineSizes[ nLevel ] );
213     SetAllScriptItem( rSet, aHItem );
214 
215     if( bItalic && !bHTMLMode )
216         SetAllScriptItem( rSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );
217 
218     if( bHTMLMode )
219     {
220         ::lcl_SetDfltFont( DEFAULTFONT_LATIN_TEXT, DEFAULTFONT_CJK_TEXT,
221                             DEFAULTFONT_CTL_TEXT, rSet );
222     }
223 
224     if( pColl )
225     {
226         if( !( nOutLvlBits & ( 1 << nLevel )) )
227         {
228             //pColl->SetOutlineLevel( nLevel );			 //#outline level zhaojianwei
229             pColl->AssignToListLevelOfOutlineStyle(nLevel);//<-end,zhaojianwei
230             if( !bHTMLMode )
231             {
232                 SwNumRule * pOutlineRule = pDoc->GetOutlineNumRule();
233                 const SwNumFmt& rNFmt = pOutlineRule->Get( nLevel );
234                 // --> OD 2008-02-01 #newlistlevelattrs#
235                 if ( rNFmt.GetPositionAndSpaceMode() ==
236                                     SvxNumberFormat::LABEL_WIDTH_AND_POSITION &&
237                      ( rNFmt.GetAbsLSpace() || rNFmt.GetFirstLineOffset() ) )
238                 // <--
239                 {
240                     SvxLRSpaceItem aLR( (SvxLRSpaceItem&)pColl->GetFmtAttr( RES_LR_SPACE ) );
241                     aLR.SetTxtFirstLineOfstValue( rNFmt.GetFirstLineOffset() );
242                     aLR.SetTxtLeft( rNFmt.GetAbsLSpace() );
243                     pColl->SetFmtAttr( aLR );
244                 }
245 
246                 // --> OD 2006-11-20 #i71764#
247                 // Check on document setting OUTLINE_LEVEL_YIELDS_OUTLINE_RULE no longer needed.
248                 // All paragraph styles, which are assigned to a level of the
249                 // outline style has to have the outline style set as its list style.
250                 {
251                     SwNumRuleItem aItem(pOutlineRule->GetName());
252 
253                     pColl->SetFmtAttr(aItem);
254                 }
255                 // <--
256             }
257         }
258         pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool(
259                                         RES_POOLCOLL_TEXT ));
260     }
261 }
262 
263 
264 
lcl_SetRegister(SwDoc * pDoc,SfxItemSet & rSet,sal_uInt16 nFact,sal_Bool bHeader,sal_Bool bTab)265 void lcl_SetRegister( SwDoc* pDoc, SfxItemSet& rSet, sal_uInt16 nFact,
266                         sal_Bool bHeader, sal_Bool bTab )
267 {
268     SvxLRSpaceItem aLR( RES_LR_SPACE );
269     sal_uInt16 nLeft = nFact ? GetMetricVal( CM_05 ) * nFact : 0;
270     aLR.SetTxtLeft( nLeft );
271 
272     rSet.Put( aLR );
273     if( bHeader )
274     {
275         SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
276         SetAllScriptItem( rSet, SvxFontHeightItem( PT_16, 100, RES_CHRATR_FONTSIZE ) );
277     }
278     if( bTab )
279     {
280         long nRightMargin = lcl_GetRightMargin( *pDoc );
281         SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
282         aTStops.Insert( SvxTabStop( nRightMargin - nLeft,
283                                     SVX_TAB_ADJUST_RIGHT,
284                                     cDfltDecimalChar, '.' ));
285         rSet.Put( aTStops );
286     }
287 }
288 
289 
290 
lcl_SetNumBul(SwDoc * pDoc,SwTxtFmtColl * pColl,SfxItemSet & rSet,sal_uInt16 nNxt,SwTwips nEZ,SwTwips nLeft,SwTwips nUpper,SwTwips nLower)291 void lcl_SetNumBul( SwDoc* pDoc, SwTxtFmtColl* pColl,
292                         SfxItemSet& rSet,
293                         sal_uInt16 nNxt, SwTwips nEZ, SwTwips nLeft,
294                         SwTwips nUpper, SwTwips nLower )
295 {
296 
297     SvxLRSpaceItem aLR( RES_LR_SPACE ); SvxULSpaceItem aUL( RES_UL_SPACE );
298     aLR.SetTxtFirstLineOfst( sal_uInt16(nEZ) ); aLR.SetTxtLeft( sal_uInt16(nLeft) );
299     aUL.SetUpper( sal_uInt16(nUpper) ); aUL.SetLower( sal_uInt16(nLower) );
300     rSet.Put( aLR );
301     rSet.Put( aUL );
302 
303     pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool( nNxt ));
304 }
305 
306 
307 
308 // Gebe die "Auto-Collection" mit der Id zurueck. Existiert
309 // sie noch nicht, dann erzeuge sie
310 // Ist der String-Pointer definiert, dann erfrage nur die
311 // Beschreibung der Attribute, !! es legt keine Vorlage an !!
312 
GetDefaultFrameDirection(sal_uLong nLanguage)313 SvxFrameDirection GetDefaultFrameDirection(sal_uLong nLanguage)
314 {
315     SvxFrameDirection eResult = (MsLangId::isRightToLeft( static_cast<LanguageType>(nLanguage)) ?
316             FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP);
317     return eResult;
318 }
319 
GetTxtCollFromPool(sal_uInt16 nId,bool bRegardLanguage)320 SwTxtFmtColl* SwDoc::GetTxtCollFromPool( sal_uInt16 nId, bool bRegardLanguage )
321 {
322     ASSERT(
323         (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
324         (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
325         (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
326         (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
327         (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
328         (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
329             "Falsche AutoFormat-Id" );
330 
331     SwTxtFmtColl* pNewColl;
332     sal_uInt16 nOutLvlBits = 0;
333     for( sal_uInt16 n = 0; n < pTxtFmtCollTbl->Count(); ++n )
334     {
335         if( nId == ( pNewColl = (*pTxtFmtCollTbl)[ n ] )->GetPoolFmtId() )
336         {
337             return pNewColl;
338         }
339         //if( pNewColl->GetOutlineLevel() < MAXLEVEL )			//#outline level,zhaojianwei
340         //nOutLvlBits |= ( 1 << pNewColl->GetOutlineLevel() );
341         if( pNewColl->IsAssignedToListLevelOfOutlineStyle())
342             nOutLvlBits |= ( 1 << pNewColl->GetAssignedOutlineStyleLevel() );//<-end,zhaojianwei
343     }
344 
345     // bis hierher nicht gefunden -> neu anlegen
346     sal_uInt16 nResId = 0;
347     if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END )
348         nResId = RC_POOLCOLL_TEXT_BEGIN - RES_POOLCOLL_TEXT_BEGIN;
349     else if (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END)
350         nResId = RC_POOLCOLL_LISTS_BEGIN - RES_POOLCOLL_LISTS_BEGIN;
351     else if (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END)
352         nResId = RC_POOLCOLL_EXTRA_BEGIN - RES_POOLCOLL_EXTRA_BEGIN;
353     else if (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END)
354         nResId = RC_POOLCOLL_REGISTER_BEGIN - RES_POOLCOLL_REGISTER_BEGIN;
355     else if (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END)
356         nResId = RC_POOLCOLL_DOC_BEGIN - RES_POOLCOLL_DOC_BEGIN;
357     else if (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END)
358         nResId = RC_POOLCOLL_HTML_BEGIN - RES_POOLCOLL_HTML_BEGIN;
359 
360     ASSERT( nResId, "Ungueltige Pool-ID" );
361     if( !nResId )
362         return GetTxtCollFromPool( RES_POOLCOLL_STANDARD );
363 
364     ResId aResId( nResId + nId, *pSwResMgr );
365     String aNm( aResId );
366 
367     // ein Set fuer alle zusetzenden Attribute
368     SwAttrSet aSet( GetAttrPool(), aTxtFmtCollSetRange );
369     sal_uInt16 nParent = GetPoolParent( nId );
370 
371     {
372 
373 //FEATURE::CONDCOLL
374         if(::IsConditionalByPoolId( nId ))
375             pNewColl = new SwConditionTxtFmtColl( GetAttrPool(), aNm, !nParent
376                                                 ? pDfltTxtFmtColl
377                                                 : GetTxtCollFromPool( nParent ));
378         else
379 //FEATURE::CONDCOLL
380         pNewColl = new SwTxtFmtColl( GetAttrPool(), aNm, !nParent
381                                             ? pDfltTxtFmtColl
382                                             : GetTxtCollFromPool( nParent ));
383         pNewColl->SetPoolFmtId( nId );
384         pTxtFmtCollTbl->Insert( pNewColl, pTxtFmtCollTbl->Count() );
385     }
386 
387     switch( nId )
388     {
389     // allgemeine Inhaltsformen
390     case RES_POOLCOLL_STANDARD:
391         /* #111214# koreans do not like SvxScriptItem(sal_True) */
392         if (bRegardLanguage)
393         {
394             sal_uLong nAppLanguage = GetAppLanguage();
395             if (GetDefaultFrameDirection(nAppLanguage) ==
396                 FRMDIR_HORI_RIGHT_TOP)
397             {
398                 SvxAdjustItem aAdjust(SVX_ADJUST_RIGHT, RES_PARATR_ADJUST );
399                 aSet.Put(aAdjust);
400             }
401             if (nAppLanguage == LANGUAGE_KOREAN)
402             {
403                 SvxScriptSpaceItem aScriptSpace(sal_False, RES_PARATR_SCRIPTSPACE);
404                 aSet.Put(aScriptSpace);
405             }
406         }
407 
408         break;
409 
410     case RES_POOLCOLL_TEXT:					// Textkoerper
411         {
412             SvxULSpaceItem aUL( 0, PT_6, RES_UL_SPACE );
413             if( get(IDocumentSettingAccess::HTML_MODE) ) aUL.SetLower( HTML_PARSPACE );
414             aSet.Put( aUL );
415         }
416         break;
417     case RES_POOLCOLL_TEXT_IDENT:			// Textkoerper Einzug
418         {
419             SvxLRSpaceItem aLR( RES_LR_SPACE );
420             aLR.SetTxtFirstLineOfst( GetMetricVal( CM_05 ));
421             aSet.Put( aLR );
422         }
423         break;
424     case RES_POOLCOLL_TEXT_NEGIDENT:		// Textkoerper neg. Einzug
425         {
426             SvxLRSpaceItem aLR( RES_LR_SPACE );
427             aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 ));
428             aLR.SetTxtLeft( GetMetricVal( CM_1 ));
429             SvxTabStopItem aTStops(RES_PARATR_TABSTOP);    aTStops.Insert( SvxTabStop( 0 ));
430 
431             aSet.Put( aLR );
432             aSet.Put( aTStops );
433         }
434         break;
435     case RES_POOLCOLL_TEXT_MOVE:			// Textkoerper Einrueckung
436         {
437             SvxLRSpaceItem aLR( RES_LR_SPACE );
438             aLR.SetTxtLeft( GetMetricVal( CM_05 ));
439             aSet.Put( aLR );
440         }
441         break;
442 
443     case RES_POOLCOLL_CONFRONTATION: 	// Textkoerper Gegenueberstellung
444         {
445             SvxLRSpaceItem aLR( RES_LR_SPACE );
446             aLR.SetTxtFirstLineOfst( - short( GetMetricVal( CM_1 ) * 4 +
447                                               GetMetricVal( CM_05)) );
448             aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 5 );
449             SvxTabStopItem aTStops( RES_PARATR_TABSTOP );    aTStops.Insert( SvxTabStop( 0 ));
450 
451             aSet.Put( aLR );
452             aSet.Put( aTStops );
453         }
454         break;
455     case RES_POOLCOLL_MARGINAL: 		// Textkoerper maginalie
456         {
457             SvxLRSpaceItem aLR( RES_LR_SPACE );
458             aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 4 );
459             aSet.Put( aLR );
460         }
461         break;
462 
463     case RES_POOLCOLL_HEADLINE_BASE:			// Basis Ueberschrift
464         {
465             static const sal_uInt16 aFntInit[] = {
466                 DEFAULTFONT_LATIN_HEADING, 	RES_CHRATR_FONT,
467                                 RES_CHRATR_LANGUAGE, LANGUAGE_ENGLISH_US,
468                 DEFAULTFONT_CJK_HEADING, 	RES_CHRATR_CJK_FONT,
469                                 RES_CHRATR_CJK_LANGUAGE, LANGUAGE_ENGLISH_US,
470                 DEFAULTFONT_CTL_HEADING, 	RES_CHRATR_CTL_FONT,
471                                 RES_CHRATR_CTL_LANGUAGE, LANGUAGE_ARABIC_SAUDI_ARABIA,
472                 0
473             };
474 
475             for( const sal_uInt16* pArr = aFntInit; *pArr; pArr += 4 )
476             {
477                 sal_uInt16 nLng = ((SvxLanguageItem&)GetDefault( *(pArr+2) )).GetLanguage();
478                 if( LANGUAGE_DONTKNOW == nLng )
479                     nLng = *(pArr+3);
480 
481                 Font aFnt( OutputDevice::GetDefaultFont( *pArr,
482                                         nLng, DEFAULTFONT_FLAGS_ONLYONE ) );
483 
484                 aSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(),
485                                         aEmptyStr, aFnt.GetPitch(),
486                                         aFnt.GetCharSet(), *(pArr+1) ));
487             }
488 
489             SvxFontHeightItem aFntSize( PT_14, 100, RES_CHRATR_FONTSIZE );
490             SvxULSpaceItem aUL( PT_12, PT_6, RES_UL_SPACE );
491             if( get(IDocumentSettingAccess::HTML_MODE) )
492                 aUL.SetLower( HTML_PARSPACE );
493             aSet.Put( SvxFmtKeepItem( sal_True, RES_KEEP ));
494 
495             pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( RES_POOLCOLL_TEXT ));
496 
497             aSet.Put( aUL );
498             SetAllScriptItem( aSet, aFntSize );
499         }
500         break;
501 
502     case RES_POOLCOLL_NUMBUL_BASE:			// Basis Numerierung/Aufzaehlung
503         break;
504 
505     case RES_POOLCOLL_GREETING:				// Grussformel
506     case RES_POOLCOLL_REGISTER_BASE: 		// Basis Verzeichnisse
507     case RES_POOLCOLL_SIGNATURE:			// Unterschrift
508     case RES_POOLCOLL_TABLE:				// Tabelle-Inhalt
509         {
510             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
511             aSet.Put( aLN );
512         }
513         break;
514 
515     case RES_POOLCOLL_HEADLINE1:		// Ueberschrift 1
516         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 0, sal_False );
517         break;
518     case RES_POOLCOLL_HEADLINE2:		// Ueberschrift 2
519         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 1, sal_True );
520         break;
521     case RES_POOLCOLL_HEADLINE3:		// Ueberschrift 3
522         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 2, sal_False );
523         break;
524     case RES_POOLCOLL_HEADLINE4:		// Ueberschrift 4
525         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 3, sal_True );
526         break;
527     case RES_POOLCOLL_HEADLINE5:		// Ueberschrift 5
528         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 4, sal_False );
529         break;
530     case RES_POOLCOLL_HEADLINE6:		// Ueberschrift 6
531         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 5, sal_False );
532         break;
533     case RES_POOLCOLL_HEADLINE7:		// Ueberschrift 7
534         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 6, sal_False );
535         break;
536     case RES_POOLCOLL_HEADLINE8:		// Ueberschrift 8
537         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 7, sal_False );
538         break;
539     case RES_POOLCOLL_HEADLINE9:		// Ueberschrift 9
540         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 8, sal_False );
541         break;
542     case RES_POOLCOLL_HEADLINE10:		// Ueberschrift 10
543         lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 9, sal_False );
544         break;
545 
546 
547     // Sonderbereiche:
548     // Kopfzeilen
549     case RES_POOLCOLL_HEADER:
550     case RES_POOLCOLL_HEADERL:
551     case RES_POOLCOLL_HEADERR:
552     // Fusszeilen
553     case RES_POOLCOLL_FOOTER:
554     case RES_POOLCOLL_FOOTERL:
555     case RES_POOLCOLL_FOOTERR:
556         {
557             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
558             aSet.Put( aLN );
559 
560             long nRightMargin = lcl_GetRightMargin( *this );
561 
562             SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
563             aTStops.Insert( SvxTabStop( nRightMargin / 2, SVX_TAB_ADJUST_CENTER ) );
564             aTStops.Insert( SvxTabStop( nRightMargin, SVX_TAB_ADJUST_RIGHT ) );
565 
566             aSet.Put( aTStops );
567         }
568         break;
569 
570     case RES_POOLCOLL_TABLE_HDLN:
571         {
572             SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
573             aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );
574             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
575             aSet.Put( aLN );
576         }
577         break;
578 
579     case RES_POOLCOLL_FOOTNOTE:				// Fussnote
580     case RES_POOLCOLL_ENDNOTE:
581         {
582             SvxLRSpaceItem aLR( RES_LR_SPACE );
583             aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 ));
584             aLR.SetTxtLeft( GetMetricVal( CM_05 ));
585             SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
586             aSet.Put( aLR );
587             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
588             aSet.Put( aLN );
589         }
590         break;
591 
592     case RES_POOLCOLL_LABEL:				// Beschriftung-Basis
593         {
594             SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetUpper( PT_6 ); aUL.SetLower( PT_6 );
595             aSet.Put( aUL );
596             SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) );
597             SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) );
598             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
599             aSet.Put( aLN );
600         }
601         break;
602 
603     case RES_POOLCOLL_FRAME:				// Rahmen Inhalt
604     case RES_POOLCOLL_LABEL_ABB:			// Beschriftung-Abbildung
605     case RES_POOLCOLL_LABEL_TABLE:			// Beschriftung-Tabelle
606     case RES_POOLCOLL_LABEL_FRAME:			// Beschriftung-Rahmen
607     case RES_POOLCOLL_LABEL_DRAWING:		// Beschriftung-Zeichnung
608         break;
609 
610     case RES_POOLCOLL_JAKETADRESS:			// UmschlagAdresse
611         {
612             SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
613             aSet.Put( aUL );
614             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
615             aSet.Put( aLN );
616         }
617         break;
618 
619     case RES_POOLCOLL_SENDADRESS:			// AbsenderAdresse
620         {
621             if( get(IDocumentSettingAccess::HTML_MODE) )
622                 SetAllScriptItem( aSet, SvxPostureItem(ITALIC_NORMAL, RES_CHRATR_POSTURE) );
623             else
624             {
625                 SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 );
626                 aSet.Put( aUL );
627             }
628             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
629             aSet.Put( aLN );
630         }
631         break;
632 
633     // Benutzer-Verzeichnisse:
634     case RES_POOLCOLL_TOX_USERH:			// Header
635         lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
636         {
637             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
638             aSet.Put( aLN );
639         }
640         break;
641     case RES_POOLCOLL_TOX_USER1:			// 1. Ebene
642         lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
643         break;
644     case RES_POOLCOLL_TOX_USER2:			// 2. Ebene
645         lcl_SetRegister( this, aSet, 1, sal_False, sal_True );
646         break;
647     case RES_POOLCOLL_TOX_USER3:			// 3. Ebene
648         lcl_SetRegister( this, aSet, 2, sal_False, sal_True );
649         break;
650     case RES_POOLCOLL_TOX_USER4:			// 4. Ebene
651         lcl_SetRegister( this, aSet, 3, sal_False, sal_True );
652         break;
653     case RES_POOLCOLL_TOX_USER5:			// 5. Ebene
654         lcl_SetRegister( this, aSet, 4, sal_False, sal_True );
655         break;
656     case RES_POOLCOLL_TOX_USER6:			// 6. Ebene
657         lcl_SetRegister( this, aSet, 5, sal_False, sal_True );
658         break;
659     case RES_POOLCOLL_TOX_USER7:			// 7. Ebene
660         lcl_SetRegister( this, aSet, 6, sal_False, sal_True );
661         break;
662     case RES_POOLCOLL_TOX_USER8:			// 8. Ebene
663         lcl_SetRegister( this, aSet, 7, sal_False, sal_True );
664         break;
665     case RES_POOLCOLL_TOX_USER9:			// 9. Ebene
666         lcl_SetRegister( this, aSet, 8, sal_False, sal_True );
667         break;
668     case RES_POOLCOLL_TOX_USER10:			// 10. Ebene
669         lcl_SetRegister( this, aSet, 9, sal_False, sal_True );
670         break;
671 
672     // Index-Verzeichnisse
673     case RES_POOLCOLL_TOX_IDXH:			// Header
674         lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
675         {
676             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
677             aSet.Put( aLN );
678         }
679         break;
680     case RES_POOLCOLL_TOX_IDX1:			// 1. Ebene
681         lcl_SetRegister( this, aSet, 0, sal_False, sal_False );
682         break;
683     case RES_POOLCOLL_TOX_IDX2:			// 2. Ebene
684         lcl_SetRegister( this, aSet, 1, sal_False, sal_False );
685         break;
686     case RES_POOLCOLL_TOX_IDX3:			// 3. Ebene
687         lcl_SetRegister( this, aSet, 2, sal_False, sal_False );
688         break;
689     case RES_POOLCOLL_TOX_IDXBREAK:		// Trenner
690         lcl_SetRegister( this, aSet, 0, sal_False, sal_False );
691         break;
692 
693     // Inhalts-Verzeichnisse
694     case RES_POOLCOLL_TOX_CNTNTH:		// Header
695         lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
696         {
697             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
698             aSet.Put( aLN );
699         }
700         break;
701     case RES_POOLCOLL_TOX_CNTNT1:		// 1. Ebene
702         lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
703         break;
704     case RES_POOLCOLL_TOX_CNTNT2:		// 2. Ebene
705         lcl_SetRegister( this, aSet, 1, sal_False, sal_True );
706         break;
707     case RES_POOLCOLL_TOX_CNTNT3:		// 3. Ebene
708         lcl_SetRegister( this, aSet, 2, sal_False, sal_True );
709         break;
710     case RES_POOLCOLL_TOX_CNTNT4:		// 4. Ebene
711         lcl_SetRegister( this, aSet, 3, sal_False, sal_True );
712         break;
713     case RES_POOLCOLL_TOX_CNTNT5:		// 5. Ebene
714         lcl_SetRegister( this, aSet, 4, sal_False, sal_True );
715         break;
716     case RES_POOLCOLL_TOX_CNTNT6:		// 6. Ebene
717         lcl_SetRegister( this, aSet, 5, sal_False, sal_True );
718         break;
719     case RES_POOLCOLL_TOX_CNTNT7:		// 7. Ebene
720         lcl_SetRegister( this, aSet, 6, sal_False, sal_True );
721         break;
722     case RES_POOLCOLL_TOX_CNTNT8:		// 8. Ebene
723         lcl_SetRegister( this, aSet, 7, sal_False, sal_True );
724         break;
725     case RES_POOLCOLL_TOX_CNTNT9:		// 9. Ebene
726         lcl_SetRegister( this, aSet, 8, sal_False, sal_True );
727         break;
728     case RES_POOLCOLL_TOX_CNTNT10:		// 10. Ebene
729         lcl_SetRegister( this, aSet, 9, sal_False, sal_True );
730         break;
731 
732     case RES_POOLCOLL_TOX_ILLUSH:
733     case RES_POOLCOLL_TOX_OBJECTH:
734     case RES_POOLCOLL_TOX_TABLESH:
735     case RES_POOLCOLL_TOX_AUTHORITIESH:
736         lcl_SetRegister( this, aSet, 0, sal_True, sal_False );
737         {
738             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
739             aSet.Put( aLN );
740         }
741         break;
742     case RES_POOLCOLL_TOX_ILLUS1:
743     case RES_POOLCOLL_TOX_OBJECT1:
744     case RES_POOLCOLL_TOX_TABLES1:
745     case RES_POOLCOLL_TOX_AUTHORITIES1:
746         lcl_SetRegister( this, aSet, 0, sal_False, sal_True );
747     break;
748 
749 
750 
751     case RES_POOLCOLL_NUM_LEVEL1S:
752         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
753                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
754                         PT_12, PT_6 );
755         break;
756     case RES_POOLCOLL_NUM_LEVEL1:
757         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
758                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
759                         0, PT_6 );
760         break;
761     case RES_POOLCOLL_NUM_LEVEL1E:
762         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1,
763                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ),
764                         0, PT_12 );
765         break;
766     case RES_POOLCOLL_NUM_NONUM1:
767         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM1,
768                         0, SwNumRule::GetNumIndent( 0 ), 0, PT_6 );
769         break;
770     case RES_POOLCOLL_NUM_LEVEL2S:
771         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
772                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
773                         PT_12, PT_6 );
774         break;
775     case RES_POOLCOLL_NUM_LEVEL2:
776         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
777                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
778                         0, PT_6 );
779         break;
780     case RES_POOLCOLL_NUM_LEVEL2E:
781         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2,
782                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ),
783                         0, PT_12 );
784         break;
785     case RES_POOLCOLL_NUM_NONUM2:
786         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM2,
787                         0, SwNumRule::GetNumIndent( 1 ), 0, PT_6 );
788         break;
789     case RES_POOLCOLL_NUM_LEVEL3S:
790         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
791                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
792                         PT_12, PT_6 );
793         break;
794     case RES_POOLCOLL_NUM_LEVEL3:
795         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
796                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
797                         0, PT_6 );
798         break;
799     case RES_POOLCOLL_NUM_LEVEL3E:
800         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3,
801                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ),
802                         0, PT_12 );
803         break;
804     case RES_POOLCOLL_NUM_NONUM3:
805         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM3,
806                         0, SwNumRule::GetNumIndent( 2 ), 0, PT_6 );
807         break;
808     case RES_POOLCOLL_NUM_LEVEL4S:
809         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
810                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
811                         PT_12, PT_6 );
812         break;
813     case RES_POOLCOLL_NUM_LEVEL4:
814         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
815                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
816                         0, PT_6 );
817         break;
818     case RES_POOLCOLL_NUM_LEVEL4E:
819         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4,
820                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ),
821                         0, PT_12 );
822         break;
823     case RES_POOLCOLL_NUM_NONUM4:
824         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM4,
825                         0, SwNumRule::GetNumIndent( 3 ), 0, PT_6 );
826         break;
827     case RES_POOLCOLL_NUM_LEVEL5S:
828         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
829                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
830                         PT_12, PT_6 );
831         break;
832     case RES_POOLCOLL_NUM_LEVEL5:
833         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
834                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
835                         0, PT_6 );
836         break;
837     case RES_POOLCOLL_NUM_LEVEL5E:
838         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5,
839                         lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ),
840                         0, PT_12 );
841         break;
842     case RES_POOLCOLL_NUM_NONUM5:
843         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM5,
844                         0, SwNumRule::GetNumIndent( 4 ), 0, PT_6 );
845         break;
846 
847     case RES_POOLCOLL_BUL_LEVEL1S:
848         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
849                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
850                         PT_12, PT_6 );
851         break;
852     case RES_POOLCOLL_BUL_LEVEL1:
853         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
854                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
855                         0, PT_6 );
856         break;
857     case RES_POOLCOLL_BUL_LEVEL1E:
858         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1,
859                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ),
860                         0, PT_12 );
861         break;
862     case RES_POOLCOLL_BUL_NONUM1:
863         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM1,
864                         0, SwNumRule::GetBullIndent( 0 ), 0, PT_6 );
865         break;
866     case RES_POOLCOLL_BUL_LEVEL2S:
867         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
868                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
869                         PT_12, PT_6 );
870         break;
871     case RES_POOLCOLL_BUL_LEVEL2:
872         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
873                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
874                         0, PT_6 );
875         break;
876     case RES_POOLCOLL_BUL_LEVEL2E:
877         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2,
878                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ),
879                         0, PT_12 );
880         break;
881     case RES_POOLCOLL_BUL_NONUM2:
882         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM2,
883                         0, SwNumRule::GetBullIndent( 1 ), 0, PT_6 );
884         break;
885     case RES_POOLCOLL_BUL_LEVEL3S:
886         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
887                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
888                         PT_12, PT_6 );
889         break;
890     case RES_POOLCOLL_BUL_LEVEL3:
891         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
892                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
893                         0, PT_6 );
894         break;
895     case RES_POOLCOLL_BUL_LEVEL3E:
896         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3,
897                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ),
898                         0, PT_12 );
899         break;
900     case RES_POOLCOLL_BUL_NONUM3:
901         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM3,
902                         0, SwNumRule::GetBullIndent( 2 ), 0, PT_6 );
903         break;
904     case RES_POOLCOLL_BUL_LEVEL4S:
905         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
906                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
907                         PT_12, PT_6 );
908         break;
909     case RES_POOLCOLL_BUL_LEVEL4:
910         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
911                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
912                         0, PT_6 );
913         break;
914     case RES_POOLCOLL_BUL_LEVEL4E:
915         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4,
916                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ),
917                         0, PT_12 );
918         break;
919     case RES_POOLCOLL_BUL_NONUM4:
920         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM4,
921                         0, SwNumRule::GetBullIndent( 3 ), 0, PT_6 );
922         break;
923     case RES_POOLCOLL_BUL_LEVEL5S:
924         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
925                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
926                         PT_12, PT_6 );
927         break;
928     case RES_POOLCOLL_BUL_LEVEL5:
929         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
930                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
931                         0, PT_6 );
932         break;
933     case RES_POOLCOLL_BUL_LEVEL5E:
934         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5,
935                         lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ),
936                         0, PT_12 );
937         break;
938     case RES_POOLCOLL_BUL_NONUM5:
939         lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM5,
940                         0, SwNumRule::GetBullIndent( 4 ), 0, PT_6 );
941         break;
942 
943     case RES_POOLCOLL_DOC_TITEL:	   		// Doc. Titel
944         {
945             SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) );
946             SetAllScriptItem( aSet, SvxFontHeightItem( PT_18, 100, RES_CHRATR_FONTSIZE ) );
947 
948             aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) );
949 
950             pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
951                                                 RES_POOLCOLL_DOC_SUBTITEL ));
952         }
953         break;
954 
955     case RES_POOLCOLL_DOC_SUBTITEL:			// Doc. UnterTitel
956         {
957             SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ));
958             SetAllScriptItem( aSet, SvxFontHeightItem( PT_14, 100, RES_CHRATR_FONTSIZE ));
959 
960             aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ));
961 
962             pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
963                                                 RES_POOLCOLL_TEXT ));
964         }
965         break;
966 
967     case RES_POOLCOLL_HTML_BLOCKQUOTE:
968         {
969             SvxLRSpaceItem aLR( RES_LR_SPACE );
970             aLR.SetLeft( GetMetricVal( CM_1 ));
971             aLR.SetRight( GetMetricVal( CM_1 ));
972             aSet.Put( aLR );
973 //          aSet.Put( SvxAdjustItem( SVX_ADJUST_BLOCK, RES_PARATR_ADJUST ) );
974             SvxULSpaceItem aUL( RES_UL_SPACE );
975             aUL = pNewColl->GetULSpace();
976             aUL.SetLower( HTML_PARSPACE );
977             aSet.Put( aUL);
978         }
979         break;
980 
981     case RES_POOLCOLL_HTML_PRE:
982         {
983             ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet );
984 
985 // WORKAROUND: PRE auf 10pt setzten
986             SetAllScriptItem( aSet, SvxFontHeightItem(PT_10, 100, RES_CHRATR_FONTSIZE) );
987 // WORKAROUND: PRE auf 10pt setzten
988 
989             // der untere Absatz-Abstand wird explizit gesetzt (macht
990             // die harte Attributierung einfacher)
991             SvxULSpaceItem aULSpaceItem( RES_UL_SPACE );
992             aULSpaceItem = pNewColl->GetULSpace();
993             aULSpaceItem.SetLower( 0 );
994             aSet.Put( aULSpaceItem );
995         }
996         break;
997 
998     case RES_POOLCOLL_HTML_HR:
999         {
1000             SvxBoxItem aBox( RES_BOX );
1001             Color aColor( COL_GRAY );
1002             SvxBorderLine aNew( &aColor, DEF_DOUBLE_LINE0_OUT,
1003                                          DEF_DOUBLE_LINE0_IN,
1004                                          DEF_DOUBLE_LINE0_DIST );
1005             aBox.SetLine( &aNew, BOX_LINE_BOTTOM );
1006 
1007             aSet.Put( aBox );
1008             aSet.Put( SwParaConnectBorderItem( sal_False ) );
1009             SetAllScriptItem( aSet, SvxFontHeightItem(120, 100, RES_CHRATR_FONTSIZE) );
1010 
1011             SvxULSpaceItem aUL( RES_UL_SPACE );
1012             {
1013                 pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
1014                                                 RES_POOLCOLL_TEXT ));
1015                 aUL = pNewColl->GetULSpace();
1016             }
1017             aUL.SetLower( HTML_PARSPACE );
1018             aSet.Put( aUL);
1019             SwFmtLineNumber aLN; aLN.SetCountLines( sal_False );
1020             aSet.Put( aLN );
1021         }
1022         break;
1023 
1024     case RES_POOLCOLL_HTML_DD:
1025         {
1026             SvxLRSpaceItem aLR( RES_LR_SPACE );
1027             aLR = pNewColl->GetLRSpace();
1028             // es wird um 1cm eingerueckt. Die IDs liegen immer 2 auseinander!
1029             aLR.SetLeft( GetMetricVal( CM_1 ));
1030             aSet.Put( aLR );
1031         }
1032         break;
1033     case RES_POOLCOLL_HTML_DT:
1034         {
1035             SvxLRSpaceItem aLR( RES_LR_SPACE );
1036             {
1037                 pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool(
1038                                                     RES_POOLCOLL_HTML_DD ));
1039                 aLR = pNewColl->GetLRSpace();
1040             }
1041             // es wird um 0cm eingerueckt. Die IDs liegen immer 2 auseinander!
1042             aLR.SetLeft( 0 );
1043             aSet.Put( aLR );
1044         }
1045         break;
1046     }
1047 
1048     if( aSet.Count() )
1049     {
1050         {
1051             pNewColl->SetFmtAttr( aSet );
1052             // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation
1053             //				(Bug: 18545)
1054             // SetModified();
1055         }
1056     }
1057     return pNewColl;
1058 }
1059 
1060 
1061 
1062     // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
1063     // benutzt wird
IsPoolTxtCollUsed(sal_uInt16 nId) const1064 bool SwDoc::IsPoolTxtCollUsed( sal_uInt16 nId ) const
1065 {
1066     ASSERT(
1067         (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) ||
1068         (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) ||
1069         (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) ||
1070         (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) ||
1071         (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) ||
1072         (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END),
1073             "Falsche AutoFormat-Id" );
1074 
1075     SwTxtFmtColl* pNewColl = 0;
1076     sal_Bool bFnd = sal_False;
1077     for( sal_uInt16 n = 0; !bFnd && n < pTxtFmtCollTbl->Count(); ++n )
1078     {
1079         pNewColl = (*pTxtFmtCollTbl)[ n ];
1080         if( nId == pNewColl->GetPoolFmtId() )
1081             bFnd = sal_True;
1082     }
1083 
1084     if( !bFnd || !pNewColl->GetDepends() )
1085         return sal_False;
1086 
1087     SwAutoFmtGetDocNode aGetHt( &GetNodes() );
1088     return !pNewColl->GetInfo( aGetHt );
1089 }
1090 
1091     // Gebe das "Auto[matische]-Format" mit der Id zurueck. Existiert
1092     // es noch nicht, dann erzeuge es
1093 
GetFmtFromPool(sal_uInt16 nId)1094 SwFmt* SwDoc::GetFmtFromPool( sal_uInt16 nId )
1095 {
1096     SwFmt *pNewFmt = 0;
1097     SwFmt *pDeriveFmt = 0;
1098 
1099     SvPtrarr* pArray[ 2 ];
1100     sal_uInt16 nArrCnt = 1, nRCId = 0;
1101     sal_uInt16* pWhichRange = 0;
1102 
1103     switch( nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
1104     {
1105     case POOLGRP_CHARFMT:
1106         {
1107             pArray[0] = pCharFmtTbl;
1108             pDeriveFmt = pDfltCharFmt;
1109 
1110             if( nId > RES_POOLCHR_NORMAL_END )
1111                 nRCId = RC_POOLCHRFMT_HTML_BEGIN - RES_POOLCHR_HTML_BEGIN;
1112             else
1113                 nRCId = RC_POOLCHRFMT_BEGIN - RES_POOLCHR_BEGIN;
1114             pWhichRange =  aCharFmtSetRange;
1115 
1116             // Fehlerfall: unbekanntes Format, aber CharFormat
1117             //			-> returne das erste
1118             if( RES_POOLCHR_BEGIN > nId || nId >= RES_POOLCHR_END )
1119             {
1120                 ASSERT( sal_False, "<SwDoc::GetFmtFromPool(..)> - unknown page pool ID" );
1121                 nId = RES_POOLCHR_BEGIN;
1122             }
1123         }
1124         break;
1125     case POOLGRP_FRAMEFMT:
1126         {
1127             pArray[0] = pFrmFmtTbl;
1128             pArray[1] = pSpzFrmFmtTbl;
1129             pDeriveFmt = pDfltFrmFmt;
1130             nArrCnt = 2;
1131             nRCId = RC_POOLFRMFMT_BEGIN - RES_POOLFRM_BEGIN;
1132             pWhichRange = aFrmFmtSetRange;
1133 
1134             // Fehlerfall: unbekanntes Format, aber FrameFormat
1135             //			-> returne das erste
1136             if( RES_POOLFRM_BEGIN > nId || nId >= RES_POOLFRM_END )
1137             {
1138                 ASSERT( sal_False, "<SwDoc::GetFmtFromPool(..)> - unknown page pool ID" );
1139                 nId = RES_POOLFRM_BEGIN;
1140             }
1141         }
1142         break;
1143 
1144     default:
1145         // Fehlerfall, unbekanntes Format
1146         ASSERT( nId, "ungueltige Id" );
1147         return 0;
1148     }
1149     ASSERT( nRCId, "ungueltige Id" );
1150 
1151     while( nArrCnt-- )
1152         for( sal_uInt16 n = 0; n < (*pArray[nArrCnt]).Count(); ++n )
1153             if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )->
1154                     GetPoolFmtId() )
1155             {
1156                 return pNewFmt;
1157             }
1158 
1159     ResId aResId( nRCId + nId, *pSwResMgr );
1160     String aNm( aResId );
1161     SwAttrSet aSet( GetAttrPool(), pWhichRange );
1162 
1163     {
1164         sal_Bool bIsModified = IsModified();
1165 
1166         {
1167             ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
1168             switch (nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) )
1169             {
1170                 case POOLGRP_CHARFMT:
1171                     pNewFmt = _MakeCharFmt(aNm, pDeriveFmt, sal_False, sal_True);
1172                 break;
1173                 case POOLGRP_FRAMEFMT:
1174                     pNewFmt = _MakeFrmFmt(aNm, pDeriveFmt, sal_False, sal_True);
1175                 break;
1176                 default:
1177                 break;
1178             }
1179         }
1180 
1181         if( !bIsModified )
1182             ResetModified();
1183         pNewFmt->SetPoolFmtId( nId );
1184         pNewFmt->SetAuto( sal_False );		// kein Auto-Format
1185     }
1186 
1187     switch( nId )
1188     {
1189     case RES_POOLCHR_FOOTNOTE:				// Fussnote
1190     case RES_POOLCHR_PAGENO:				// Seiten/Feld
1191     case RES_POOLCHR_LABEL:					// Beschriftung
1192     case RES_POOLCHR_DROPCAPS: 				// Initialien
1193     case RES_POOLCHR_NUM_LEVEL:				// Aufzaehlungszeichen
1194     case RES_POOLCHR_TOXJUMP:				// Verzeichnissprung
1195     case RES_POOLCHR_ENDNOTE:				// Endnote
1196     case RES_POOLCHR_LINENUM:				// Zeilennummerierung
1197         break;
1198 
1199     case RES_POOLCHR_ENDNOTE_ANCHOR:		// Endnotenanker
1200     case RES_POOLCHR_FOOTNOTE_ANCHOR:		// Fussnotenanker
1201         {
1202             aSet.Put( SvxEscapementItem( DFLT_ESC_AUTO_SUPER, 58, RES_CHRATR_ESCAPEMENT ) );
1203         }
1204         break;
1205 
1206 
1207     case RES_POOLCHR_BUL_LEVEL:				// Aufzaehlungszeichen
1208         {
1209             const Font& rBulletFont = numfunc::GetDefBulletFont();
1210             SetAllScriptItem( aSet, SvxFontItem( rBulletFont.GetFamily(),
1211                       rBulletFont.GetName(), rBulletFont.GetStyleName(),
1212                         rBulletFont.GetPitch(), rBulletFont.GetCharSet(), RES_CHRATR_FONT ));
1213             // --> OD 2008-06-02 #i63395#
1214             // no font and no font size any more
1215 //            SetAllScriptItem( aSet, SvxFontHeightItem( PT_9, 100, RES_CHRATR_FONTSIZE ));
1216             // <--
1217         }
1218         break;
1219 
1220     case RES_POOLCHR_INET_NORMAL:
1221         {
1222             Color aCol( COL_BLUE );
1223             aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1224             aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
1225             // i40133: patch submitted by rail: set language to 'none' to prevent spell checking:
1226             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
1227             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
1228             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
1229         }
1230         break;
1231     case RES_POOLCHR_INET_VISIT:
1232         {
1233             Color aCol( COL_RED );
1234             aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1235             aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) );
1236             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) );
1237             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) );
1238             aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) );
1239         }
1240         break;
1241     case RES_POOLCHR_JUMPEDIT:
1242         {
1243             Color aCol( COL_CYAN );
1244             aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) );
1245             aSet.Put( SvxUnderlineItem( UNDERLINE_DOTTED, RES_CHRATR_UNDERLINE ) );
1246             aSet.Put( SvxCaseMapItem( SVX_CASEMAP_KAPITAELCHEN, RES_CHRATR_CASEMAP ) );
1247         }
1248         break;
1249 
1250     case RES_POOLCHR_RUBYTEXT:
1251         {
1252             long nH = ((SvxFontHeightItem*)GetDfltAttr(
1253                                 RES_CHRATR_CJK_FONTSIZE ))->GetHeight() / 2;
1254             SetAllScriptItem( aSet, SvxFontHeightItem( nH, 100, RES_CHRATR_FONTSIZE));
1255             aSet.Put(SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE ));
1256             aSet.Put(SvxEmphasisMarkItem( EMPHASISMARK_NONE, RES_CHRATR_EMPHASIS_MARK) );
1257         }
1258         break;
1259 
1260     case RES_POOLCHR_HTML_EMPHASIS:
1261     case RES_POOLCHR_HTML_CITIATION:
1262     case RES_POOLCHR_HTML_VARIABLE:
1263         {
1264             SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE) );
1265         }
1266         break;
1267 
1268     case RES_POOLCHR_IDX_MAIN_ENTRY:
1269     case RES_POOLCHR_HTML_STRONG:
1270         {
1271             SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ));
1272         }
1273         break;
1274 
1275     case RES_POOLCHR_HTML_CODE:
1276     case RES_POOLCHR_HTML_SAMPLE:
1277     case RES_POOLCHR_HTML_KEYBOARD:
1278     case RES_POOLCHR_HTML_TELETYPE:
1279         {
1280             ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet );
1281         }
1282         break;
1283    case RES_POOLCHR_VERT_NUM:
1284             aSet.Put( SvxCharRotateItem( 900, sal_False, RES_CHRATR_ROTATE ) );
1285     break;
1286 //nichts besonderes
1287 //	case RES_POOLCHR_HTML_DEFINSTANCE:
1288 //			break;
1289 
1290 
1291     case RES_POOLFRM_FRAME:
1292         {
1293             if ( get(IDocumentSettingAccess::HTML_MODE) )
1294             {
1295                 aSet.Put( SwFmtAnchor( FLY_AS_CHAR ));
1296                 aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::LINE_CENTER, text::RelOrientation::PRINT_AREA ) );
1297                 aSet.Put( SwFmtSurround( SURROUND_NONE ) );
1298             }
1299             else
1300             {
1301                 aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
1302                 aSet.Put( SwFmtSurround( SURROUND_PARALLEL ) );
1303                 aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::PRINT_AREA ) );
1304                 aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::PRINT_AREA ) );
1305                 Color aCol( COL_BLACK );
1306                 SvxBorderLine aLine( &aCol, DEF_LINE_WIDTH_0 );
1307                 SvxBoxItem aBox( RES_BOX );
1308                 aBox.SetLine( &aLine, BOX_LINE_TOP );
1309                 aBox.SetLine( &aLine, BOX_LINE_BOTTOM );
1310                 aBox.SetLine( &aLine, BOX_LINE_LEFT );
1311                 aBox.SetLine( &aLine, BOX_LINE_RIGHT );
1312                 aBox.SetDistance( 85 );
1313                 aSet.Put( aBox );
1314                 aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1315                 aSet.Put( SvxULSpaceItem( 114, 114, RES_UL_SPACE ) );
1316             }
1317 
1318             //UUUU for styles of FlyFrames do not set the FillStyle to make it a derived attribute
1319             aSet.ClearItem(XATTR_FILLSTYLE);
1320         }
1321         break;
1322     case RES_POOLFRM_GRAPHIC:
1323     case RES_POOLFRM_OLE:
1324         {
1325             aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
1326             aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
1327             aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
1328             aSet.Put( SwFmtSurround( SURROUND_NONE ));
1329         }
1330         break;
1331     case RES_POOLFRM_FORMEL:
1332         {
1333             aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) );
1334             aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CHAR_CENTER, text::RelOrientation::FRAME ) );
1335             aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1336         }
1337         break;
1338     case RES_POOLFRM_MARGINAL:
1339         {
1340             aSet.Put( SwFmtAnchor( FLY_AT_PARA ));
1341             aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::FRAME ));
1342             aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
1343             aSet.Put( SwFmtSurround( SURROUND_PARALLEL ));
1344             // Breite 3.5 centimeter vorgegeben, als Hoehe nur den
1345             // min. Wert benutzen
1346             aSet.Put( SwFmtFrmSize( ATT_MIN_SIZE,
1347                     GetMetricVal( CM_1 ) * 3 + GetMetricVal( CM_05 ),
1348                     MM50 ));
1349         }
1350         break;
1351     case RES_POOLFRM_WATERSIGN:
1352         {
1353             aSet.Put( SwFmtAnchor( FLY_AT_PAGE ));
1354             aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME ));
1355             aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CENTER, text::RelOrientation::FRAME ));
1356             aSet.Put( SvxOpaqueItem( sal_False ));
1357             aSet.Put( SwFmtSurround( SURROUND_THROUGHT ));
1358         }
1359         break;
1360 
1361     case RES_POOLFRM_LABEL:
1362         {
1363             aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) );
1364             aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ) );
1365             aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) );
1366 
1367             SvxProtectItem aProtect( RES_PROTECT );
1368             aProtect.SetSizeProtect( sal_True );
1369             aProtect.SetPosProtect( sal_True );
1370             aSet.Put( aProtect );
1371 
1372             pNewFmt->SetAutoUpdateFmt( sal_True );
1373         }
1374         break;
1375     }
1376     if( aSet.Count() )
1377     {
1378         {
1379             pNewFmt->SetFmtAttr( aSet );
1380             // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation
1381             //				(Bug: 18545)
1382             // SetModified();
1383         }
1384     }
1385     return pNewFmt;
1386 }
1387 
GetFrmFmtFromPool(sal_uInt16 nId)1388 SwFrmFmt* SwDoc::GetFrmFmtFromPool( sal_uInt16 nId )
1389 {
1390     return (SwFrmFmt*)GetFmtFromPool( nId );
1391 }
1392 
GetCharFmtFromPool(sal_uInt16 nId)1393 SwCharFmt* SwDoc::GetCharFmtFromPool( sal_uInt16 nId )
1394 {
1395     return (SwCharFmt*)GetFmtFromPool( nId );
1396 }
1397 
1398     // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
1399     // benutzt wird
IsPoolFmtUsed(sal_uInt16 nId) const1400 bool SwDoc::IsPoolFmtUsed( sal_uInt16 nId ) const
1401 {
1402     SwFmt *pNewFmt = 0;
1403     const SvPtrarr* pArray[ 2 ];
1404     sal_uInt16 nArrCnt = 1;
1405     sal_Bool bFnd = sal_True;
1406 
1407     if( RES_POOLCHR_BEGIN <= nId && nId < RES_POOLCHR_END )
1408     {
1409         pArray[0] = pCharFmtTbl;
1410     }
1411     if( RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END )
1412     {
1413         pArray[0] = pFrmFmtTbl;
1414         pArray[1] = pSpzFrmFmtTbl;
1415         nArrCnt = 2;
1416     }
1417     else
1418     {
1419         ASSERT( sal_False, "<SwDoc::IsPoolFmtUsed(..)> - unknown page pool ID" );
1420         bFnd = sal_False;
1421     }
1422 
1423     if( bFnd )
1424     {
1425         bFnd = sal_False;
1426         while( nArrCnt-- && !bFnd )
1427             for( sal_uInt16 n = 0; !bFnd && n < (*pArray[nArrCnt]).Count(); ++n )
1428                 if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )->
1429                         GetPoolFmtId() )
1430                     bFnd = sal_True;
1431     }
1432 
1433     // nicht gefunden oder keine Abhaengigen ?
1434     if( bFnd && pNewFmt->GetDepends() )
1435     {
1436         // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
1437         // (auch indirekte fuer Format-Ableitung! )
1438         SwAutoFmtGetDocNode aGetHt( &GetNodes() );
1439         bFnd = !pNewFmt->GetInfo( aGetHt );
1440     }
1441     else
1442         bFnd = sal_False;
1443 
1444     return bFnd;
1445 }
1446 
1447 
1448 
lcl_PutStdPageSizeIntoItemSet(SwDoc * pDoc,SfxItemSet & rSet)1449 void lcl_PutStdPageSizeIntoItemSet( SwDoc* pDoc, SfxItemSet& rSet )
1450 {
1451     SwPageDesc* pStdPgDsc = pDoc->GetPageDescFromPool( RES_POOLPAGE_STANDARD );
1452     SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
1453     if( pStdPgDsc->GetLandscape() )
1454     {
1455         SwTwips nTmp = aFrmSz.GetHeight();
1456         aFrmSz.SetHeight( aFrmSz.GetWidth() );
1457         aFrmSz.SetWidth( nTmp );
1458     }
1459     rSet.Put( aFrmSz );
1460 }
1461 
GetPageDescFromPool(sal_uInt16 nId,bool bRegardLanguage)1462 SwPageDesc* SwDoc::GetPageDescFromPool( sal_uInt16 nId, bool bRegardLanguage )
1463 {
1464     ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
1465             "Falsche AutoFormat-Id" );
1466 
1467     for( sal_uInt16 n = 0; n < aPageDescs.Count(); ++n )
1468     {
1469         if ( nId == aPageDescs[ n ]->GetPoolFmtId() )
1470         {
1471             return aPageDescs[ n ];
1472         }
1473     }
1474 
1475     if( RES_POOLPAGE_BEGIN > nId ||  nId >= RES_POOLPAGE_END )
1476     {
1477         // unknown page pool ID
1478         ASSERT( sal_False, "<SwDoc::GetPageDescFromPool(..)> - unknown page pool ID" );
1479         nId = RES_POOLPAGE_BEGIN;
1480     }
1481 
1482     SwPageDesc* pNewPgDsc = 0;
1483     {
1484         const ResId aResId( sal_uInt32(RC_POOLPAGEDESC_BEGIN + nId - RES_POOLPAGE_BEGIN), *pSwResMgr );
1485         const String aNm( aResId );
1486         const bool bIsModified = IsModified();
1487 
1488         sal_uInt16 nPageDescIdx = 0;
1489         {
1490             ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
1491             nPageDescIdx = MakePageDesc( aNm, 0, bRegardLanguage );
1492         }
1493 
1494         pNewPgDsc = aPageDescs[ nPageDescIdx ];
1495         pNewPgDsc->SetPoolFmtId( nId );
1496         if ( !bIsModified )
1497         {
1498             ResetModified();
1499         }
1500     }
1501 
1502     SvxLRSpaceItem aLR( RES_LR_SPACE );
1503     {
1504         aLR.SetLeft( GetMetricVal( CM_1 ) * 2 );
1505         aLR.SetRight( aLR.GetLeft() );
1506     }
1507     SvxULSpaceItem aUL( RES_UL_SPACE );
1508     {
1509         aUL.SetUpper( (sal_uInt16)aLR.GetLeft() );
1510         aUL.SetLower( (sal_uInt16)aLR.GetLeft() );
1511     }
1512 
1513     SwAttrSet aSet( GetAttrPool(), aPgFrmFmtSetRange );
1514     bool bSetLeft = true;
1515 
1516     switch( nId )
1517     {
1518     case RES_POOLPAGE_STANDARD:     // "Default"
1519         {
1520             aSet.Put( aLR );
1521             aSet.Put( aUL );
1522             if( pNewPgDsc )
1523                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1524         }
1525         break;
1526 
1527     case RES_POOLPAGE_FIRST:        // "First Page"
1528     case RES_POOLPAGE_REGISTER:     // "Index"
1529         {
1530             lcl_PutStdPageSizeIntoItemSet( this, aSet );
1531             aSet.Put( aLR );
1532             aSet.Put( aUL );
1533             if( pNewPgDsc )
1534             {
1535                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1536                 if( RES_POOLPAGE_FIRST == nId )
1537                     pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_STANDARD ));
1538             }
1539         }
1540         break;
1541 
1542     case RES_POOLPAGE_LEFT:         // "Left Page"
1543         {
1544             lcl_PutStdPageSizeIntoItemSet( this, aSet );
1545             aSet.Put( aLR );
1546             aSet.Put( aUL );
1547             bSetLeft = false;
1548             if( pNewPgDsc )
1549                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_LEFT );
1550         }
1551         break;
1552     case RES_POOLPAGE_RIGHT:        // "Right Page"
1553         {
1554             lcl_PutStdPageSizeIntoItemSet( this, aSet );
1555             aSet.Put( aLR );
1556             aSet.Put( aUL );
1557             bSetLeft = false;
1558             if( pNewPgDsc )
1559                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_RIGHT );
1560         }
1561         break;
1562 
1563     case RES_POOLPAGE_JAKET:        // "Envelope"
1564         {
1565             Size aPSize( SvxPaperInfo::GetPaperSize( PAPER_ENV_C65 ) );
1566             LandscapeSwap( aPSize );
1567             aSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, aPSize.Width(), aPSize.Height() ));
1568             aLR.SetLeft( 0 ); aLR.SetRight( 0 );
1569             aUL.SetUpper( 0 ); aUL.SetLower( 0 );
1570             aSet.Put( aLR );
1571             aSet.Put( aUL );
1572 
1573             if( pNewPgDsc )
1574             {
1575                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1576                 pNewPgDsc->SetLandscape( sal_True );
1577             }
1578         }
1579         break;
1580 
1581     case RES_POOLPAGE_HTML:         // "HTML"
1582         {
1583             lcl_PutStdPageSizeIntoItemSet( this, aSet );
1584             aLR.SetRight( GetMetricVal( CM_1 ));
1585             aUL.SetUpper( (sal_uInt16)aLR.GetRight() );
1586             aUL.SetLower( (sal_uInt16)aLR.GetRight() );
1587             aSet.Put( aLR );
1588             aSet.Put( aUL );
1589 
1590             if( pNewPgDsc )
1591                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1592         }
1593         break;
1594 
1595     case RES_POOLPAGE_FOOTNOTE:     // "Footnote"
1596     case RES_POOLPAGE_ENDNOTE:      // "Endnote"
1597         {
1598             lcl_PutStdPageSizeIntoItemSet( this, aSet );
1599             aSet.Put( aLR );
1600             aSet.Put( aUL );
1601             if( pNewPgDsc )
1602                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1603             SwPageFtnInfo aInf( pNewPgDsc->GetFtnInfo() );
1604             aInf.SetLineWidth( 0 );
1605             aInf.SetTopDist( 0 );
1606             aInf.SetBottomDist( 0 );
1607             pNewPgDsc->SetFtnInfo( aInf );
1608         }
1609         break;
1610 
1611     case RES_POOLPAGE_LANDSCAPE:    // "Landscape"
1612         {
1613             SwPageDesc* pStdPgDsc = this->GetPageDescFromPool( RES_POOLPAGE_STANDARD );
1614             SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() );
1615             if ( !pStdPgDsc->GetLandscape() )
1616             {
1617                 const SwTwips nTmp = aFrmSz.GetHeight();
1618                 aFrmSz.SetHeight( aFrmSz.GetWidth() );
1619                 aFrmSz.SetWidth( nTmp );
1620             }
1621             aSet.Put( aFrmSz );
1622             aSet.Put( aLR );
1623             aSet.Put( aUL );
1624             if( pNewPgDsc )
1625             {
1626                 pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL );
1627                 pNewPgDsc->SetLandscape( sal_True );
1628             }
1629         }
1630         break;
1631 
1632     }
1633 
1634     if( aSet.Count() )
1635     {
1636         if( bSetLeft )
1637             pNewPgDsc->GetLeft().SetFmtAttr( aSet );
1638         pNewPgDsc->GetMaster().SetFmtAttr( aSet );
1639     }
1640     return pNewPgDsc;
1641 }
1642 
GetNumRuleFromPool(sal_uInt16 nId)1643 SwNumRule* SwDoc::GetNumRuleFromPool( sal_uInt16 nId )
1644 {
1645     ASSERT( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END,
1646             "Falsche AutoFormat-Id" );
1647 
1648     SwNumRule* pNewRule;
1649     sal_uInt16 n;
1650 
1651     for( n = 0; n < GetNumRuleTbl().Count(); ++n )
1652         if( nId == ( pNewRule = GetNumRuleTbl()[ n ] )->GetPoolFmtId() )
1653         {
1654             return pNewRule;
1655         }
1656 
1657     // Fehlerfall: unbekannte Poolvorlage
1658     if( RES_POOLNUMRULE_BEGIN > nId ||  nId >= RES_POOLNUMRULE_END )
1659     {
1660         ASSERT( sal_False, "<SwDoc::GetNumRuleFromPool(..)> - unknown page pool ID" );
1661         nId = RES_POOLNUMRULE_BEGIN;
1662     }
1663 
1664     ResId aResId( sal_uInt32(RC_POOLNUMRULE_BEGIN + nId - RES_POOLNUMRULE_BEGIN), *pSwResMgr );
1665     String aNm( aResId );
1666 
1667     SwCharFmt *pNumCFmt = 0, *pBullCFmt = 0;
1668 
1669     // --> OD 2008-02-11 #newlistlevelattrs#
1670     const SvxNumberFormat::SvxNumPositionAndSpaceMode eNumberFormatPositionAndSpaceMode
1671                                   // --> OD 2008-06-06 #i89178#
1672                                   = numfunc::GetDefaultPositionAndSpaceMode();
1673                                   // <--
1674     // <--
1675     {
1676         sal_Bool bIsModified = IsModified();
1677         // --> OD 2008-02-11 #newlistlevelattrs#
1678         n = MakeNumRule( aNm, 0, sal_False, eNumberFormatPositionAndSpaceMode );
1679         // <--
1680         pNewRule = GetNumRuleTbl()[ n ];
1681         pNewRule->SetPoolFmtId( nId );
1682         pNewRule->SetAutoRule( sal_False );
1683 
1684         if( RES_POOLNUMRULE_NUM1 <= nId && nId <= RES_POOLNUMRULE_NUM5 )
1685             pNumCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL );
1686 
1687         if( ( RES_POOLNUMRULE_BUL1 <= nId && nId <= RES_POOLNUMRULE_BUL5 ) ||
1688             RES_POOLNUMRULE_NUM5 == nId )
1689             pBullCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL );
1690 
1691         if( !bIsModified )
1692             ResetModified();
1693     }
1694 
1695     switch( nId )
1696     {
1697     case RES_POOLNUMRULE_NUM1:
1698         {
1699             SwNumFmt aFmt;
1700             // --> OD 2008-02-11 #newlistlevelattrs#
1701             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1702             // <--
1703             aFmt.SetNumberingType(SVX_NUM_ARABIC);
1704             aFmt.SetCharFmt( pNumCFmt );
1705             aFmt.SetStart( 1 );
1706             aFmt.SetIncludeUpperLevels( 1 );
1707             aFmt.SetSuffix( aDotStr );
1708 
1709             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1710                 {
1711 //				cm: 0,5  1,0  1,5  2,0   2,5   3,0   3,5   4,0   4,5   5,0
1712                     283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1713                 };
1714 #ifdef USE_MEASUREMENT
1715             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
1716                 {
1717                     283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1718                 };
1719             const sal_uInt16* pArr = MEASURE_METRIC ==
1720                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
1721                                     ? aAbsSpace
1722                                     : aAbsSpaceInch;
1723 #else
1724             const sal_uInt16* pArr = aAbsSpace;
1725 #endif
1726 
1727             // --> OD 2008-02-11 #newlistlevelattrs#
1728             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1729             {
1730                 aFmt.SetFirstLineOffset( - (*pArr) );
1731             }
1732             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1733             {
1734                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1735                 aFmt.SetFirstLineIndent( - (*pArr) );
1736             }
1737             // <--
1738             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
1739             {
1740                 // --> OD 2008-02-11 #newlistlevelattrs#
1741                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1742                 {
1743                     aFmt.SetAbsLSpace( *pArr );
1744                 }
1745                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1746                 {
1747                     aFmt.SetListtabPos( *pArr );
1748                     aFmt.SetIndentAt( *pArr );
1749                 }
1750                 // <--
1751                 pNewRule->Set( n, aFmt );
1752             }
1753         }
1754         break;
1755 
1756     case RES_POOLNUMRULE_NUM2:
1757         {
1758             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1759                 {
1760                     283,  283,  567,  709,		// 0.50, 0.50, 1.00, 1.25
1761                     850, 1021, 1304, 1474,		// 1.50, 1.80, 2.30, 2.60
1762                    1588, 1758					// 2.80, 3.10
1763                 };
1764 
1765 #ifdef USE_MEASUREMENT
1766             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
1767                 {
1768                     385,  385,  770,  963,
1769                    1155, 1386, 1771, 2002,
1770                    2156, 2387
1771                 };
1772 
1773             const sal_uInt16* pArr = MEASURE_METRIC ==
1774                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
1775                                     ? aAbsSpace
1776                                     : aAbsSpaceInch;
1777 #else
1778             const sal_uInt16* pArr = aAbsSpace;
1779 #endif
1780             SwNumFmt aFmt;
1781             // --> OD 2008-02-11 #newlistlevelattrs#
1782             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1783             // <--
1784             aFmt.SetNumberingType(SVX_NUM_ARABIC);
1785             aFmt.SetCharFmt( pNumCFmt );
1786             aFmt.SetIncludeUpperLevels( 1 );
1787             // --> OD 2008-02-11 #newlistlevelattrs#
1788             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1789             {
1790                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1791             }
1792             // <--
1793             sal_uInt16 nSpace = 0;
1794             for( n = 0; n < MAXLEVEL; ++n )
1795             {
1796                 // --> OD 2008-02-11 #newlistlevelattrs#
1797                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1798                 {
1799                     aFmt.SetAbsLSpace( nSpace = nSpace + pArr[ n ] );
1800                     aFmt.SetFirstLineOffset( - pArr[ n ] );
1801                 }
1802                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1803                 {
1804                     aFmt.SetListtabPos( nSpace = nSpace + pArr[ n ] );
1805                     aFmt.SetIndentAt( nSpace );
1806                     aFmt.SetFirstLineIndent( - pArr[ n ] );
1807                 }
1808                 // <--
1809                 aFmt.SetStart( n+1 );
1810                 pNewRule->Set( n, aFmt );
1811             }
1812         }
1813         break;
1814     case RES_POOLNUMRULE_NUM3:
1815         {
1816             SwNumFmt aFmt;
1817             // --> OD 2008-02-11 #newlistlevelattrs#
1818             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1819             // <--
1820             aFmt.SetNumberingType(SVX_NUM_ARABIC);
1821             aFmt.SetCharFmt( pNumCFmt );
1822             aFmt.SetIncludeUpperLevels( 1 );
1823 
1824             sal_uInt16 nOffs = GetMetricVal( CM_1 ) * 3;
1825             // --> OD 2008-02-11 #newlistlevelattrs#
1826             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1827             {
1828                 aFmt.SetFirstLineOffset( - nOffs );
1829             }
1830             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1831             {
1832                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1833                 aFmt.SetFirstLineIndent( - nOffs );
1834             }
1835             // <--
1836 
1837             for( n = 0; n < MAXLEVEL; ++n )
1838             {
1839                 // --> OD 2008-02-11 #newlistlevelattrs#
1840                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1841                 {
1842                     aFmt.SetAbsLSpace( (n+1) * nOffs );
1843                 }
1844                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1845                 {
1846                     aFmt.SetListtabPos( (n+1) * nOffs );
1847                     aFmt.SetIndentAt( (n+1) * nOffs );
1848                 }
1849                 // <--
1850                 aFmt.SetStart( n+1 );
1851                 pNewRule->Set( n, aFmt );
1852             }
1853         }
1854         break;
1855     case RES_POOLNUMRULE_NUM4:
1856         {
1857             SwNumFmt aFmt;
1858             // --> OD 2008-02-11 #newlistlevelattrs#
1859             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1860             // <--
1861             aFmt.SetNumberingType(SVX_NUM_ROMAN_UPPER);
1862             aFmt.SetCharFmt( pNumCFmt );
1863             aFmt.SetIncludeUpperLevels( 1 );
1864             aFmt.SetSuffix( aDotStr );
1865 
1866             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
1867                 {
1868 //				cm: 0,5  1,0  1,5  2,0   2,5   3,0   3,5   4,0   4,5   5,0
1869                     283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1870                 };
1871 #ifdef USE_MEASUREMENT
1872             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
1873                 {
1874                     283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835
1875                 };
1876             const sal_uInt16* pArr = MEASURE_METRIC ==
1877                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
1878                                     ? aAbsSpace
1879                                     : aAbsSpaceInch;
1880 #else
1881             const sal_uInt16* pArr = aAbsSpace;
1882 #endif
1883 
1884             // --> OD 2008-02-11 #newlistlevelattrs#
1885             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1886             {
1887                 aFmt.SetFirstLineOffset( - (*pArr) );
1888             }
1889             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1890             {
1891                 aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE );
1892                 aFmt.SetFirstLineIndent( - (*pArr) );
1893             }
1894             // <--
1895             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
1896             {
1897                 aFmt.SetStart( n + 1 );
1898                 // --> OD 2008-02-11 #newlistlevelattrs#
1899                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1900                 {
1901                     aFmt.SetAbsLSpace( *pArr );
1902                 }
1903                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1904                 {
1905                     aFmt.SetListtabPos( *pArr );
1906                     aFmt.SetIndentAt( *pArr );
1907                 }
1908                 // <--
1909                 pNewRule->Set( n, aFmt );
1910             }
1911         }
1912         break;
1913     case RES_POOLNUMRULE_NUM5:
1914         {
1915             // [ First, LSpace ]
1916             static const sal_uInt16 aAbsSpace0to2[] =
1917                 {
1918                     227,  227,  	// 0.40, 0.40,
1919                     369,  624,		// 0.65, 1.10,
1920                     255,  879 		// 0.45, 1.55
1921                 };
1922 
1923 #ifdef USE_MEASUREMENT
1924             static const sal_uInt16 aAbsSpaceInch0to2[] =
1925                 {
1926                     308,  308,
1927                     501,  847,
1928                     347, 1194
1929                 };
1930             const sal_uInt16* pArr0to2 = MEASURE_METRIC ==
1931                             SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
1932                                 ? aAbsSpace0to2
1933                                 : aAbsSpaceInch0to2;
1934 #else
1935             const sal_uInt16* pArr0to2 = aAbsSpace0to2;
1936 #endif
1937             SwNumFmt aFmt;
1938             // --> OD 2008-02-11 #newlistlevelattrs#
1939             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
1940             // <--
1941             aFmt.SetNumberingType(SVX_NUM_ARABIC);
1942             aFmt.SetStart( 1 );
1943             aFmt.SetIncludeUpperLevels( 1 );
1944             aFmt.SetSuffix( aDotStr );
1945             // --> OD 2008-02-11 #newlistlevelattrs#
1946             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1947             {
1948                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
1949             }
1950             // <--
1951 
1952             // --> OD 2008-02-11 #newlistlevelattrs#
1953             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1954             {
1955                 aFmt.SetFirstLineOffset( -pArr0to2[0] );    // == 0.40 cm
1956                 aFmt.SetAbsLSpace( pArr0to2[1] );           // == 0.40 cm
1957             }
1958             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1959             {
1960                 aFmt.SetFirstLineIndent( -pArr0to2[0] );
1961                 aFmt.SetListtabPos( pArr0to2[1] );
1962                 aFmt.SetIndentAt( pArr0to2[1] );
1963             }
1964             // <--
1965 
1966             aFmt.SetCharFmt( pNumCFmt );
1967             pNewRule->Set( 0, aFmt );
1968 
1969             aFmt.SetIncludeUpperLevels( 2 );
1970             aFmt.SetStart( 2 );
1971             // --> OD 2008-02-11 #newlistlevelattrs#
1972             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1973             {
1974                 aFmt.SetFirstLineOffset( -pArr0to2[2] );    // == 0.65 cm
1975                 aFmt.SetAbsLSpace( pArr0to2[3] );           // == 1.10 cm
1976             }
1977             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1978             {
1979                 aFmt.SetFirstLineIndent( -pArr0to2[2] );
1980                 aFmt.SetListtabPos( pArr0to2[3] );
1981                 aFmt.SetIndentAt( pArr0to2[3] );
1982             }
1983             // <--
1984             pNewRule->Set( 1, aFmt );
1985 
1986             aFmt.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER);
1987             aFmt.SetSuffix( ')');
1988             aFmt.SetIncludeUpperLevels( 1 );
1989             aFmt.SetStart( 3 );
1990             // --> OD 2008-02-11 #newlistlevelattrs#
1991             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1992             {
1993                 aFmt.SetFirstLineOffset( - pArr0to2[4] );   // == 0.45cm
1994                 aFmt.SetAbsLSpace( pArr0to2[5] );           // == 1.55 cm
1995             }
1996             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
1997             {
1998                 aFmt.SetFirstLineIndent( -pArr0to2[4] );
1999                 aFmt.SetListtabPos( pArr0to2[5] );
2000                 aFmt.SetIndentAt( pArr0to2[5] );
2001             }
2002             // <--
2003             pNewRule->Set( 2, aFmt );
2004 
2005 
2006             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2007             aFmt.SetCharFmt( pBullCFmt );
2008             // --> OD 2006-06-29 #6440955#
2009             aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
2010             // <--
2011             aFmt.SetBulletChar( cBulletChar );
2012             sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4,
2013                    nOffs2 = GetMetricVal( CM_1 ) * 2;
2014 
2015             // --> OD 2008-02-11 #newlistlevelattrs#
2016             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2017             {
2018                 aFmt.SetFirstLineOffset( - nOffs );
2019             }
2020             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2021             {
2022                 aFmt.SetFirstLineIndent( - nOffs );
2023             }
2024             // <--
2025             aFmt.SetSuffix( aEmptyStr );
2026             for( n = 3; n < MAXLEVEL; ++n )
2027             {
2028                 aFmt.SetStart( n+1 );
2029                 // --> OD 2008-02-11 #newlistlevelattrs#
2030                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2031                 {
2032                     aFmt.SetAbsLSpace( nOffs2 + ((n-3) * nOffs) );
2033                 }
2034                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2035                 {
2036                     aFmt.SetListtabPos( nOffs2 + ((n-3) * nOffs) );
2037                     aFmt.SetIndentAt( nOffs2 + ((n-3) * nOffs) );
2038                 }
2039                 // <--
2040                 pNewRule->Set( n, aFmt );
2041             }
2042         }
2043         break;
2044 
2045     case RES_POOLNUMRULE_BUL1:
2046         {
2047             SwNumFmt aFmt;
2048             // --> OD 2008-02-11 #newlistlevelattrs#
2049             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2050             // <--
2051             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2052             aFmt.SetCharFmt( pBullCFmt );
2053             aFmt.SetStart( 1 );
2054             aFmt.SetIncludeUpperLevels( 1 );
2055             // --> OD 2006-06-29 #6440955#
2056             aFmt.SetBulletFont( &numfunc::GetDefBulletFont() );
2057             // <--
2058             aFmt.SetBulletChar( cBulletChar );
2059 
2060             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2061                 {
2062 //				cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
2063                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2064                 };
2065 #ifdef USE_MEASUREMENT
2066             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
2067                 {
2068                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2069                 };
2070             const sal_uInt16* pArr = MEASURE_METRIC ==
2071                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
2072                                     ? aAbsSpace
2073                                     : aAbsSpaceInch;
2074 #else
2075             const sal_uInt16* pArr = aAbsSpace;
2076 #endif
2077 
2078             // --> OD 2008-02-11 #newlistlevelattrs#
2079             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2080             {
2081                 aFmt.SetFirstLineOffset( - (*pArr) );
2082             }
2083             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2084             {
2085                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
2086                 aFmt.SetFirstLineIndent( - (*pArr) );
2087             }
2088             // <--
2089             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
2090             {
2091                 // --> OD 2008-02-11 #newlistlevelattrs#
2092                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2093                 {
2094                     aFmt.SetAbsLSpace( *pArr );
2095                 }
2096                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2097                 {
2098                     aFmt.SetListtabPos( *pArr );
2099                     aFmt.SetIndentAt( *pArr );
2100                 }
2101                 // <--
2102                 pNewRule->Set( n, aFmt );
2103             }
2104         }
2105         break;
2106     case RES_POOLNUMRULE_BUL2:
2107         {
2108             SwNumFmt aFmt;
2109             // --> OD 2008-02-11 #newlistlevelattrs#
2110             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2111             // <--
2112             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2113             aFmt.SetCharFmt( pBullCFmt );
2114             aFmt.SetStart( 1 );
2115             aFmt.SetIncludeUpperLevels( 1 );
2116             // --> OD 2006-06-29 #6440955#
2117             aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
2118             // <--
2119             aFmt.SetBulletChar( 0x2013 );
2120 
2121             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2122                 {
2123 //				cm: 0,3  0,6  0,9  1,2  1,5  1,8   2,1   2,4   2,7   3,0
2124                     170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701
2125                 };
2126 #ifdef USE_MEASUREMENT
2127             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
2128                 {
2129                     170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701
2130                 };
2131             const sal_uInt16* pArr = MEASURE_METRIC ==
2132                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
2133                                     ? aAbsSpace
2134                                     : aAbsSpaceInch;
2135 #else
2136             const sal_uInt16* pArr = aAbsSpace;
2137 #endif
2138 
2139             // --> OD 2008-02-11 #newlistlevelattrs#
2140             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2141             {
2142                 aFmt.SetFirstLineOffset( - (*pArr) );
2143             }
2144             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2145             {
2146                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
2147                 aFmt.SetFirstLineIndent( - (*pArr) );
2148             }
2149             // <--
2150             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
2151             {
2152                 // --> OD 2008-02-11 #newlistlevelattrs#
2153                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2154                 {
2155                     aFmt.SetAbsLSpace( *pArr );
2156                 }
2157                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2158                 {
2159                     aFmt.SetListtabPos( *pArr );
2160                     aFmt.SetIndentAt( *pArr );
2161                 }
2162                 // <--
2163                 pNewRule->Set( n, aFmt );
2164             }
2165         }
2166         break;
2167     case RES_POOLNUMRULE_BUL3:
2168         {
2169             SwNumFmt aFmt;
2170             // --> OD 2008-02-11 #newlistlevelattrs#
2171             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2172             // <--
2173             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2174             aFmt.SetCharFmt( pBullCFmt );
2175             aFmt.SetStart( 1 );
2176             aFmt.SetIncludeUpperLevels( 1 );
2177             // --> OD 2006-06-29 #6440955#
2178             aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
2179             // <--
2180 
2181             sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4;
2182             // --> OD 2008-02-11 #newlistlevelattrs#
2183             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2184             {
2185                 aFmt.SetFirstLineOffset( - nOffs );
2186             }
2187             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2188             {
2189                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
2190                 aFmt.SetFirstLineIndent( - nOffs );
2191             }
2192             // <--
2193 
2194             for( n = 0; n < MAXLEVEL; ++n )
2195             {
2196                 aFmt.SetBulletChar( ( n & 1 ? 0x25a1 : 0x2611 ) );
2197                 // --> OD 2008-02-11 #newlistlevelattrs#
2198                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2199                 {
2200                     aFmt.SetAbsLSpace( ((n & 1) +1) * nOffs );
2201                 }
2202                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2203                 {
2204                     aFmt.SetListtabPos( ((n & 1) +1) * nOffs );
2205                     aFmt.SetIndentAt( ((n & 1) +1) * nOffs );
2206                 }
2207                 // <--
2208                 pNewRule->Set( n, aFmt );
2209             }
2210         }
2211         break;
2212     case RES_POOLNUMRULE_BUL4:
2213         {
2214             SwNumFmt aFmt;
2215             // --> OD 2008-02-11 #newlistlevelattrs#
2216             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2217             // <--
2218             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2219             aFmt.SetCharFmt( pBullCFmt );
2220             aFmt.SetStart( 1 );
2221             aFmt.SetIncludeUpperLevels( 1 );
2222             // --> OD 2006-06-29 #6440955#
2223             aFmt.SetBulletFont(  &numfunc::GetDefBulletFont() );
2224             // <--
2225 
2226             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2227                 {
2228 //				cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
2229                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2230                 };
2231 #ifdef USE_MEASUREMENT
2232             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
2233                 {
2234                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2235                 };
2236             const sal_uInt16* pArr = MEASURE_METRIC ==
2237                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
2238                                     ? aAbsSpace
2239                                     : aAbsSpaceInch;
2240 #else
2241             const sal_uInt16* pArr = aAbsSpace;
2242 #endif
2243 
2244             // --> OD 2008-02-11 #newlistlevelattrs#
2245             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2246             {
2247                 aFmt.SetFirstLineOffset( - (*pArr) );
2248             }
2249             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2250             {
2251                 aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE );
2252                 aFmt.SetFirstLineIndent( - (*pArr) );
2253             }
2254             // <--
2255             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
2256             {
2257                 switch( n )
2258                 {
2259                 case 0: 	aFmt.SetBulletChar( 0x27a2 );	break;
2260                 case 1:		aFmt.SetBulletChar( 0xE006 );	break;
2261                 default:	aFmt.SetBulletChar( 0xE004 );	break;
2262                 }
2263                 // --> OD 2008-02-11 #newlistlevelattrs#
2264                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2265                 {
2266                     aFmt.SetAbsLSpace( *pArr );
2267                 }
2268                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2269                 {
2270                     aFmt.SetListtabPos( *pArr );
2271                     aFmt.SetIndentAt( *pArr );
2272                 }
2273                 // <--
2274                 pNewRule->Set( n, aFmt );
2275             }
2276         }
2277         break;
2278     case RES_POOLNUMRULE_BUL5:
2279         {
2280             SwNumFmt aFmt;
2281             // --> OD 2008-02-11 #newlistlevelattrs#
2282             aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode );
2283             // <--
2284             aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2285             aFmt.SetCharFmt( pBullCFmt );
2286             aFmt.SetStart( 1 );
2287             aFmt.SetIncludeUpperLevels( 1 );
2288             aFmt.SetBulletChar( 0x2717 );
2289             // --> OD 2006-06-29 #6440955#
2290             aFmt.SetBulletFont( &numfunc::GetDefBulletFont() );
2291             // <--
2292 
2293             static const sal_uInt16 aAbsSpace[ MAXLEVEL ] =
2294                 {
2295 //				cm: 0,4  0,8  1,2  1,6  2,0   2,4   2,8   3,2   3,6   4,0
2296                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2297                 };
2298 #ifdef USE_MEASUREMENT
2299             static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] =
2300                 {
2301                     227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268
2302                 };
2303             const sal_uInt16* pArr = MEASURE_METRIC ==
2304                                 SvtSysLocale().GetLocaleData().getMeasurementSystemEnum()
2305                                     ? aAbsSpace
2306                                     : aAbsSpaceInch;
2307 #else
2308             const sal_uInt16* pArr = aAbsSpace;
2309 #endif
2310 
2311             // --> OD 2008-02-11 #newlistlevelattrs#
2312             if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2313             {
2314                 aFmt.SetFirstLineOffset( - (*pArr) );
2315             }
2316             else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2317             {
2318                 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
2319                 aFmt.SetFirstLineIndent( - (*pArr) );
2320             }
2321             // <--
2322             for( n = 0; n < MAXLEVEL; ++n, ++pArr )
2323             {
2324                 // --> OD 2008-02-11 #newlistlevelattrs#
2325                 if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
2326                 {
2327                     aFmt.SetAbsLSpace( *pArr );
2328                 }
2329                 else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
2330                 {
2331                     aFmt.SetListtabPos( *pArr );
2332                     aFmt.SetIndentAt( *pArr );
2333                 }
2334                 // <--
2335                 pNewRule->Set( n, aFmt );
2336             }
2337         }
2338         break;
2339     }
2340 
2341     return pNewRule;
2342 }
2343 
2344 
2345 
2346     // pruefe, ob diese "Auto-Collection" in Dokument schon/noch
2347     // benutzt wird
IsPoolPageDescUsed(sal_uInt16 nId) const2348 bool SwDoc::IsPoolPageDescUsed( sal_uInt16 nId ) const
2349 {
2350     ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END,
2351             "Falsche AutoFormat-Id" );
2352     SwPageDesc *pNewPgDsc = 0;
2353     sal_Bool bFnd = sal_False;
2354     for( sal_uInt16 n = 0; !bFnd && n < aPageDescs.Count(); ++n )
2355     {
2356         pNewPgDsc = aPageDescs[ n ];
2357         if( nId == pNewPgDsc->GetPoolFmtId() )
2358             bFnd = sal_True;
2359     }
2360 
2361     // nicht gefunden oder keine Abhaengigen ?
2362     if( !bFnd || !pNewPgDsc->GetDepends() )		// ??????
2363         return sal_False;
2364 
2365     // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
2366     // (auch indirekte fuer Format-Ableitung! )
2367     SwAutoFmtGetDocNode aGetHt( &GetNodes() );
2368     return !pNewPgDsc->GetInfo( aGetHt );
2369 }
2370 
2371 // erfrage ob die Absatz-/Zeichen-/Rahmen-/Seiten - Vorlage benutzt wird
IsUsed(const SwModify & rModify) const2372 sal_Bool SwDoc::IsUsed( const SwModify& rModify ) const
2373 {
2374     // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
2375     // (auch indirekte fuer Format-Ableitung! )
2376     SwAutoFmtGetDocNode aGetHt( &GetNodes() );
2377     return !rModify.GetInfo( aGetHt );
2378 }
2379 
2380 // erfrage ob die NumRule benutzt wird
IsUsed(const SwNumRule & rRule) const2381 sal_Bool SwDoc::IsUsed( const SwNumRule& rRule ) const
2382 {
2383     // --> OD 2008-03-04 #refactorlists#
2384 //    // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt
2385 //    // (auch indirekte fuer Format-Ableitung! )
2386 //    sal_Bool bUsed = sal_False;
2387 //    SwAutoFmtGetDocNode aGetHt( &aNodes );
2388 //    SwModify* pMod;
2389 //    const SfxPoolItem* pItem;
2390 //    sal_uInt16 i, nMaxItems = GetAttrPool().GetItemCount( RES_PARATR_NUMRULE);
2391 //    for( i = 0; i < nMaxItems; ++i )
2392 //    {
2393 //        if( 0 != (pItem = GetAttrPool().GetItem( RES_PARATR_NUMRULE, i ) ) &&
2394 //            0 != ( pMod = (SwModify*)((SwNumRuleItem*)pItem)->GetDefinedIn()) &&
2395 //            ((SwNumRuleItem*)pItem)->GetValue().Len() &&
2396 //            ((SwNumRuleItem*)pItem)->GetValue() == rRule.GetName() )
2397 //        {
2398 //            if( pMod->IsA( TYPE( SwFmt )) )
2399 //            {
2400 //                bUsed = !pMod->GetInfo( aGetHt );
2401 //                if( bUsed )
2402 //                    break;
2403 //            }
2404 //            else if( ((SwTxtNode*)pMod)->GetNodes().IsDocNodes() )
2405 //            {
2406 //                bUsed = sal_True;
2407 //                break;
2408 //            }
2409 //        }
2410 //    }
2411 
2412 //    return bUsed;
2413     sal_Bool bUsed = rRule.GetTxtNodeListSize() > 0 ||
2414                      rRule.GetParagraphStyleListSize() > 0;
2415 
2416     return bUsed;
2417     // <--
2418 }
2419 
2420     // Suche die Position vom Vorlagen-Namen. Ist nicht vorhanden
2421     // dann fuege neu ein
SetDocPattern(const String & rPatternName)2422 sal_uInt16 SwDoc::SetDocPattern( const String& rPatternName )
2423 {
2424     ASSERT( rPatternName.Len(), "kein Dokument-Vorlagenname" );
2425 
2426     sal_uInt16 nNewPos = aPatternNms.Count();
2427     for( sal_uInt16 n = 0; n < aPatternNms.Count(); ++n )
2428         if( !aPatternNms[n] )
2429         {
2430             if( nNewPos == aPatternNms.Count() )
2431                 nNewPos = n;
2432         }
2433         else if( rPatternName == *aPatternNms[n] )
2434             return n;
2435 
2436     if( nNewPos < aPatternNms.Count() )
2437         aPatternNms.Remove( nNewPos );		// Platz wieder frei machen
2438 
2439     String* pNewNm = new String( rPatternName );
2440     aPatternNms.Insert( pNewNm, nNewPos );
2441     SetModified();
2442     return nNewPos;
2443 }
2444 
GetPoolParent(sal_uInt16 nId)2445 sal_uInt16 GetPoolParent( sal_uInt16 nId )
2446 {
2447     sal_uInt16 nRet = USHRT_MAX;
2448     if( POOLGRP_NOCOLLID & nId )		// 1 == Formate / 0 == Collections
2449     {
2450         switch( ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID ) & nId )
2451         {
2452         case POOLGRP_CHARFMT:
2453         case POOLGRP_FRAMEFMT:
2454             nRet = 0; 			// vom default abgeleitet
2455             break;
2456         case POOLGRP_PAGEDESC:
2457         case POOLGRP_NUMRULE:
2458             break;				// es gibt keine Ableitung
2459         }
2460     }
2461     else
2462     {
2463         switch( COLL_GET_RANGE_BITS & nId )
2464         {
2465         case COLL_TEXT_BITS:
2466             switch( nId )
2467             {
2468             case RES_POOLCOLL_STANDARD:
2469                     nRet = 0;									break;
2470             case RES_POOLCOLL_TEXT_IDENT:
2471             case RES_POOLCOLL_TEXT_NEGIDENT:
2472             case RES_POOLCOLL_TEXT_MOVE:
2473             case RES_POOLCOLL_CONFRONTATION:
2474             case RES_POOLCOLL_MARGINAL:
2475                     nRet = RES_POOLCOLL_TEXT;					break;
2476 
2477             case RES_POOLCOLL_TEXT:
2478             case RES_POOLCOLL_GREETING:
2479             case RES_POOLCOLL_SIGNATURE:
2480             case RES_POOLCOLL_HEADLINE_BASE:
2481                     nRet = RES_POOLCOLL_STANDARD;				break;
2482 
2483             case RES_POOLCOLL_HEADLINE1:
2484             case RES_POOLCOLL_HEADLINE2:
2485             case RES_POOLCOLL_HEADLINE3:
2486             case RES_POOLCOLL_HEADLINE4:
2487             case RES_POOLCOLL_HEADLINE5:
2488             case RES_POOLCOLL_HEADLINE6:
2489             case RES_POOLCOLL_HEADLINE7:
2490             case RES_POOLCOLL_HEADLINE8:
2491             case RES_POOLCOLL_HEADLINE9:
2492             case RES_POOLCOLL_HEADLINE10:
2493                     nRet = RES_POOLCOLL_HEADLINE_BASE; 			break;
2494             }
2495             break;
2496 
2497         case COLL_LISTS_BITS:
2498             switch( nId )
2499             {
2500             case RES_POOLCOLL_NUMBUL_BASE:
2501                     nRet = RES_POOLCOLL_TEXT;					break;
2502 
2503             default:
2504                 nRet = RES_POOLCOLL_NUMBUL_BASE;				break;
2505             }
2506             break;
2507 
2508         case COLL_EXTRA_BITS:
2509             switch( nId )
2510             {
2511             case RES_POOLCOLL_FRAME:
2512                     nRet = RES_POOLCOLL_TEXT;					break;
2513 
2514             case RES_POOLCOLL_TABLE_HDLN:
2515                     nRet = RES_POOLCOLL_TABLE;					break;
2516 
2517             case RES_POOLCOLL_TABLE:
2518             case RES_POOLCOLL_FOOTNOTE:
2519             case RES_POOLCOLL_ENDNOTE:
2520             case RES_POOLCOLL_JAKETADRESS:
2521             case RES_POOLCOLL_SENDADRESS:
2522             case RES_POOLCOLL_HEADER:
2523             case RES_POOLCOLL_HEADERL:
2524             case RES_POOLCOLL_HEADERR:
2525             case RES_POOLCOLL_FOOTER:
2526             case RES_POOLCOLL_FOOTERL:
2527             case RES_POOLCOLL_FOOTERR:
2528             case RES_POOLCOLL_LABEL:
2529                     nRet = RES_POOLCOLL_STANDARD;				break;
2530 
2531             case RES_POOLCOLL_LABEL_ABB:
2532             case RES_POOLCOLL_LABEL_TABLE:
2533             case RES_POOLCOLL_LABEL_FRAME:
2534             case RES_POOLCOLL_LABEL_DRAWING:
2535                     nRet = RES_POOLCOLL_LABEL;					break;
2536             }
2537             break;
2538 
2539         case COLL_REGISTER_BITS:
2540             switch( nId )
2541             {
2542             case RES_POOLCOLL_REGISTER_BASE:
2543                     nRet = RES_POOLCOLL_STANDARD;				break;
2544 
2545             case RES_POOLCOLL_TOX_USERH:
2546             case RES_POOLCOLL_TOX_CNTNTH:
2547             case RES_POOLCOLL_TOX_IDXH:
2548             case RES_POOLCOLL_TOX_ILLUSH:
2549             case RES_POOLCOLL_TOX_OBJECTH:
2550             case RES_POOLCOLL_TOX_TABLESH:
2551             case RES_POOLCOLL_TOX_AUTHORITIESH:
2552                     nRet = RES_POOLCOLL_HEADLINE_BASE;  		break;
2553 
2554             default:
2555                     nRet = RES_POOLCOLL_REGISTER_BASE;  		break;
2556             }
2557             break;
2558 
2559         case COLL_DOC_BITS:
2560             nRet = RES_POOLCOLL_HEADLINE_BASE;
2561             break;
2562 
2563         case COLL_HTML_BITS:
2564             nRet = RES_POOLCOLL_STANDARD;
2565             break;
2566         }
2567     }
2568 
2569     return nRet;
2570 }
2571 
RemoveAllFmtLanguageDependencies()2572 void SwDoc::RemoveAllFmtLanguageDependencies()
2573 {
2574     /* #106748# Restore the language independ pool defaults and styles. */
2575     GetAttrPool().ResetPoolDefaultItem( RES_PARATR_ADJUST );
2576 
2577     SwTxtFmtColl * pTxtFmtColl = GetTxtCollFromPool( RES_POOLCOLL_STANDARD );
2578 
2579     pTxtFmtColl->ResetFmtAttr( RES_PARATR_ADJUST );
2580     /* #111214# koreans do not like SvxScriptItem(sal_True) */
2581     pTxtFmtColl->ResetFmtAttr( RES_PARATR_SCRIPTSPACE );
2582 
2583     SvxFrameDirectionItem aFrameDir( FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR );
2584 
2585     sal_uInt16 nCount = GetPageDescCnt();
2586     for( sal_uInt16 i=0; i<nCount; ++i )
2587     {
2588         SwPageDesc& rDesc = _GetPageDesc( i );
2589         rDesc.GetMaster().SetFmtAttr( aFrameDir );
2590         rDesc.GetLeft().SetFmtAttr( aFrameDir );
2591     }
2592 
2593     // OD 09.10.2003 #i18732# - restore static pool default for item
2594     // RES_FOLLOW_TEXT_FLOW.
2595     GetAttrPool().ResetPoolDefaultItem( RES_FOLLOW_TEXT_FLOW );
2596 
2597     //#i16874# AutoKerning as default for new documents
2598     GetAttrPool().ResetPoolDefaultItem( RES_CHRATR_AUTOKERN );
2599 }
2600