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 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 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 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 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 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 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 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 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 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 1064 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 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( !this, "ungueltige 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( !this, "ungueltige 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 1388 SwFrmFmt* SwDoc::GetFrmFmtFromPool( sal_uInt16 nId ) 1389 { 1390 return (SwFrmFmt*)GetFmtFromPool( nId ); 1391 } 1392 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 1400 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, "ungueltige 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 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 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( !this, "<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 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( !this, "ungueltige 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 2348 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 2372 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 2381 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 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 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 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