| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <hintids.hxx> |
| #include <i18npool/mslangid.hxx> |
| #include <unotools/localedatawrapper.hxx> |
| #include <editeng/paperinf.hxx> |
| #include <editeng/wghtitem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <editeng/tstpitem.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/adjitem.hxx> |
| #include <editeng/postitem.hxx> |
| #include <editeng/keepitem.hxx> |
| #include <editeng/opaqitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/cmapitem.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <editeng/protitem.hxx> |
| #include <editeng/escpitem.hxx> |
| #include <editeng/langitem.hxx> |
| #include <editeng/charrotateitem.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <editeng/emphitem.hxx> |
| #include <editeng/scriptspaceitem.hxx> |
| #include <viewopt.hxx> |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include <fmtanchr.hxx> |
| #include <fmtornt.hxx> |
| #include <fmtsrnd.hxx> |
| #include <fmtfsize.hxx> |
| #include <poolfmt.hxx> |
| #include <paratr.hxx> |
| #include <pagedesc.hxx> |
| #include <frmtool.hxx> |
| #include <charfmt.hxx> |
| #include <docary.hxx> |
| #include <fmtcol.hxx> |
| #include <ndtxt.hxx> |
| #include <fmtline.hxx> |
| #include <poolfmt.hrc> |
| #include <GetMetricVal.hxx> |
| #include <numrule.hxx> |
| |
| |
| using namespace ::com::sun::star; |
| |
| const sal_uInt16 PT_3 = 3 * 20; // 3 pt |
| const sal_uInt16 PT_6 = 6 * 20; // 6 pt |
| const sal_uInt16 PT_7 = 7 * 20; // 6 pt |
| const sal_uInt16 PT_8 = 8 * 20; // 8 pt |
| const sal_uInt16 PT_9 = 9 * 20; // 9 pt |
| const sal_uInt16 PT_10 = 10 * 20; // 10 pt |
| const sal_uInt16 PT_11 = 11 * 20; // 11 pt |
| const sal_uInt16 PT_12 = 12 * 20; // 12 pt |
| const sal_uInt16 PT_14 = 14 * 20; // 14 pt |
| const sal_uInt16 PT_16 = 16 * 20; // 16 pt |
| const sal_uInt16 PT_18 = 18 * 20; // 18 pt |
| const sal_uInt16 PT_22 = 22 * 20; // 22 pt |
| const sal_uInt16 PT_24 = 24 * 20; // 22 pt |
| |
| |
| //const sal_uInt16 HTML_PARSPACE = ((CM_05 * 7) / 10); |
| #define HTML_PARSPACE GetMetricVal( CM_05 ) |
| |
| static const sal_Char __FAR_DATA sKomma[] = ", "; |
| |
| static const sal_uInt16 aHeadlineSizes[ 2 * MAXLEVEL ] = { |
| // PT_16, PT_14, PT_14, PT_12, PT_12, // normal |
| //JP 10.12.96: jetzt soll alles prozentual sein: |
| 115, 100, 100, 85, 85, |
| 75, 75, 75, 75, 75, // normal |
| // PT_22, PT_16, PT_12, PT_11, PT_9 // HTML-Mode |
| PT_24, PT_18, PT_14, PT_12, PT_10, |
| PT_7, PT_7, PT_7, PT_7, PT_7 // HTML-Mode |
| }; |
| |
| long lcl_GetRightMargin( SwDoc& rDoc ) |
| { |
| // sorge dafuer, dass die Druckereinstellungen in die Standard- |
| // Seitenvorlage uebernommen wurden. |
| const SwFrmFmt& rPgDscFmt = |
| const_cast<const SwDoc *>(&rDoc)->GetPageDesc( 0 ).GetMaster(); |
| const SvxLRSpaceItem& rLR = rPgDscFmt.GetLRSpace(); |
| const long nLeft = rLR.GetLeft(); |
| const long nRight = rLR.GetRight(); |
| const long nWidth = rPgDscFmt.GetFrmSize().GetWidth(); |
| return nWidth - nLeft - nRight; |
| } |
| |
| void SetAllScriptItem( SfxItemSet& rSet, const SfxPoolItem& rItem ) |
| { |
| rSet.Put( rItem ); |
| sal_uInt16 nWhCJK = 0, nWhCTL = 0; |
| switch( rItem.Which() ) |
| { |
| case RES_CHRATR_FONTSIZE: |
| nWhCJK = RES_CHRATR_CJK_FONTSIZE, nWhCTL = RES_CHRATR_CTL_FONTSIZE; |
| break; |
| case RES_CHRATR_FONT: |
| nWhCJK = RES_CHRATR_CJK_FONT, nWhCTL = RES_CHRATR_CTL_FONT; |
| break; |
| case RES_CHRATR_LANGUAGE: |
| nWhCJK = RES_CHRATR_CJK_LANGUAGE, nWhCTL = RES_CHRATR_CTL_LANGUAGE; |
| break; |
| case RES_CHRATR_POSTURE: |
| nWhCJK = RES_CHRATR_CJK_POSTURE, nWhCTL = RES_CHRATR_CTL_POSTURE; |
| break; |
| case RES_CHRATR_WEIGHT: |
| nWhCJK = RES_CHRATR_CJK_WEIGHT, nWhCTL = RES_CHRATR_CTL_WEIGHT; |
| break; |
| } |
| |
| if( nWhCJK ) |
| rSet.Put( rItem, nWhCJK ); |
| if( nWhCTL ) |
| rSet.Put( rItem, nWhCTL ); |
| } |
| |
| void lcl_SetDfltFont( sal_uInt16 nFntType, SfxItemSet& rSet ) |
| { |
| static struct { |
| sal_uInt16 nResLngId; |
| sal_uInt16 nResFntId; |
| } aArr[ 3 ] = { |
| { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT }, |
| { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT }, |
| { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT } |
| }; |
| for( sal_uInt16 n = 0; n < 3; ++n ) |
| { |
| sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem( |
| aArr[n].nResLngId )).GetLanguage(); |
| Font aFnt( OutputDevice::GetDefaultFont( nFntType, |
| nLng, DEFAULTFONT_FLAGS_ONLYONE ) ); |
| |
| rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), |
| aEmptyStr, aFnt.GetPitch(), |
| aFnt.GetCharSet(), aArr[n].nResFntId )); |
| } |
| } |
| |
| void lcl_SetDfltFont( sal_uInt16 nLatinFntType, sal_uInt16 nCJKFntType, |
| sal_uInt16 nCTLFntType, SfxItemSet& rSet ) |
| { |
| static struct { |
| sal_uInt16 nResLngId; |
| sal_uInt16 nResFntId; |
| sal_uInt16 nFntType; |
| } aArr[ 3 ] = { |
| { RES_CHRATR_LANGUAGE, RES_CHRATR_FONT, 0 }, |
| { RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_FONT, 0 }, |
| { RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_FONT, 0 } |
| }; |
| aArr[0].nFntType = nLatinFntType; |
| aArr[1].nFntType = nCJKFntType; |
| aArr[2].nFntType = nCTLFntType; |
| |
| for( sal_uInt16 n = 0; n < 3; ++n ) |
| { |
| sal_uInt16 nLng = ((SvxLanguageItem&)rSet.GetPool()->GetDefaultItem( |
| aArr[n].nResLngId )).GetLanguage(); |
| Font aFnt( OutputDevice::GetDefaultFont( aArr[n].nFntType, |
| nLng, DEFAULTFONT_FLAGS_ONLYONE ) ); |
| |
| rSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), |
| aEmptyStr, aFnt.GetPitch(), |
| aFnt.GetCharSet(), aArr[n].nResFntId )); |
| } |
| } |
| |
| void lcl_SetHeadline( SwDoc* pDoc, SwTxtFmtColl* pColl, |
| SfxItemSet& rSet, |
| sal_uInt16 nOutLvlBits, sal_uInt8 nLevel, sal_Bool bItalic ) |
| { |
| SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) ); |
| SvxFontHeightItem aHItem(240, 100, RES_CHRATR_FONTSIZE); |
| const bool bHTMLMode = pDoc->get(IDocumentSettingAccess::HTML_MODE); |
| if( bHTMLMode ) |
| aHItem.SetHeight( aHeadlineSizes[ MAXLEVEL + nLevel ] ); |
| else |
| aHItem.SetHeight( PT_14, aHeadlineSizes[ nLevel ] ); |
| SetAllScriptItem( rSet, aHItem ); |
| |
| if( bItalic && !bHTMLMode ) |
| SetAllScriptItem( rSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) ); |
| |
| if( bHTMLMode ) |
| { |
| ::lcl_SetDfltFont( DEFAULTFONT_LATIN_TEXT, DEFAULTFONT_CJK_TEXT, |
| DEFAULTFONT_CTL_TEXT, rSet ); |
| } |
| |
| if( pColl ) |
| { |
| if( !( nOutLvlBits & ( 1 << nLevel )) ) |
| { |
| //pColl->SetOutlineLevel( nLevel ); //#outline level zhaojianwei |
| pColl->AssignToListLevelOfOutlineStyle(nLevel);//<-end,zhaojianwei |
| if( !bHTMLMode ) |
| { |
| SwNumRule * pOutlineRule = pDoc->GetOutlineNumRule(); |
| const SwNumFmt& rNFmt = pOutlineRule->Get( nLevel ); |
| // --> OD 2008-02-01 #newlistlevelattrs# |
| if ( rNFmt.GetPositionAndSpaceMode() == |
| SvxNumberFormat::LABEL_WIDTH_AND_POSITION && |
| ( rNFmt.GetAbsLSpace() || rNFmt.GetFirstLineOffset() ) ) |
| // <-- |
| { |
| SvxLRSpaceItem aLR( (SvxLRSpaceItem&)pColl->GetFmtAttr( RES_LR_SPACE ) ); |
| aLR.SetTxtFirstLineOfstValue( rNFmt.GetFirstLineOffset() ); |
| aLR.SetTxtLeft( rNFmt.GetAbsLSpace() ); |
| pColl->SetFmtAttr( aLR ); |
| } |
| |
| // --> OD 2006-11-20 #i71764# |
| // Check on document setting OUTLINE_LEVEL_YIELDS_OUTLINE_RULE no longer needed. |
| // All paragraph styles, which are assigned to a level of the |
| // outline style has to have the outline style set as its list style. |
| { |
| SwNumRuleItem aItem(pOutlineRule->GetName()); |
| |
| pColl->SetFmtAttr(aItem); |
| } |
| // <-- |
| } |
| } |
| pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool( |
| RES_POOLCOLL_TEXT )); |
| } |
| } |
| |
| |
| |
| void lcl_SetRegister( SwDoc* pDoc, SfxItemSet& rSet, sal_uInt16 nFact, |
| sal_Bool bHeader, sal_Bool bTab ) |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| sal_uInt16 nLeft = nFact ? GetMetricVal( CM_05 ) * nFact : 0; |
| aLR.SetTxtLeft( nLeft ); |
| |
| rSet.Put( aLR ); |
| if( bHeader ) |
| { |
| SetAllScriptItem( rSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) ); |
| SetAllScriptItem( rSet, SvxFontHeightItem( PT_16, 100, RES_CHRATR_FONTSIZE ) ); |
| } |
| if( bTab ) |
| { |
| long nRightMargin = lcl_GetRightMargin( *pDoc ); |
| SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP ); |
| aTStops.Insert( SvxTabStop( nRightMargin - nLeft, |
| SVX_TAB_ADJUST_RIGHT, |
| cDfltDecimalChar, '.' )); |
| rSet.Put( aTStops ); |
| } |
| } |
| |
| |
| |
| void lcl_SetNumBul( SwDoc* pDoc, SwTxtFmtColl* pColl, |
| SfxItemSet& rSet, |
| sal_uInt16 nNxt, SwTwips nEZ, SwTwips nLeft, |
| SwTwips nUpper, SwTwips nLower ) |
| { |
| |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); SvxULSpaceItem aUL( RES_UL_SPACE ); |
| aLR.SetTxtFirstLineOfst( sal_uInt16(nEZ) ); aLR.SetTxtLeft( sal_uInt16(nLeft) ); |
| aUL.SetUpper( sal_uInt16(nUpper) ); aUL.SetLower( sal_uInt16(nLower) ); |
| rSet.Put( aLR ); |
| rSet.Put( aUL ); |
| |
| if( !pColl ) |
| pColl->SetNextTxtFmtColl( *pDoc->GetTxtCollFromPool( nNxt )); |
| } |
| |
| |
| |
| // Gebe die "Auto-Collection" mit der Id zurueck. Existiert |
| // sie noch nicht, dann erzeuge sie |
| // Ist der String-Pointer definiert, dann erfrage nur die |
| // Beschreibung der Attribute, !! es legt keine Vorlage an !! |
| |
| SvxFrameDirection GetDefaultFrameDirection(sal_uLong nLanguage) |
| { |
| SvxFrameDirection eResult = (MsLangId::isRightToLeft( static_cast<LanguageType>(nLanguage)) ? |
| FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP); |
| return eResult; |
| } |
| |
| SwTxtFmtColl* SwDoc::GetTxtCollFromPool( sal_uInt16 nId, bool bRegardLanguage ) |
| { |
| ASSERT( |
| (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) || |
| (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) || |
| (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) || |
| (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) || |
| (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) || |
| (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END), |
| "Falsche AutoFormat-Id" ); |
| |
| SwTxtFmtColl* pNewColl; |
| sal_uInt16 nOutLvlBits = 0; |
| for( sal_uInt16 n = 0; n < pTxtFmtCollTbl->Count(); ++n ) |
| { |
| if( nId == ( pNewColl = (*pTxtFmtCollTbl)[ n ] )->GetPoolFmtId() ) |
| { |
| return pNewColl; |
| } |
| //if( pNewColl->GetOutlineLevel() < MAXLEVEL ) //#outline level,zhaojianwei |
| //nOutLvlBits |= ( 1 << pNewColl->GetOutlineLevel() ); |
| if( pNewColl->IsAssignedToListLevelOfOutlineStyle()) |
| nOutLvlBits |= ( 1 << pNewColl->GetAssignedOutlineStyleLevel() );//<-end,zhaojianwei |
| } |
| |
| // bis hierher nicht gefunden -> neu anlegen |
| sal_uInt16 nResId = 0; |
| if( RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END ) |
| nResId = RC_POOLCOLL_TEXT_BEGIN - RES_POOLCOLL_TEXT_BEGIN; |
| else if (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) |
| nResId = RC_POOLCOLL_LISTS_BEGIN - RES_POOLCOLL_LISTS_BEGIN; |
| else if (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) |
| nResId = RC_POOLCOLL_EXTRA_BEGIN - RES_POOLCOLL_EXTRA_BEGIN; |
| else if (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) |
| nResId = RC_POOLCOLL_REGISTER_BEGIN - RES_POOLCOLL_REGISTER_BEGIN; |
| else if (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) |
| nResId = RC_POOLCOLL_DOC_BEGIN - RES_POOLCOLL_DOC_BEGIN; |
| else if (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END) |
| nResId = RC_POOLCOLL_HTML_BEGIN - RES_POOLCOLL_HTML_BEGIN; |
| |
| ASSERT( nResId, "Ungueltige Pool-ID" ); |
| if( !nResId ) |
| return GetTxtCollFromPool( RES_POOLCOLL_STANDARD ); |
| |
| ResId aResId( nResId + nId, *pSwResMgr ); |
| String aNm( aResId ); |
| |
| // ein Set fuer alle zusetzenden Attribute |
| SwAttrSet aSet( GetAttrPool(), aTxtFmtCollSetRange ); |
| sal_uInt16 nParent = GetPoolParent( nId ); |
| |
| { |
| |
| //FEATURE::CONDCOLL |
| if(::IsConditionalByPoolId( nId )) |
| pNewColl = new SwConditionTxtFmtColl( GetAttrPool(), aNm, !nParent |
| ? pDfltTxtFmtColl |
| : GetTxtCollFromPool( nParent )); |
| else |
| //FEATURE::CONDCOLL |
| pNewColl = new SwTxtFmtColl( GetAttrPool(), aNm, !nParent |
| ? pDfltTxtFmtColl |
| : GetTxtCollFromPool( nParent )); |
| pNewColl->SetPoolFmtId( nId ); |
| pTxtFmtCollTbl->Insert( pNewColl, pTxtFmtCollTbl->Count() ); |
| } |
| |
| switch( nId ) |
| { |
| // allgemeine Inhaltsformen |
| case RES_POOLCOLL_STANDARD: |
| /* #111214# koreans do not like SvxScriptItem(sal_True) */ |
| if (bRegardLanguage) |
| { |
| sal_uLong nAppLanguage = GetAppLanguage(); |
| if (GetDefaultFrameDirection(nAppLanguage) == |
| FRMDIR_HORI_RIGHT_TOP) |
| { |
| SvxAdjustItem aAdjust(SVX_ADJUST_RIGHT, RES_PARATR_ADJUST ); |
| aSet.Put(aAdjust); |
| } |
| if (nAppLanguage == LANGUAGE_KOREAN) |
| { |
| SvxScriptSpaceItem aScriptSpace(sal_False, RES_PARATR_SCRIPTSPACE); |
| aSet.Put(aScriptSpace); |
| } |
| } |
| break; |
| |
| case RES_POOLCOLL_TEXT: // Textkoerper |
| { |
| SvxULSpaceItem aUL( 0, PT_6, RES_UL_SPACE ); |
| if( get(IDocumentSettingAccess::HTML_MODE) ) aUL.SetLower( HTML_PARSPACE ); |
| aSet.Put( aUL ); |
| } |
| break; |
| case RES_POOLCOLL_TEXT_IDENT: // Textkoerper Einzug |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtFirstLineOfst( GetMetricVal( CM_05 )); |
| aSet.Put( aLR ); |
| } |
| break; |
| case RES_POOLCOLL_TEXT_NEGIDENT: // Textkoerper neg. Einzug |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 )); |
| aLR.SetTxtLeft( GetMetricVal( CM_1 )); |
| SvxTabStopItem aTStops(RES_PARATR_TABSTOP); aTStops.Insert( SvxTabStop( 0 )); |
| |
| aSet.Put( aLR ); |
| aSet.Put( aTStops ); |
| } |
| break; |
| case RES_POOLCOLL_TEXT_MOVE: // Textkoerper Einrueckung |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtLeft( GetMetricVal( CM_05 )); |
| aSet.Put( aLR ); |
| } |
| break; |
| |
| case RES_POOLCOLL_CONFRONTATION: // Textkoerper Gegenueberstellung |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtFirstLineOfst( - short( GetMetricVal( CM_1 ) * 4 + |
| GetMetricVal( CM_05)) ); |
| aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 5 ); |
| SvxTabStopItem aTStops( RES_PARATR_TABSTOP ); aTStops.Insert( SvxTabStop( 0 )); |
| |
| aSet.Put( aLR ); |
| aSet.Put( aTStops ); |
| } |
| break; |
| case RES_POOLCOLL_MARGINAL: // Textkoerper maginalie |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtLeft( GetMetricVal( CM_1 ) * 4 ); |
| aSet.Put( aLR ); |
| } |
| break; |
| |
| case RES_POOLCOLL_HEADLINE_BASE: // Basis Ueberschrift |
| { |
| static const sal_uInt16 aFntInit[] = { |
| DEFAULTFONT_LATIN_HEADING, RES_CHRATR_FONT, |
| RES_CHRATR_LANGUAGE, LANGUAGE_ENGLISH_US, |
| DEFAULTFONT_CJK_HEADING, RES_CHRATR_CJK_FONT, |
| RES_CHRATR_CJK_LANGUAGE, LANGUAGE_ENGLISH_US, |
| DEFAULTFONT_CTL_HEADING, RES_CHRATR_CTL_FONT, |
| RES_CHRATR_CTL_LANGUAGE, LANGUAGE_ARABIC_SAUDI_ARABIA, |
| 0 |
| }; |
| |
| for( const sal_uInt16* pArr = aFntInit; *pArr; pArr += 4 ) |
| { |
| sal_uInt16 nLng = ((SvxLanguageItem&)GetDefault( *(pArr+2) )).GetLanguage(); |
| if( LANGUAGE_DONTKNOW == nLng ) |
| nLng = *(pArr+3); |
| |
| Font aFnt( OutputDevice::GetDefaultFont( *pArr, |
| nLng, DEFAULTFONT_FLAGS_ONLYONE ) ); |
| |
| aSet.Put( SvxFontItem( aFnt.GetFamily(), aFnt.GetName(), |
| aEmptyStr, aFnt.GetPitch(), |
| aFnt.GetCharSet(), *(pArr+1) )); |
| } |
| |
| SvxFontHeightItem aFntSize( PT_14, 100, RES_CHRATR_FONTSIZE ); |
| SvxULSpaceItem aUL( PT_12, PT_6, RES_UL_SPACE ); |
| if( get(IDocumentSettingAccess::HTML_MODE) ) |
| aUL.SetLower( HTML_PARSPACE ); |
| aSet.Put( SvxFmtKeepItem( sal_True, RES_KEEP )); |
| |
| pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( RES_POOLCOLL_TEXT )); |
| |
| aSet.Put( aUL ); |
| SetAllScriptItem( aSet, aFntSize ); |
| } |
| break; |
| |
| case RES_POOLCOLL_NUMBUL_BASE: // Basis Numerierung/Aufzaehlung |
| break; |
| |
| case RES_POOLCOLL_GREETING: // Grussformel |
| case RES_POOLCOLL_REGISTER_BASE: // Basis Verzeichnisse |
| case RES_POOLCOLL_SIGNATURE: // Unterschrift |
| case RES_POOLCOLL_TABLE: // Tabelle-Inhalt |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_HEADLINE1: // Ueberschrift 1 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 0, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE2: // Ueberschrift 2 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 1, sal_True ); |
| break; |
| case RES_POOLCOLL_HEADLINE3: // Ueberschrift 3 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 2, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE4: // Ueberschrift 4 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 3, sal_True ); |
| break; |
| case RES_POOLCOLL_HEADLINE5: // Ueberschrift 5 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 4, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE6: // Ueberschrift 6 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 5, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE7: // Ueberschrift 7 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 6, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE8: // Ueberschrift 8 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 7, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE9: // Ueberschrift 9 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 8, sal_False ); |
| break; |
| case RES_POOLCOLL_HEADLINE10: // Ueberschrift 10 |
| lcl_SetHeadline( this, pNewColl, aSet, nOutLvlBits, 9, sal_False ); |
| break; |
| |
| |
| // Sonderbereiche: |
| // Kopfzeilen |
| case RES_POOLCOLL_HEADER: |
| case RES_POOLCOLL_HEADERL: |
| case RES_POOLCOLL_HEADERR: |
| // Fusszeilen |
| case RES_POOLCOLL_FOOTER: |
| case RES_POOLCOLL_FOOTERL: |
| case RES_POOLCOLL_FOOTERR: |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| |
| long nRightMargin = lcl_GetRightMargin( *this ); |
| |
| SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP ); |
| aTStops.Insert( SvxTabStop( nRightMargin / 2, SVX_TAB_ADJUST_CENTER ) ); |
| aTStops.Insert( SvxTabStop( nRightMargin, SVX_TAB_ADJUST_RIGHT ) ); |
| |
| aSet.Put( aTStops ); |
| } |
| break; |
| |
| case RES_POOLCOLL_TABLE_HDLN: |
| { |
| SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) ); |
| aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) ); |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_FOOTNOTE: // Fussnote |
| case RES_POOLCOLL_ENDNOTE: |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetTxtFirstLineOfst( -(short)GetMetricVal( CM_05 )); |
| aLR.SetTxtLeft( GetMetricVal( CM_05 )); |
| SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) ); |
| aSet.Put( aLR ); |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_LABEL: // Beschriftung-Basis |
| { |
| SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetUpper( PT_6 ); aUL.SetLower( PT_6 ); |
| aSet.Put( aUL ); |
| SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ) ); |
| SetAllScriptItem( aSet, SvxFontHeightItem( PT_10, 100, RES_CHRATR_FONTSIZE ) ); |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_FRAME: // Rahmen Inhalt |
| case RES_POOLCOLL_LABEL_ABB: // Beschriftung-Abbildung |
| case RES_POOLCOLL_LABEL_TABLE: // Beschriftung-Tabelle |
| case RES_POOLCOLL_LABEL_FRAME: // Beschriftung-Rahmen |
| case RES_POOLCOLL_LABEL_DRAWING: // Beschriftung-Zeichnung |
| break; |
| |
| case RES_POOLCOLL_JAKETADRESS: // UmschlagAdresse |
| { |
| SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 ); |
| aSet.Put( aUL ); |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_SENDADRESS: // AbsenderAdresse |
| { |
| if( get(IDocumentSettingAccess::HTML_MODE) ) |
| SetAllScriptItem( aSet, SvxPostureItem(ITALIC_NORMAL, RES_CHRATR_POSTURE) ); |
| else |
| { |
| SvxULSpaceItem aUL( RES_UL_SPACE ); aUL.SetLower( PT_3 ); |
| aSet.Put( aUL ); |
| } |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| // Benutzer-Verzeichnisse: |
| case RES_POOLCOLL_TOX_USERH: // Header |
| lcl_SetRegister( this, aSet, 0, sal_True, sal_False ); |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| case RES_POOLCOLL_TOX_USER1: // 1. Ebene |
| lcl_SetRegister( this, aSet, 0, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER2: // 2. Ebene |
| lcl_SetRegister( this, aSet, 1, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER3: // 3. Ebene |
| lcl_SetRegister( this, aSet, 2, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER4: // 4. Ebene |
| lcl_SetRegister( this, aSet, 3, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER5: // 5. Ebene |
| lcl_SetRegister( this, aSet, 4, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER6: // 6. Ebene |
| lcl_SetRegister( this, aSet, 5, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER7: // 7. Ebene |
| lcl_SetRegister( this, aSet, 6, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER8: // 8. Ebene |
| lcl_SetRegister( this, aSet, 7, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER9: // 9. Ebene |
| lcl_SetRegister( this, aSet, 8, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_USER10: // 10. Ebene |
| lcl_SetRegister( this, aSet, 9, sal_False, sal_True ); |
| break; |
| |
| // Index-Verzeichnisse |
| case RES_POOLCOLL_TOX_IDXH: // Header |
| lcl_SetRegister( this, aSet, 0, sal_True, sal_False ); |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| case RES_POOLCOLL_TOX_IDX1: // 1. Ebene |
| lcl_SetRegister( this, aSet, 0, sal_False, sal_False ); |
| break; |
| case RES_POOLCOLL_TOX_IDX2: // 2. Ebene |
| lcl_SetRegister( this, aSet, 1, sal_False, sal_False ); |
| break; |
| case RES_POOLCOLL_TOX_IDX3: // 3. Ebene |
| lcl_SetRegister( this, aSet, 2, sal_False, sal_False ); |
| break; |
| case RES_POOLCOLL_TOX_IDXBREAK: // Trenner |
| lcl_SetRegister( this, aSet, 0, sal_False, sal_False ); |
| break; |
| |
| // Inhalts-Verzeichnisse |
| case RES_POOLCOLL_TOX_CNTNTH: // Header |
| lcl_SetRegister( this, aSet, 0, sal_True, sal_False ); |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| case RES_POOLCOLL_TOX_CNTNT1: // 1. Ebene |
| lcl_SetRegister( this, aSet, 0, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT2: // 2. Ebene |
| lcl_SetRegister( this, aSet, 1, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT3: // 3. Ebene |
| lcl_SetRegister( this, aSet, 2, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT4: // 4. Ebene |
| lcl_SetRegister( this, aSet, 3, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT5: // 5. Ebene |
| lcl_SetRegister( this, aSet, 4, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT6: // 6. Ebene |
| lcl_SetRegister( this, aSet, 5, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT7: // 7. Ebene |
| lcl_SetRegister( this, aSet, 6, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT8: // 8. Ebene |
| lcl_SetRegister( this, aSet, 7, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT9: // 9. Ebene |
| lcl_SetRegister( this, aSet, 8, sal_False, sal_True ); |
| break; |
| case RES_POOLCOLL_TOX_CNTNT10: // 10. Ebene |
| lcl_SetRegister( this, aSet, 9, sal_False, sal_True ); |
| break; |
| |
| case RES_POOLCOLL_TOX_ILLUSH: |
| case RES_POOLCOLL_TOX_OBJECTH: |
| case RES_POOLCOLL_TOX_TABLESH: |
| case RES_POOLCOLL_TOX_AUTHORITIESH: |
| lcl_SetRegister( this, aSet, 0, sal_True, sal_False ); |
| { |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| case RES_POOLCOLL_TOX_ILLUS1: |
| case RES_POOLCOLL_TOX_OBJECT1: |
| case RES_POOLCOLL_TOX_TABLES1: |
| case RES_POOLCOLL_TOX_AUTHORITIES1: |
| lcl_SetRegister( this, aSet, 0, sal_False, sal_True ); |
| break; |
| |
| |
| |
| case RES_POOLCOLL_NUM_LEVEL1S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL1: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL1E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL1, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 0 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_NUM_NONUM1: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM1, |
| 0, SwNumRule::GetNumIndent( 0 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL2S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL2: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL2E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL2, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 1 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_NUM_NONUM2: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM2, |
| 0, SwNumRule::GetNumIndent( 1 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL3S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL3: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL3E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL3, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 2 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_NUM_NONUM3: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM3, |
| 0, SwNumRule::GetNumIndent( 2 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL4S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL4: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL4E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL4, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 3 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_NUM_NONUM4: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM4, |
| 0, SwNumRule::GetNumIndent( 3 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL5S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL5: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_NUM_LEVEL5E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_LEVEL5, |
| lNumFirstLineOffset, SwNumRule::GetNumIndent( 4 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_NUM_NONUM5: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_NUM_NONUM5, |
| 0, SwNumRule::GetNumIndent( 4 ), 0, PT_6 ); |
| break; |
| |
| case RES_POOLCOLL_BUL_LEVEL1S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL1: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL1E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL1, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 0 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_BUL_NONUM1: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM1, |
| 0, SwNumRule::GetBullIndent( 0 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL2S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL2: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL2E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL2, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 1 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_BUL_NONUM2: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM2, |
| 0, SwNumRule::GetBullIndent( 1 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL3S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL3: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL3E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL3, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 2 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_BUL_NONUM3: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM3, |
| 0, SwNumRule::GetBullIndent( 2 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL4S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL4: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL4E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL4, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 3 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_BUL_NONUM4: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM4, |
| 0, SwNumRule::GetBullIndent( 3 ), 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL5S: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ), |
| PT_12, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL5: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ), |
| 0, PT_6 ); |
| break; |
| case RES_POOLCOLL_BUL_LEVEL5E: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_LEVEL5, |
| lBullFirstLineOffset, SwNumRule::GetBullIndent( 4 ), |
| 0, PT_12 ); |
| break; |
| case RES_POOLCOLL_BUL_NONUM5: |
| lcl_SetNumBul( this, pNewColl, aSet, RES_POOLCOLL_BUL_NONUM5, |
| 0, SwNumRule::GetBullIndent( 4 ), 0, PT_6 ); |
| break; |
| |
| case RES_POOLCOLL_DOC_TITEL: // Doc. Titel |
| { |
| SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ) ); |
| SetAllScriptItem( aSet, SvxFontHeightItem( PT_18, 100, RES_CHRATR_FONTSIZE ) ); |
| |
| aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST ) ); |
| |
| pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( |
| RES_POOLCOLL_DOC_SUBTITEL )); |
| } |
| break; |
| |
| case RES_POOLCOLL_DOC_SUBTITEL: // Doc. UnterTitel |
| { |
| SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE )); |
| SetAllScriptItem( aSet, SvxFontHeightItem( PT_14, 100, RES_CHRATR_FONTSIZE )); |
| |
| aSet.Put( SvxAdjustItem( SVX_ADJUST_CENTER, RES_PARATR_ADJUST )); |
| |
| pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( |
| RES_POOLCOLL_TEXT )); |
| } |
| break; |
| |
| case RES_POOLCOLL_HTML_BLOCKQUOTE: |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR.SetLeft( GetMetricVal( CM_1 )); |
| aLR.SetRight( GetMetricVal( CM_1 )); |
| aSet.Put( aLR ); |
| // aSet.Put( SvxAdjustItem( SVX_ADJUST_BLOCK, RES_PARATR_ADJUST ) ); |
| SvxULSpaceItem aUL( RES_UL_SPACE ); |
| aUL = pNewColl->GetULSpace(); |
| aUL.SetLower( HTML_PARSPACE ); |
| aSet.Put( aUL); |
| } |
| break; |
| |
| case RES_POOLCOLL_HTML_PRE: |
| { |
| ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet ); |
| |
| // WORKAROUND: PRE auf 10pt setzten |
| SetAllScriptItem( aSet, SvxFontHeightItem(PT_10, 100, RES_CHRATR_FONTSIZE) ); |
| // WORKAROUND: PRE auf 10pt setzten |
| |
| // der untere Absatz-Abstand wird explizit gesetzt (macht |
| // die harte Attributierung einfacher) |
| SvxULSpaceItem aULSpaceItem( RES_UL_SPACE ); |
| aULSpaceItem = pNewColl->GetULSpace(); |
| aULSpaceItem.SetLower( 0 ); |
| aSet.Put( aULSpaceItem ); |
| } |
| break; |
| |
| case RES_POOLCOLL_HTML_HR: |
| { |
| SvxBoxItem aBox( RES_BOX ); |
| Color aColor( COL_GRAY ); |
| SvxBorderLine aNew( &aColor, DEF_DOUBLE_LINE0_OUT, |
| DEF_DOUBLE_LINE0_IN, |
| DEF_DOUBLE_LINE0_DIST ); |
| aBox.SetLine( &aNew, BOX_LINE_BOTTOM ); |
| |
| aSet.Put( aBox ); |
| aSet.Put( SwParaConnectBorderItem( sal_False ) ); |
| SetAllScriptItem( aSet, SvxFontHeightItem(120, 100, RES_CHRATR_FONTSIZE) ); |
| |
| SvxULSpaceItem aUL( RES_UL_SPACE ); |
| { |
| pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( |
| RES_POOLCOLL_TEXT )); |
| aUL = pNewColl->GetULSpace(); |
| } |
| aUL.SetLower( HTML_PARSPACE ); |
| aSet.Put( aUL); |
| SwFmtLineNumber aLN; aLN.SetCountLines( sal_False ); |
| aSet.Put( aLN ); |
| } |
| break; |
| |
| case RES_POOLCOLL_HTML_DD: |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| aLR = pNewColl->GetLRSpace(); |
| // es wird um 1cm eingerueckt. Die IDs liegen immer 2 auseinander! |
| aLR.SetLeft( GetMetricVal( CM_1 )); |
| aSet.Put( aLR ); |
| } |
| break; |
| case RES_POOLCOLL_HTML_DT: |
| { |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| { |
| pNewColl->SetNextTxtFmtColl( *GetTxtCollFromPool( |
| RES_POOLCOLL_HTML_DD )); |
| aLR = pNewColl->GetLRSpace(); |
| } |
| // es wird um 0cm eingerueckt. Die IDs liegen immer 2 auseinander! |
| aLR.SetLeft( 0 ); |
| aSet.Put( aLR ); |
| } |
| break; |
| } |
| |
| if( aSet.Count() ) |
| { |
| { |
| pNewColl->SetFmtAttr( aSet ); |
| // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation |
| // (Bug: 18545) |
| // SetModified(); |
| } |
| } |
| return pNewColl; |
| } |
| |
| |
| |
| // pruefe, ob diese "Auto-Collection" in Dokument schon/noch |
| // benutzt wird |
| bool SwDoc::IsPoolTxtCollUsed( sal_uInt16 nId ) const |
| { |
| ASSERT( |
| (RES_POOLCOLL_TEXT_BEGIN <= nId && nId < RES_POOLCOLL_TEXT_END) || |
| (RES_POOLCOLL_LISTS_BEGIN <= nId && nId < RES_POOLCOLL_LISTS_END) || |
| (RES_POOLCOLL_EXTRA_BEGIN <= nId && nId < RES_POOLCOLL_EXTRA_END) || |
| (RES_POOLCOLL_REGISTER_BEGIN <= nId && nId < RES_POOLCOLL_REGISTER_END) || |
| (RES_POOLCOLL_DOC_BEGIN <= nId && nId < RES_POOLCOLL_DOC_END) || |
| (RES_POOLCOLL_HTML_BEGIN <= nId && nId < RES_POOLCOLL_HTML_END), |
| "Falsche AutoFormat-Id" ); |
| |
| SwTxtFmtColl* pNewColl = 0; |
| sal_Bool bFnd = sal_False; |
| for( sal_uInt16 n = 0; !bFnd && n < pTxtFmtCollTbl->Count(); ++n ) |
| { |
| pNewColl = (*pTxtFmtCollTbl)[ n ]; |
| if( nId == pNewColl->GetPoolFmtId() ) |
| bFnd = sal_True; |
| } |
| |
| if( !bFnd || !pNewColl->GetDepends() ) |
| return sal_False; |
| |
| SwAutoFmtGetDocNode aGetHt( &GetNodes() ); |
| return !pNewColl->GetInfo( aGetHt ); |
| } |
| |
| // Gebe das "Auto[matische]-Format" mit der Id zurueck. Existiert |
| // es noch nicht, dann erzeuge es |
| |
| SwFmt* SwDoc::GetFmtFromPool( sal_uInt16 nId ) |
| { |
| SwFmt *pNewFmt = 0; |
| SwFmt *pDeriveFmt = 0; |
| |
| SvPtrarr* pArray[ 2 ]; |
| sal_uInt16 nArrCnt = 1, nRCId = 0; |
| sal_uInt16* pWhichRange = 0; |
| |
| switch( nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) ) |
| { |
| case POOLGRP_CHARFMT: |
| { |
| pArray[0] = pCharFmtTbl; |
| pDeriveFmt = pDfltCharFmt; |
| |
| if( nId > RES_POOLCHR_NORMAL_END ) |
| nRCId = RC_POOLCHRFMT_HTML_BEGIN - RES_POOLCHR_HTML_BEGIN; |
| else |
| nRCId = RC_POOLCHRFMT_BEGIN - RES_POOLCHR_BEGIN; |
| pWhichRange = aCharFmtSetRange; |
| |
| // Fehlerfall: unbekanntes Format, aber CharFormat |
| // -> returne das erste |
| if( RES_POOLCHR_BEGIN > nId || nId >= RES_POOLCHR_END ) |
| { |
| ASSERT( !this, "ungueltige Id" ); |
| nId = RES_POOLCHR_BEGIN; |
| } |
| } |
| break; |
| case POOLGRP_FRAMEFMT: |
| { |
| pArray[0] = pFrmFmtTbl; |
| pArray[1] = pSpzFrmFmtTbl; |
| pDeriveFmt = pDfltFrmFmt; |
| nArrCnt = 2; |
| nRCId = RC_POOLFRMFMT_BEGIN - RES_POOLFRM_BEGIN; |
| pWhichRange = aFrmFmtSetRange; |
| |
| // Fehlerfall: unbekanntes Format, aber FrameFormat |
| // -> returne das erste |
| if( RES_POOLFRM_BEGIN > nId || nId >= RES_POOLFRM_END ) |
| { |
| ASSERT( !this, "ungueltige Id" ); |
| nId = RES_POOLFRM_BEGIN; |
| } |
| } |
| break; |
| |
| default: |
| // Fehlerfall, unbekanntes Format |
| ASSERT( nId, "ungueltige Id" ); |
| return 0; |
| } |
| ASSERT( nRCId, "ungueltige Id" ); |
| |
| while( nArrCnt-- ) |
| for( sal_uInt16 n = 0; n < (*pArray[nArrCnt]).Count(); ++n ) |
| if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )-> |
| GetPoolFmtId() ) |
| { |
| return pNewFmt; |
| } |
| |
| ResId aResId( nRCId + nId, *pSwResMgr ); |
| String aNm( aResId ); |
| SwAttrSet aSet( GetAttrPool(), pWhichRange ); |
| |
| { |
| sal_Bool bIsModified = IsModified(); |
| |
| { |
| ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo()); |
| switch (nId & (COLL_GET_RANGE_BITS + POOLGRP_NOCOLLID) ) |
| { |
| case POOLGRP_CHARFMT: |
| pNewFmt = _MakeCharFmt(aNm, pDeriveFmt, sal_False, sal_True); |
| break; |
| case POOLGRP_FRAMEFMT: |
| pNewFmt = _MakeFrmFmt(aNm, pDeriveFmt, sal_False, sal_True); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if( !bIsModified ) |
| ResetModified(); |
| pNewFmt->SetPoolFmtId( nId ); |
| pNewFmt->SetAuto( sal_False ); // kein Auto-Format |
| } |
| |
| switch( nId ) |
| { |
| case RES_POOLCHR_FOOTNOTE: // Fussnote |
| case RES_POOLCHR_PAGENO: // Seiten/Feld |
| case RES_POOLCHR_LABEL: // Beschriftung |
| case RES_POOLCHR_DROPCAPS: // Initialien |
| case RES_POOLCHR_NUM_LEVEL: // Aufzaehlungszeichen |
| case RES_POOLCHR_TOXJUMP: // Verzeichnissprung |
| case RES_POOLCHR_ENDNOTE: // Endnote |
| case RES_POOLCHR_LINENUM: // Zeilennummerierung |
| break; |
| |
| case RES_POOLCHR_ENDNOTE_ANCHOR: // Endnotenanker |
| case RES_POOLCHR_FOOTNOTE_ANCHOR: // Fussnotenanker |
| { |
| aSet.Put( SvxEscapementItem( DFLT_ESC_AUTO_SUPER, 58, RES_CHRATR_ESCAPEMENT ) ); |
| } |
| break; |
| |
| |
| case RES_POOLCHR_BUL_LEVEL: // Aufzaehlungszeichen |
| { |
| const Font& rBulletFont = numfunc::GetDefBulletFont(); |
| SetAllScriptItem( aSet, SvxFontItem( rBulletFont.GetFamily(), |
| rBulletFont.GetName(), rBulletFont.GetStyleName(), |
| rBulletFont.GetPitch(), rBulletFont.GetCharSet(), RES_CHRATR_FONT )); |
| // --> OD 2008-06-02 #i63395# |
| // no font and no font size any more |
| // SetAllScriptItem( aSet, SvxFontHeightItem( PT_9, 100, RES_CHRATR_FONTSIZE )); |
| // <-- |
| } |
| break; |
| |
| case RES_POOLCHR_INET_NORMAL: |
| { |
| Color aCol( COL_BLUE ); |
| aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) ); |
| aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) ); |
| // i40133: patch submitted by rail: set language to 'none' to prevent spell checking: |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) ); |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) ); |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) ); |
| } |
| break; |
| case RES_POOLCHR_INET_VISIT: |
| { |
| Color aCol( COL_RED ); |
| aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) ); |
| aSet.Put( SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE ) ); |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_LANGUAGE ) ); |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CJK_LANGUAGE ) ); |
| aSet.Put( SvxLanguageItem( LANGUAGE_NONE, RES_CHRATR_CTL_LANGUAGE ) ); |
| } |
| break; |
| case RES_POOLCHR_JUMPEDIT: |
| { |
| Color aCol( COL_CYAN ); |
| aSet.Put( SvxColorItem( aCol, RES_CHRATR_COLOR ) ); |
| aSet.Put( SvxUnderlineItem( UNDERLINE_DOTTED, RES_CHRATR_UNDERLINE ) ); |
| aSet.Put( SvxCaseMapItem( SVX_CASEMAP_KAPITAELCHEN, RES_CHRATR_CASEMAP ) ); |
| } |
| break; |
| |
| case RES_POOLCHR_RUBYTEXT: |
| { |
| long nH = ((SvxFontHeightItem*)GetDfltAttr( |
| RES_CHRATR_CJK_FONTSIZE ))->GetHeight() / 2; |
| SetAllScriptItem( aSet, SvxFontHeightItem( nH, 100, RES_CHRATR_FONTSIZE)); |
| aSet.Put(SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE )); |
| aSet.Put(SvxEmphasisMarkItem( EMPHASISMARK_NONE, RES_CHRATR_EMPHASIS_MARK) ); |
| } |
| break; |
| |
| case RES_POOLCHR_HTML_EMPHASIS: |
| case RES_POOLCHR_HTML_CITIATION: |
| case RES_POOLCHR_HTML_VARIABLE: |
| { |
| SetAllScriptItem( aSet, SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE) ); |
| } |
| break; |
| |
| case RES_POOLCHR_IDX_MAIN_ENTRY: |
| case RES_POOLCHR_HTML_STRONG: |
| { |
| SetAllScriptItem( aSet, SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT )); |
| } |
| break; |
| |
| case RES_POOLCHR_HTML_CODE: |
| case RES_POOLCHR_HTML_SAMPLE: |
| case RES_POOLCHR_HTML_KEYBOARD: |
| case RES_POOLCHR_HTML_TELETYPE: |
| { |
| ::lcl_SetDfltFont( DEFAULTFONT_FIXED, aSet ); |
| } |
| break; |
| case RES_POOLCHR_VERT_NUM: |
| aSet.Put( SvxCharRotateItem( 900, sal_False, RES_CHRATR_ROTATE ) ); |
| break; |
| //nichts besonderes |
| // case RES_POOLCHR_HTML_DEFINSTANCE: |
| // break; |
| |
| |
| case RES_POOLFRM_FRAME: |
| { |
| if ( get(IDocumentSettingAccess::HTML_MODE) ) |
| { |
| aSet.Put( SwFmtAnchor( FLY_AS_CHAR )); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::LINE_CENTER, text::RelOrientation::PRINT_AREA ) ); |
| aSet.Put( SwFmtSurround( SURROUND_NONE ) ); |
| } |
| else |
| { |
| aSet.Put( SwFmtAnchor( FLY_AT_PARA )); |
| aSet.Put( SwFmtSurround( SURROUND_PARALLEL ) ); |
| aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::PRINT_AREA ) ); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::PRINT_AREA ) ); |
| Color aCol( COL_BLACK ); |
| SvxBorderLine aLine( &aCol, DEF_LINE_WIDTH_0 ); |
| SvxBoxItem aBox( RES_BOX ); |
| aBox.SetLine( &aLine, BOX_LINE_TOP ); |
| aBox.SetLine( &aLine, BOX_LINE_BOTTOM ); |
| aBox.SetLine( &aLine, BOX_LINE_LEFT ); |
| aBox.SetLine( &aLine, BOX_LINE_RIGHT ); |
| aBox.SetDistance( 85 ); |
| aSet.Put( aBox ); |
| aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) ); |
| aSet.Put( SvxULSpaceItem( 114, 114, RES_UL_SPACE ) ); |
| } |
| } |
| break; |
| case RES_POOLFRM_GRAPHIC: |
| case RES_POOLFRM_OLE: |
| { |
| aSet.Put( SwFmtAnchor( FLY_AT_PARA )); |
| aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME )); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME )); |
| aSet.Put( SwFmtSurround( SURROUND_NONE )); |
| } |
| break; |
| case RES_POOLFRM_FORMEL: |
| { |
| aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) ); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CHAR_CENTER, text::RelOrientation::FRAME ) ); |
| aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) ); |
| } |
| break; |
| case RES_POOLFRM_MARGINAL: |
| { |
| aSet.Put( SwFmtAnchor( FLY_AT_PARA )); |
| aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::LEFT, text::RelOrientation::FRAME )); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME )); |
| aSet.Put( SwFmtSurround( SURROUND_PARALLEL )); |
| // Breite 3.5 centimeter vorgegeben, als Hoehe nur den |
| // min. Wert benutzen |
| aSet.Put( SwFmtFrmSize( ATT_MIN_SIZE, |
| GetMetricVal( CM_1 ) * 3 + GetMetricVal( CM_05 ), |
| MM50 )); |
| } |
| break; |
| case RES_POOLFRM_WATERSIGN: |
| { |
| aSet.Put( SwFmtAnchor( FLY_AT_PAGE )); |
| aSet.Put( SwFmtHoriOrient( 0, text::HoriOrientation::CENTER, text::RelOrientation::FRAME )); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::CENTER, text::RelOrientation::FRAME )); |
| aSet.Put( SvxOpaqueItem( sal_False )); |
| aSet.Put( SwFmtSurround( SURROUND_THROUGHT )); |
| } |
| break; |
| |
| case RES_POOLFRM_LABEL: |
| { |
| aSet.Put( SwFmtAnchor( FLY_AS_CHAR ) ); |
| aSet.Put( SwFmtVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ) ); |
| aSet.Put( SvxLRSpaceItem( 114, 114, 0, 0, RES_LR_SPACE ) ); |
| |
| SvxProtectItem aProtect( RES_PROTECT ); |
| aProtect.SetSizeProtect( sal_True ); |
| aProtect.SetPosProtect( sal_True ); |
| aSet.Put( aProtect ); |
| |
| pNewFmt->SetAutoUpdateFmt( sal_True ); |
| } |
| break; |
| } |
| if( aSet.Count() ) |
| { |
| { |
| pNewFmt->SetFmtAttr( aSet ); |
| // JP 31.08.95: erzeugen einer PoolVorlage ist keine Modifikation |
| // (Bug: 18545) |
| // SetModified(); |
| } |
| } |
| return pNewFmt; |
| } |
| |
| SwFrmFmt* SwDoc::GetFrmFmtFromPool( sal_uInt16 nId ) |
| { |
| return (SwFrmFmt*)GetFmtFromPool( nId ); |
| } |
| |
| SwCharFmt* SwDoc::GetCharFmtFromPool( sal_uInt16 nId ) |
| { |
| return (SwCharFmt*)GetFmtFromPool( nId ); |
| } |
| |
| // pruefe, ob diese "Auto-Collection" in Dokument schon/noch |
| // benutzt wird |
| bool SwDoc::IsPoolFmtUsed( sal_uInt16 nId ) const |
| { |
| SwFmt *pNewFmt = 0; |
| const SvPtrarr* pArray[ 2 ]; |
| sal_uInt16 nArrCnt = 1; |
| sal_Bool bFnd = sal_True; |
| |
| if( RES_POOLCHR_BEGIN <= nId && nId < RES_POOLCHR_END ) |
| { |
| pArray[0] = pCharFmtTbl; |
| } |
| if( RES_POOLFRM_BEGIN <= nId && nId < RES_POOLFRM_END ) |
| { |
| pArray[0] = pFrmFmtTbl; |
| pArray[1] = pSpzFrmFmtTbl; |
| nArrCnt = 2; |
| } |
| else |
| { |
| ASSERT( sal_False, "ungueltige Id" ); |
| bFnd = sal_False; |
| } |
| |
| if( bFnd ) |
| { |
| bFnd = sal_False; |
| while( nArrCnt-- && !bFnd ) |
| for( sal_uInt16 n = 0; !bFnd && n < (*pArray[nArrCnt]).Count(); ++n ) |
| if( nId == ( pNewFmt = (SwFmt*)(*pArray[ nArrCnt ] )[ n ] )-> |
| GetPoolFmtId() ) |
| bFnd = sal_True; |
| } |
| |
| // nicht gefunden oder keine Abhaengigen ? |
| if( bFnd && pNewFmt->GetDepends() ) |
| { |
| // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt |
| // (auch indirekte fuer Format-Ableitung! ) |
| SwAutoFmtGetDocNode aGetHt( &GetNodes() ); |
| bFnd = !pNewFmt->GetInfo( aGetHt ); |
| } |
| else |
| bFnd = sal_False; |
| |
| return bFnd; |
| } |
| |
| |
| |
| void lcl_PutStdPageSizeIntoItemSet( SwDoc* pDoc, SfxItemSet& rSet ) |
| { |
| SwPageDesc* pStdPgDsc = pDoc->GetPageDescFromPool( RES_POOLPAGE_STANDARD ); |
| SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() ); |
| if( pStdPgDsc->GetLandscape() ) |
| { |
| SwTwips nTmp = aFrmSz.GetHeight(); |
| aFrmSz.SetHeight( aFrmSz.GetWidth() ); |
| aFrmSz.SetWidth( nTmp ); |
| } |
| rSet.Put( aFrmSz ); |
| } |
| |
| SwPageDesc* SwDoc::GetPageDescFromPool( sal_uInt16 nId, bool bRegardLanguage ) |
| { |
| ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END, |
| "Falsche AutoFormat-Id" ); |
| |
| for( sal_uInt16 n = 0; n < aPageDescs.Count(); ++n ) |
| { |
| if ( nId == aPageDescs[ n ]->GetPoolFmtId() ) |
| { |
| return aPageDescs[ n ]; |
| } |
| } |
| |
| if( RES_POOLPAGE_BEGIN > nId || nId >= RES_POOLPAGE_END ) |
| { |
| // unknown page pool ID |
| ASSERT( !this, "<SwDoc::GetPageDescFromPool(..)> - unknown page pool ID" ); |
| nId = RES_POOLPAGE_BEGIN; |
| } |
| |
| SwPageDesc* pNewPgDsc = 0; |
| { |
| const ResId aResId( sal_uInt32(RC_POOLPAGEDESC_BEGIN + nId - RES_POOLPAGE_BEGIN), *pSwResMgr ); |
| const String aNm( aResId ); |
| const bool bIsModified = IsModified(); |
| |
| sal_uInt16 nPageDescIdx = 0; |
| { |
| ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo()); |
| nPageDescIdx = MakePageDesc( aNm, 0, bRegardLanguage ); |
| } |
| |
| pNewPgDsc = aPageDescs[ nPageDescIdx ]; |
| pNewPgDsc->SetPoolFmtId( nId ); |
| if ( !bIsModified ) |
| { |
| ResetModified(); |
| } |
| } |
| |
| SvxLRSpaceItem aLR( RES_LR_SPACE ); |
| { |
| aLR.SetLeft( GetMetricVal( CM_1 ) * 2 ); |
| aLR.SetRight( aLR.GetLeft() ); |
| } |
| SvxULSpaceItem aUL( RES_UL_SPACE ); |
| { |
| aUL.SetUpper( (sal_uInt16)aLR.GetLeft() ); |
| aUL.SetLower( (sal_uInt16)aLR.GetLeft() ); |
| } |
| |
| SwAttrSet aSet( GetAttrPool(), aPgFrmFmtSetRange ); |
| bool bSetLeft = true; |
| |
| switch( nId ) |
| { |
| case RES_POOLPAGE_STANDARD: // "Default" |
| { |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| if( pNewPgDsc ) |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| } |
| break; |
| |
| case RES_POOLPAGE_FIRST: // "First Page" |
| case RES_POOLPAGE_REGISTER: // "Index" |
| { |
| lcl_PutStdPageSizeIntoItemSet( this, aSet ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| if( pNewPgDsc ) |
| { |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| if( RES_POOLPAGE_FIRST == nId ) |
| pNewPgDsc->SetFollow( GetPageDescFromPool( RES_POOLPAGE_STANDARD )); |
| } |
| } |
| break; |
| |
| case RES_POOLPAGE_LEFT: // "Left Page" |
| { |
| lcl_PutStdPageSizeIntoItemSet( this, aSet ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| bSetLeft = false; |
| if( pNewPgDsc ) |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_LEFT ); |
| } |
| break; |
| case RES_POOLPAGE_RIGHT: // "Right Page" |
| { |
| lcl_PutStdPageSizeIntoItemSet( this, aSet ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| bSetLeft = false; |
| if( pNewPgDsc ) |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_RIGHT ); |
| } |
| break; |
| |
| case RES_POOLPAGE_JAKET: // "Envelope" |
| { |
| Size aPSize( SvxPaperInfo::GetPaperSize( PAPER_ENV_C65 ) ); |
| LandscapeSwap( aPSize ); |
| aSet.Put( SwFmtFrmSize( ATT_FIX_SIZE, aPSize.Width(), aPSize.Height() )); |
| aLR.SetLeft( 0 ); aLR.SetRight( 0 ); |
| aUL.SetUpper( 0 ); aUL.SetLower( 0 ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| |
| if( pNewPgDsc ) |
| { |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| pNewPgDsc->SetLandscape( sal_True ); |
| } |
| } |
| break; |
| |
| case RES_POOLPAGE_HTML: // "HTML" |
| { |
| lcl_PutStdPageSizeIntoItemSet( this, aSet ); |
| aLR.SetRight( GetMetricVal( CM_1 )); |
| aUL.SetUpper( (sal_uInt16)aLR.GetRight() ); |
| aUL.SetLower( (sal_uInt16)aLR.GetRight() ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| |
| if( pNewPgDsc ) |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| } |
| break; |
| |
| case RES_POOLPAGE_FOOTNOTE: // "Footnote" |
| case RES_POOLPAGE_ENDNOTE: // "Endnote" |
| { |
| lcl_PutStdPageSizeIntoItemSet( this, aSet ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| if( pNewPgDsc ) |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| SwPageFtnInfo aInf( pNewPgDsc->GetFtnInfo() ); |
| aInf.SetLineWidth( 0 ); |
| aInf.SetTopDist( 0 ); |
| aInf.SetBottomDist( 0 ); |
| pNewPgDsc->SetFtnInfo( aInf ); |
| } |
| break; |
| |
| case RES_POOLPAGE_LANDSCAPE: // "Landscape" |
| { |
| SwPageDesc* pStdPgDsc = this->GetPageDescFromPool( RES_POOLPAGE_STANDARD ); |
| SwFmtFrmSize aFrmSz( pStdPgDsc->GetMaster().GetFrmSize() ); |
| if ( !pStdPgDsc->GetLandscape() ) |
| { |
| const SwTwips nTmp = aFrmSz.GetHeight(); |
| aFrmSz.SetHeight( aFrmSz.GetWidth() ); |
| aFrmSz.SetWidth( nTmp ); |
| } |
| aSet.Put( aFrmSz ); |
| aSet.Put( aLR ); |
| aSet.Put( aUL ); |
| if( pNewPgDsc ) |
| { |
| pNewPgDsc->SetUseOn( nsUseOnPage::PD_ALL ); |
| pNewPgDsc->SetLandscape( sal_True ); |
| } |
| } |
| break; |
| |
| } |
| |
| if( aSet.Count() ) |
| { |
| if( bSetLeft ) |
| pNewPgDsc->GetLeft().SetFmtAttr( aSet ); |
| pNewPgDsc->GetMaster().SetFmtAttr( aSet ); |
| } |
| return pNewPgDsc; |
| } |
| |
| SwNumRule* SwDoc::GetNumRuleFromPool( sal_uInt16 nId ) |
| { |
| ASSERT( RES_POOLNUMRULE_BEGIN <= nId && nId < RES_POOLNUMRULE_END, |
| "Falsche AutoFormat-Id" ); |
| |
| SwNumRule* pNewRule; |
| sal_uInt16 n; |
| |
| for( n = 0; n < GetNumRuleTbl().Count(); ++n ) |
| if( nId == ( pNewRule = GetNumRuleTbl()[ n ] )->GetPoolFmtId() ) |
| { |
| return pNewRule; |
| } |
| |
| // Fehlerfall: unbekannte Poolvorlage |
| if( RES_POOLNUMRULE_BEGIN > nId || nId >= RES_POOLNUMRULE_END ) |
| { |
| ASSERT( !this, "ungueltige Id" ); |
| nId = RES_POOLNUMRULE_BEGIN; |
| } |
| |
| ResId aResId( sal_uInt32(RC_POOLNUMRULE_BEGIN + nId - RES_POOLNUMRULE_BEGIN), *pSwResMgr ); |
| String aNm( aResId ); |
| |
| SwCharFmt *pNumCFmt = 0, *pBullCFmt = 0; |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| const SvxNumberFormat::SvxNumPositionAndSpaceMode eNumberFormatPositionAndSpaceMode |
| // --> OD 2008-06-06 #i89178# |
| = numfunc::GetDefaultPositionAndSpaceMode(); |
| // <-- |
| // <-- |
| { |
| sal_Bool bIsModified = IsModified(); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| n = MakeNumRule( aNm, 0, sal_False, eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| pNewRule = GetNumRuleTbl()[ n ]; |
| pNewRule->SetPoolFmtId( nId ); |
| pNewRule->SetAutoRule( sal_False ); |
| |
| if( RES_POOLNUMRULE_NUM1 <= nId && nId <= RES_POOLNUMRULE_NUM5 ) |
| pNumCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL ); |
| |
| if( ( RES_POOLNUMRULE_BUL1 <= nId && nId <= RES_POOLNUMRULE_BUL5 ) || |
| RES_POOLNUMRULE_NUM5 == nId ) |
| pBullCFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL ); |
| |
| if( !bIsModified ) |
| ResetModified(); |
| } |
| |
| switch( nId ) |
| { |
| case RES_POOLNUMRULE_NUM1: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_ARABIC); |
| aFmt.SetCharFmt( pNumCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| aFmt.SetSuffix( aDotStr ); |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,5 1,0 1,5 2,0 2,5 3,0 3,5 4,0 4,5 5,0 |
| 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| |
| case RES_POOLNUMRULE_NUM2: |
| { |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| 283, 283, 567, 709, // 0.50, 0.50, 1.00, 1.25 |
| 850, 1021, 1304, 1474, // 1.50, 1.80, 2.30, 2.60 |
| 1588, 1758 // 2.80, 3.10 |
| }; |
| |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 385, 385, 770, 963, |
| 1155, 1386, 1771, 2002, |
| 2156, 2387 |
| }; |
| |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_ARABIC); |
| aFmt.SetCharFmt( pNumCFmt ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| } |
| // <-- |
| sal_uInt16 nSpace = 0; |
| for( n = 0; n < MAXLEVEL; ++n ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( nSpace = nSpace + pArr[ n ] ); |
| aFmt.SetFirstLineOffset( - pArr[ n ] ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( nSpace = nSpace + pArr[ n ] ); |
| aFmt.SetIndentAt( nSpace ); |
| aFmt.SetFirstLineIndent( - pArr[ n ] ); |
| } |
| // <-- |
| aFmt.SetStart( n+1 ); |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_NUM3: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_ARABIC); |
| aFmt.SetCharFmt( pNumCFmt ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| |
| sal_uInt16 nOffs = GetMetricVal( CM_1 ) * 3; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - nOffs ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - nOffs ); |
| } |
| // <-- |
| |
| for( n = 0; n < MAXLEVEL; ++n ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( (n+1) * nOffs ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( (n+1) * nOffs ); |
| aFmt.SetIndentAt( (n+1) * nOffs ); |
| } |
| // <-- |
| aFmt.SetStart( n+1 ); |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_NUM4: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_ROMAN_UPPER); |
| aFmt.SetCharFmt( pNumCFmt ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| aFmt.SetSuffix( aDotStr ); |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,5 1,0 1,5 2,0 2,5 3,0 3,5 4,0 4,5 5,0 |
| 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 283, 567, 850, 1134, 1417, 1701, 1984, 2268, 2551, 2835 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| aFmt.SetStart( n + 1 ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_NUM5: |
| { |
| // [ First, LSpace ] |
| static const sal_uInt16 aAbsSpace0to2[] = |
| { |
| 227, 227, // 0.40, 0.40, |
| 369, 624, // 0.65, 1.10, |
| 255, 879 // 0.45, 1.55 |
| }; |
| |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch0to2[] = |
| { |
| 308, 308, |
| 501, 847, |
| 347, 1194 |
| }; |
| const sal_uInt16* pArr0to2 = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace0to2 |
| : aAbsSpaceInch0to2; |
| #else |
| const sal_uInt16* pArr0to2 = aAbsSpace0to2; |
| #endif |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_ARABIC); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| aFmt.SetSuffix( aDotStr ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| } |
| // <-- |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( -pArr0to2[0] ); // == 0.40 cm |
| aFmt.SetAbsLSpace( pArr0to2[1] ); // == 0.40 cm |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetFirstLineIndent( -pArr0to2[0] ); |
| aFmt.SetListtabPos( pArr0to2[1] ); |
| aFmt.SetIndentAt( pArr0to2[1] ); |
| } |
| // <-- |
| |
| aFmt.SetCharFmt( pNumCFmt ); |
| pNewRule->Set( 0, aFmt ); |
| |
| aFmt.SetIncludeUpperLevels( 2 ); |
| aFmt.SetStart( 2 ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( -pArr0to2[2] ); // == 0.65 cm |
| aFmt.SetAbsLSpace( pArr0to2[3] ); // == 1.10 cm |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetFirstLineIndent( -pArr0to2[2] ); |
| aFmt.SetListtabPos( pArr0to2[3] ); |
| aFmt.SetIndentAt( pArr0to2[3] ); |
| } |
| // <-- |
| pNewRule->Set( 1, aFmt ); |
| |
| aFmt.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER); |
| aFmt.SetSuffix( ')'); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| aFmt.SetStart( 3 ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - pArr0to2[4] ); // == 0.45cm |
| aFmt.SetAbsLSpace( pArr0to2[5] ); // == 1.55 cm |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetFirstLineIndent( -pArr0to2[4] ); |
| aFmt.SetListtabPos( pArr0to2[5] ); |
| aFmt.SetIndentAt( pArr0to2[5] ); |
| } |
| // <-- |
| pNewRule->Set( 2, aFmt ); |
| |
| |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| aFmt.SetBulletChar( cBulletChar ); |
| sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4, |
| nOffs2 = GetMetricVal( CM_1 ) * 2; |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - nOffs ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetFirstLineIndent( - nOffs ); |
| } |
| // <-- |
| aFmt.SetSuffix( aEmptyStr ); |
| for( n = 3; n < MAXLEVEL; ++n ) |
| { |
| aFmt.SetStart( n+1 ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( nOffs2 + ((n-3) * nOffs) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( nOffs2 + ((n-3) * nOffs) ); |
| aFmt.SetIndentAt( nOffs2 + ((n-3) * nOffs) ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| |
| case RES_POOLNUMRULE_BUL1: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| aFmt.SetBulletChar( cBulletChar ); |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0 |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_BUL2: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| aFmt.SetBulletChar( 0x2013 ); |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,3 0,6 0,9 1,2 1,5 1,8 2,1 2,4 2,7 3,0 |
| 170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 170, 340, 510, 680, 850, 1020, 1191, 1361, 1531, 1701 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_BUL3: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| |
| sal_uInt16 nOffs = GetMetricVal( CM_01 ) * 4; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - nOffs ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - nOffs ); |
| } |
| // <-- |
| |
| for( n = 0; n < MAXLEVEL; ++n ) |
| { |
| aFmt.SetBulletChar( ( n & 1 ? 0x25a1 : 0x2611 ) ); |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( ((n & 1) +1) * nOffs ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( ((n & 1) +1) * nOffs ); |
| aFmt.SetIndentAt( ((n & 1) +1) * nOffs ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_BUL4: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0 |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| switch( n ) |
| { |
| case 0: aFmt.SetBulletChar( 0x27a2 ); break; |
| case 1: aFmt.SetBulletChar( 0xE006 ); break; |
| default: aFmt.SetBulletChar( 0xE004 ); break; |
| } |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| case RES_POOLNUMRULE_BUL5: |
| { |
| SwNumFmt aFmt; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| aFmt.SetPositionAndSpaceMode( eNumberFormatPositionAndSpaceMode ); |
| // <-- |
| aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); |
| aFmt.SetCharFmt( pBullCFmt ); |
| aFmt.SetStart( 1 ); |
| aFmt.SetIncludeUpperLevels( 1 ); |
| aFmt.SetBulletChar( 0x2717 ); |
| // --> OD 2006-06-29 #6440955# |
| aFmt.SetBulletFont( &numfunc::GetDefBulletFont() ); |
| // <-- |
| |
| static const sal_uInt16 aAbsSpace[ MAXLEVEL ] = |
| { |
| // cm: 0,4 0,8 1,2 1,6 2,0 2,4 2,8 3,2 3,6 4,0 |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| #ifdef USE_MEASUREMENT |
| static const sal_uInt16 aAbsSpaceInch[ MAXLEVEL ] = |
| { |
| 227, 454, 680, 907, 1134, 1361, 1587, 1814, 2041, 2268 |
| }; |
| const sal_uInt16* pArr = MEASURE_METRIC == |
| SvtSysLocale().GetLocaleData().getMeasurementSystemEnum() |
| ? aAbsSpace |
| : aAbsSpaceInch; |
| #else |
| const sal_uInt16* pArr = aAbsSpace; |
| #endif |
| |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetFirstLineOffset( - (*pArr) ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmt.SetFirstLineIndent( - (*pArr) ); |
| } |
| // <-- |
| for( n = 0; n < MAXLEVEL; ++n, ++pArr ) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmt.SetAbsLSpace( *pArr ); |
| } |
| else if ( eNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| aFmt.SetListtabPos( *pArr ); |
| aFmt.SetIndentAt( *pArr ); |
| } |
| // <-- |
| pNewRule->Set( n, aFmt ); |
| } |
| } |
| break; |
| } |
| |
| return pNewRule; |
| } |
| |
| |
| |
| // pruefe, ob diese "Auto-Collection" in Dokument schon/noch |
| // benutzt wird |
| bool SwDoc::IsPoolPageDescUsed( sal_uInt16 nId ) const |
| { |
| ASSERT( RES_POOLPAGE_BEGIN <= nId && nId < RES_POOLPAGE_END, |
| "Falsche AutoFormat-Id" ); |
| SwPageDesc *pNewPgDsc = 0; |
| sal_Bool bFnd = sal_False; |
| for( sal_uInt16 n = 0; !bFnd && n < aPageDescs.Count(); ++n ) |
| { |
| pNewPgDsc = aPageDescs[ n ]; |
| if( nId == pNewPgDsc->GetPoolFmtId() ) |
| bFnd = sal_True; |
| } |
| |
| // nicht gefunden oder keine Abhaengigen ? |
| if( !bFnd || !pNewPgDsc->GetDepends() ) // ?????? |
| return sal_False; |
| |
| // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt |
| // (auch indirekte fuer Format-Ableitung! ) |
| SwAutoFmtGetDocNode aGetHt( &GetNodes() ); |
| return !pNewPgDsc->GetInfo( aGetHt ); |
| } |
| |
| // erfrage ob die Absatz-/Zeichen-/Rahmen-/Seiten - Vorlage benutzt wird |
| sal_Bool SwDoc::IsUsed( const SwModify& rModify ) const |
| { |
| // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt |
| // (auch indirekte fuer Format-Ableitung! ) |
| SwAutoFmtGetDocNode aGetHt( &GetNodes() ); |
| return !rModify.GetInfo( aGetHt ); |
| } |
| |
| // erfrage ob die NumRule benutzt wird |
| sal_Bool SwDoc::IsUsed( const SwNumRule& rRule ) const |
| { |
| // --> OD 2008-03-04 #refactorlists# |
| // // dann teste mal, ob es abhaengige ContentNodes im Nodes Array gibt |
| // // (auch indirekte fuer Format-Ableitung! ) |
| // sal_Bool bUsed = sal_False; |
| // SwAutoFmtGetDocNode aGetHt( &aNodes ); |
| // SwModify* pMod; |
| // const SfxPoolItem* pItem; |
| // sal_uInt16 i, nMaxItems = GetAttrPool().GetItemCount( RES_PARATR_NUMRULE); |
| // for( i = 0; i < nMaxItems; ++i ) |
| // { |
| // if( 0 != (pItem = GetAttrPool().GetItem( RES_PARATR_NUMRULE, i ) ) && |
| // 0 != ( pMod = (SwModify*)((SwNumRuleItem*)pItem)->GetDefinedIn()) && |
| // ((SwNumRuleItem*)pItem)->GetValue().Len() && |
| // ((SwNumRuleItem*)pItem)->GetValue() == rRule.GetName() ) |
| // { |
| // if( pMod->IsA( TYPE( SwFmt )) ) |
| // { |
| // bUsed = !pMod->GetInfo( aGetHt ); |
| // if( bUsed ) |
| // break; |
| // } |
| // else if( ((SwTxtNode*)pMod)->GetNodes().IsDocNodes() ) |
| // { |
| // bUsed = sal_True; |
| // break; |
| // } |
| // } |
| // } |
| |
| // return bUsed; |
| sal_Bool bUsed = rRule.GetTxtNodeListSize() > 0 || |
| rRule.GetParagraphStyleListSize() > 0; |
| |
| return bUsed; |
| // <-- |
| } |
| |
| // Suche die Position vom Vorlagen-Namen. Ist nicht vorhanden |
| // dann fuege neu ein |
| sal_uInt16 SwDoc::SetDocPattern( const String& rPatternName ) |
| { |
| ASSERT( rPatternName.Len(), "kein Dokument-Vorlagenname" ); |
| |
| sal_uInt16 nNewPos = aPatternNms.Count(); |
| for( sal_uInt16 n = 0; n < aPatternNms.Count(); ++n ) |
| if( !aPatternNms[n] ) |
| { |
| if( nNewPos == aPatternNms.Count() ) |
| nNewPos = n; |
| } |
| else if( rPatternName == *aPatternNms[n] ) |
| return n; |
| |
| if( nNewPos < aPatternNms.Count() ) |
| aPatternNms.Remove( nNewPos ); // Platz wieder frei machen |
| |
| String* pNewNm = new String( rPatternName ); |
| aPatternNms.Insert( pNewNm, nNewPos ); |
| SetModified(); |
| return nNewPos; |
| } |
| |
| sal_uInt16 GetPoolParent( sal_uInt16 nId ) |
| { |
| sal_uInt16 nRet = USHRT_MAX; |
| if( POOLGRP_NOCOLLID & nId ) // 1 == Formate / 0 == Collections |
| { |
| switch( ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID ) & nId ) |
| { |
| case POOLGRP_CHARFMT: |
| case POOLGRP_FRAMEFMT: |
| nRet = 0; // vom default abgeleitet |
| break; |
| case POOLGRP_PAGEDESC: |
| case POOLGRP_NUMRULE: |
| break; // es gibt keine Ableitung |
| } |
| } |
| else |
| { |
| switch( COLL_GET_RANGE_BITS & nId ) |
| { |
| case COLL_TEXT_BITS: |
| switch( nId ) |
| { |
| case RES_POOLCOLL_STANDARD: |
| nRet = 0; break; |
| case RES_POOLCOLL_TEXT_IDENT: |
| case RES_POOLCOLL_TEXT_NEGIDENT: |
| case RES_POOLCOLL_TEXT_MOVE: |
| case RES_POOLCOLL_CONFRONTATION: |
| case RES_POOLCOLL_MARGINAL: |
| nRet = RES_POOLCOLL_TEXT; break; |
| |
| case RES_POOLCOLL_TEXT: |
| case RES_POOLCOLL_GREETING: |
| case RES_POOLCOLL_SIGNATURE: |
| case RES_POOLCOLL_HEADLINE_BASE: |
| nRet = RES_POOLCOLL_STANDARD; break; |
| |
| case RES_POOLCOLL_HEADLINE1: |
| case RES_POOLCOLL_HEADLINE2: |
| case RES_POOLCOLL_HEADLINE3: |
| case RES_POOLCOLL_HEADLINE4: |
| case RES_POOLCOLL_HEADLINE5: |
| case RES_POOLCOLL_HEADLINE6: |
| case RES_POOLCOLL_HEADLINE7: |
| case RES_POOLCOLL_HEADLINE8: |
| case RES_POOLCOLL_HEADLINE9: |
| case RES_POOLCOLL_HEADLINE10: |
| nRet = RES_POOLCOLL_HEADLINE_BASE; break; |
| } |
| break; |
| |
| case COLL_LISTS_BITS: |
| switch( nId ) |
| { |
| case RES_POOLCOLL_NUMBUL_BASE: |
| nRet = RES_POOLCOLL_TEXT; break; |
| |
| default: |
| nRet = RES_POOLCOLL_NUMBUL_BASE; break; |
| } |
| break; |
| |
| case COLL_EXTRA_BITS: |
| switch( nId ) |
| { |
| case RES_POOLCOLL_FRAME: |
| nRet = RES_POOLCOLL_TEXT; break; |
| |
| case RES_POOLCOLL_TABLE_HDLN: |
| nRet = RES_POOLCOLL_TABLE; break; |
| |
| case RES_POOLCOLL_TABLE: |
| case RES_POOLCOLL_FOOTNOTE: |
| case RES_POOLCOLL_ENDNOTE: |
| case RES_POOLCOLL_JAKETADRESS: |
| case RES_POOLCOLL_SENDADRESS: |
| case RES_POOLCOLL_HEADER: |
| case RES_POOLCOLL_HEADERL: |
| case RES_POOLCOLL_HEADERR: |
| case RES_POOLCOLL_FOOTER: |
| case RES_POOLCOLL_FOOTERL: |
| case RES_POOLCOLL_FOOTERR: |
| case RES_POOLCOLL_LABEL: |
| nRet = RES_POOLCOLL_STANDARD; break; |
| |
| case RES_POOLCOLL_LABEL_ABB: |
| case RES_POOLCOLL_LABEL_TABLE: |
| case RES_POOLCOLL_LABEL_FRAME: |
| case RES_POOLCOLL_LABEL_DRAWING: |
| nRet = RES_POOLCOLL_LABEL; break; |
| } |
| break; |
| |
| case COLL_REGISTER_BITS: |
| switch( nId ) |
| { |
| case RES_POOLCOLL_REGISTER_BASE: |
| nRet = RES_POOLCOLL_STANDARD; break; |
| |
| case RES_POOLCOLL_TOX_USERH: |
| case RES_POOLCOLL_TOX_CNTNTH: |
| case RES_POOLCOLL_TOX_IDXH: |
| case RES_POOLCOLL_TOX_ILLUSH: |
| case RES_POOLCOLL_TOX_OBJECTH: |
| case RES_POOLCOLL_TOX_TABLESH: |
| case RES_POOLCOLL_TOX_AUTHORITIESH: |
| nRet = RES_POOLCOLL_HEADLINE_BASE; break; |
| |
| default: |
| nRet = RES_POOLCOLL_REGISTER_BASE; break; |
| } |
| break; |
| |
| case COLL_DOC_BITS: |
| nRet = RES_POOLCOLL_HEADLINE_BASE; |
| break; |
| |
| case COLL_HTML_BITS: |
| nRet = RES_POOLCOLL_STANDARD; |
| break; |
| } |
| } |
| |
| return nRet; |
| } |
| |
| void SwDoc::RemoveAllFmtLanguageDependencies() |
| { |
| /* #106748# Restore the language independ pool defaults and styles. */ |
| GetAttrPool().ResetPoolDefaultItem( RES_PARATR_ADJUST ); |
| |
| SwTxtFmtColl * pTxtFmtColl = GetTxtCollFromPool( RES_POOLCOLL_STANDARD ); |
| |
| pTxtFmtColl->ResetFmtAttr( RES_PARATR_ADJUST ); |
| /* #111214# koreans do not like SvxScriptItem(sal_True) */ |
| pTxtFmtColl->ResetFmtAttr( RES_PARATR_SCRIPTSPACE ); |
| |
| SvxFrameDirectionItem aFrameDir( FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR ); |
| |
| sal_uInt16 nCount = GetPageDescCnt(); |
| for( sal_uInt16 i=0; i<nCount; ++i ) |
| { |
| SwPageDesc& rDesc = _GetPageDesc( i ); |
| rDesc.GetMaster().SetFmtAttr( aFrameDir ); |
| rDesc.GetLeft().SetFmtAttr( aFrameDir ); |
| } |
| |
| // OD 09.10.2003 #i18732# - restore static pool default for item |
| // RES_FOLLOW_TEXT_FLOW. |
| GetAttrPool().ResetPoolDefaultItem( RES_FOLLOW_TEXT_FLOW ); |
| |
| //#i16874# AutoKerning as default for new documents |
| GetAttrPool().ResetPoolDefaultItem( RES_CHRATR_AUTOKERN ); |
| } |