| /************************************************************** |
| * |
| * 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_editeng.hxx" |
| |
| #include <editeng/numitem.hxx> |
| |
| #include <com/sun/star/text/HoriOrientation.hpp> |
| #include <com/sun/star/text/VertOrientation.hpp> |
| #include <com/sun/star/text/RelOrientation.hpp> |
| #include <editeng/brshitem.hxx> |
| #include <vcl/font.hxx> |
| #include <editeng/editids.hrc> |
| #include <editeng/editrids.hrc> |
| #include <editeng/numdef.hxx> |
| #include <vcl/graph.hxx> |
| #include <vcl/window.hxx> |
| #include <vcl/svapp.hxx> |
| #include <editeng/unolingu.hxx> |
| #include <com/sun/star/text/XNumberingFormatter.hpp> |
| #include <com/sun/star/text/XDefaultNumberingProvider.hpp> |
| #include <com/sun/star/style/NumberingType.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| #include <comphelper/processfactory.hxx> |
| |
| #include <editeng/unonrule.hxx> |
| |
| #define MM100_TO_TWIP(MM100) ((MM100*72L+63L)/127L) |
| |
| #define DEF_WRITER_LSPACE 500 //Standardeinrueckung |
| #define DEF_DRAW_LSPACE 800 //Standardeinrueckung |
| |
| #define NUMITEM_VERSION_01 0x01 |
| #define NUMITEM_VERSION_02 0x02 |
| #define NUMITEM_VERSION_03 0x03 |
| #define NUMITEM_VERSION_04 0x04 |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::text; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::style; |
| |
| sal_Int32 SvxNumberType::nRefCount = 0; |
| com::sun::star::uno::Reference<com::sun::star::text::XNumberingFormatter> SvxNumberType::xFormatter = 0; |
| void lcl_getFormatter(com::sun::star::uno::Reference<com::sun::star::text::XNumberingFormatter>& _xFormatter) |
| { |
| if(!_xFormatter.is()) |
| { |
| try |
| { |
| Reference< XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory(); |
| Reference < XInterface > xI = xMSF->createInstance( |
| ::rtl::OUString::createFromAscii( "com.sun.star.text.DefaultNumberingProvider" ) ); |
| Reference<XDefaultNumberingProvider> xRet(xI, UNO_QUERY); |
| DBG_ASSERT(xRet.is(), "service missing: \"com.sun.star.text.DefaultNumberingProvider\""); |
| _xFormatter = Reference<XNumberingFormatter> (xRet, UNO_QUERY); |
| } |
| catch(Exception& ) |
| { |
| } |
| } |
| } |
| /* -----------------------------22.02.01 14:24-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxNumberType::SvxNumberType(sal_Int16 nType) : |
| nNumType(nType), |
| bShowSymbol(sal_True) |
| { |
| nRefCount++; |
| } |
| /* -----------------------------22.02.01 14:31-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxNumberType::SvxNumberType(const SvxNumberType& rType) : |
| nNumType(rType.nNumType), |
| bShowSymbol(rType.bShowSymbol) |
| { |
| nRefCount++; |
| } |
| /* -----------------------------22.02.01 14:24-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxNumberType::~SvxNumberType() |
| { |
| if(!--nRefCount) |
| xFormatter = 0; |
| } |
| /* -----------------------------22.02.01 11:09-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| String SvxNumberType::GetNumStr( sal_uLong nNo ) const |
| { |
| LanguageType eLang = Application::GetSettings().GetLanguage(); |
| Locale aLocale = SvxCreateLocale(eLang); |
| return GetNumStr( nNo, aLocale ); |
| } |
| /* -----------------28.10.98 15:56------------------- |
| * |
| * --------------------------------------------------*/ |
| String SvxNumberType::GetNumStr( sal_uLong nNo, const Locale& rLocale ) const |
| { |
| lcl_getFormatter(xFormatter); |
| String aTmpStr; |
| if(!xFormatter.is()) |
| return aTmpStr; |
| |
| if(bShowSymbol) |
| { |
| switch(nNumType) |
| { |
| case NumberingType::CHAR_SPECIAL: |
| case NumberingType::BITMAP: |
| break; |
| default: |
| { |
| //#95525# '0' allowed for ARABIC numberings |
| if(NumberingType::ARABIC == nNumType && 0 == nNo ) |
| aTmpStr = '0'; |
| else |
| { |
| Sequence< PropertyValue > aProperties(2); |
| PropertyValue* pValues = aProperties.getArray(); |
| pValues[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NumberingType")); |
| pValues[0].Value <<= nNumType; |
| pValues[1].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Value")); |
| pValues[1].Value <<= (sal_Int32)nNo; |
| |
| try |
| { |
| aTmpStr = xFormatter->makeNumberingString( aProperties, rLocale ); |
| } |
| catch(Exception&) |
| { |
| } |
| } |
| } |
| } |
| } |
| return aTmpStr; |
| } |
| /* -----------------27.10.98 10:33------------------- |
| * |
| * --------------------------------------------------*/ |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| SvxNumberFormat::SvxNumberFormat( sal_Int16 eType, |
| SvxNumPositionAndSpaceMode ePositionAndSpaceMode ) |
| // <-- |
| : SvxNumberType(eType), |
| eNumAdjust(SVX_ADJUST_LEFT), |
| nInclUpperLevels(0), |
| nStart(1), |
| cBullet(SVX_DEF_BULLET), |
| nBulletRelSize(100), |
| nBulletColor(COL_BLACK), |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| mePositionAndSpaceMode( ePositionAndSpaceMode ), |
| // <-- |
| nFirstLineOffset(0), |
| nAbsLSpace(0), |
| nLSpace(0), |
| nCharTextDistance(0), |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| meLabelFollowedBy( LISTTAB ), |
| mnListtabPos( 0 ), |
| mnFirstLineIndent( 0 ), |
| mnIndentAt( 0 ), |
| // <-- |
| pGraphicBrush(0), |
| eVertOrient(text::VertOrientation::NONE), |
| pBulletFont(0) |
| { |
| } |
| /* -----------------27.10.98 10:56------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumberFormat::SvxNumberFormat(const SvxNumberFormat& rFormat) : |
| SvxNumberType(rFormat), |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| mePositionAndSpaceMode( rFormat.mePositionAndSpaceMode ), |
| // <-- |
| pGraphicBrush(0), |
| pBulletFont(0) |
| { |
| *this = rFormat; |
| } |
| /* -----------------27.10.98 10:56------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumberFormat::~SvxNumberFormat() |
| { |
| delete pGraphicBrush; |
| delete pBulletFont; |
| } |
| /* -----------------08.12.98 11:14------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumberFormat::SvxNumberFormat(SvStream &rStream) |
| : mePositionAndSpaceMode( LABEL_WIDTH_AND_POSITION ), |
| meLabelFollowedBy( LISTTAB ), |
| mnListtabPos( 0 ), |
| mnFirstLineIndent( 0 ), |
| mnIndentAt( 0 ) |
| { |
| |
| sal_uInt16 nVersion; |
| rStream >> nVersion; |
| |
| sal_uInt16 nUSHORT; |
| rStream >> nUSHORT; |
| SetNumberingType((sal_Int16)nUSHORT); |
| rStream >> nUSHORT; |
| eNumAdjust = (SvxAdjust)nUSHORT; |
| rStream >> nUSHORT; |
| nInclUpperLevels = (sal_uInt8)nUSHORT; |
| rStream >> nUSHORT; |
| nStart = nUSHORT; |
| rStream >> nUSHORT; |
| cBullet = nUSHORT; |
| |
| short nShort; |
| rStream >> nShort; |
| nFirstLineOffset = nShort; |
| rStream >> nShort; |
| nAbsLSpace = nShort; |
| rStream >> nShort; |
| nLSpace = nShort; |
| |
| rStream >> nShort; |
| nCharTextDistance = nShort; |
| rtl_TextEncoding eEnc = gsl_getSystemTextEncoding(); |
| rStream.ReadByteString(sPrefix, eEnc); |
| rStream.ReadByteString(sSuffix, eEnc); |
| rStream.ReadByteString(sCharStyleName, eEnc); |
| rStream >> nUSHORT; |
| if(nUSHORT) |
| { |
| SvxBrushItem aHelper(0); |
| pGraphicBrush = (SvxBrushItem*) aHelper.Create( rStream, BRUSH_GRAPHIC_VERSION ); |
| } |
| else |
| pGraphicBrush = 0; |
| |
| rStream >> nUSHORT; |
| eVertOrient = (sal_Int16)nUSHORT; |
| |
| rStream >> nUSHORT; |
| if(nUSHORT) |
| { |
| pBulletFont = new Font; |
| rStream >> *pBulletFont; |
| if(!pBulletFont->GetCharSet()) |
| pBulletFont->SetCharSet(rStream.GetStreamCharSet()); |
| } |
| else |
| pBulletFont = 0; |
| rStream >> aGraphicSize; |
| |
| rStream >> nBulletColor; |
| rStream >> nUSHORT; |
| nBulletRelSize = nUSHORT; |
| rStream >> nUSHORT; |
| SetShowSymbol((sal_Bool)nUSHORT); |
| |
| if( nVersion < NUMITEM_VERSION_03 ) |
| cBullet = ByteString::ConvertToUnicode( (sal_Char)cBullet, |
| (pBulletFont&&pBulletFont->GetCharSet()) ? pBulletFont->GetCharSet() |
| : RTL_TEXTENCODING_SYMBOL ); |
| if(pBulletFont) |
| { |
| sal_Bool bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50; |
| if(bConvertBulletFont) |
| { |
| |
| FontToSubsFontConverter pConverter = |
| CreateFontToSubsFontConverter(pBulletFont->GetName(), |
| FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS); |
| if(pConverter) |
| { |
| cBullet = ConvertFontToSubsFontChar(pConverter, cBullet); |
| String sFontName = GetFontToSubsFontName(pConverter); |
| pBulletFont->SetName(sFontName); |
| DestroyFontToSubsFontConverter(pConverter); |
| } |
| } |
| } |
| |
| if( NUMITEM_VERSION_04 <= nVersion ) |
| { |
| rStream >> nUSHORT; |
| mePositionAndSpaceMode = (SvxNumPositionAndSpaceMode) nUSHORT; |
| rStream >> nUSHORT; |
| meLabelFollowedBy = ( SvxNumLabelFollowedBy ) nUSHORT; |
| long nLong; |
| rStream >> nLong; |
| mnListtabPos = nLong; |
| rStream >> nLong; |
| mnFirstLineIndent = nLong; |
| rStream >> nLong; |
| mnIndentAt = nLong; |
| } |
| } |
| /* -----------------08.12.98 11:14------------------- |
| * |
| * --------------------------------------------------*/ |
| SvStream& SvxNumberFormat::Store(SvStream &rStream, FontToSubsFontConverter pConverter) |
| { |
| if(pConverter && pBulletFont) |
| { |
| cBullet = ConvertFontToSubsFontChar(pConverter, cBullet); |
| String sFontName = GetFontToSubsFontName(pConverter); |
| pBulletFont->SetName(sFontName); |
| } |
| |
| rStream << (sal_uInt16)NUMITEM_VERSION_04; |
| |
| rStream << (sal_uInt16)GetNumberingType(); |
| rStream << (sal_uInt16)eNumAdjust; |
| rStream << (sal_uInt16)nInclUpperLevels; |
| rStream << nStart; |
| rStream << (sal_uInt16)cBullet; |
| |
| rStream << nFirstLineOffset; |
| rStream << nAbsLSpace; |
| rStream << nLSpace; |
| |
| rStream << nCharTextDistance; |
| rtl_TextEncoding eEnc = gsl_getSystemTextEncoding(); |
| rStream.WriteByteString(sPrefix, eEnc); |
| rStream.WriteByteString(sSuffix, eEnc); |
| rStream.WriteByteString(sCharStyleName, eEnc); |
| if(pGraphicBrush) |
| { |
| rStream << (sal_uInt16)1; |
| |
| // #75113# in SD or SI force bullet itself to be stored, |
| // for that purpose throw away link when link and graphic |
| // are present, so Brush save is forced |
| if(pGraphicBrush->GetGraphicLink() && pGraphicBrush->GetGraphic()) |
| { |
| String aEmpty; |
| pGraphicBrush->SetGraphicLink(aEmpty); |
| } |
| |
| pGraphicBrush->Store(rStream, BRUSH_GRAPHIC_VERSION); |
| } |
| else |
| rStream << (sal_uInt16)0; |
| |
| rStream << (sal_uInt16)eVertOrient; |
| if(pBulletFont) |
| { |
| rStream << (sal_uInt16)1; |
| rStream << *pBulletFont; |
| } |
| else |
| rStream << (sal_uInt16)0; |
| rStream << aGraphicSize; |
| |
| Color nTempColor = nBulletColor; |
| if(COL_AUTO == nBulletColor.GetColor()) |
| nTempColor = COL_BLACK; |
| rStream << nTempColor; |
| rStream << nBulletRelSize; |
| rStream << (sal_uInt16)IsShowSymbol(); |
| |
| rStream << ( sal_uInt16 ) mePositionAndSpaceMode; |
| rStream << ( sal_uInt16 ) meLabelFollowedBy; |
| rStream << ( long ) mnListtabPos; |
| rStream << ( long ) mnFirstLineIndent; |
| rStream << ( long ) mnIndentAt; |
| |
| return rStream; |
| } |
| |
| /* -----------------------------23.02.01 11:10-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxNumberFormat& SvxNumberFormat::operator=( const SvxNumberFormat& rFormat ) |
| { |
| if (& rFormat == this) { return *this; } |
| |
| SetNumberingType(rFormat.GetNumberingType()); |
| eNumAdjust = rFormat.eNumAdjust ; |
| nInclUpperLevels = rFormat.nInclUpperLevels ; |
| nStart = rFormat.nStart ; |
| cBullet = rFormat.cBullet ; |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| mePositionAndSpaceMode = rFormat.mePositionAndSpaceMode; |
| // <-- |
| nFirstLineOffset = rFormat.nFirstLineOffset; |
| nAbsLSpace = rFormat.nAbsLSpace ; |
| nLSpace = rFormat.nLSpace ; |
| nCharTextDistance = rFormat.nCharTextDistance ; |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| meLabelFollowedBy = rFormat.meLabelFollowedBy; |
| mnListtabPos = rFormat.mnListtabPos; |
| mnFirstLineIndent = rFormat.mnFirstLineIndent; |
| mnIndentAt = rFormat.mnIndentAt; |
| // <-- |
| eVertOrient = rFormat.eVertOrient ; |
| sPrefix = rFormat.sPrefix ; |
| sSuffix = rFormat.sSuffix ; |
| aGraphicSize = rFormat.aGraphicSize ; |
| nBulletColor = rFormat.nBulletColor ; |
| nBulletRelSize = rFormat.nBulletRelSize; |
| SetShowSymbol(rFormat.IsShowSymbol()); |
| sCharStyleName = rFormat.sCharStyleName; |
| DELETEZ(pGraphicBrush); |
| if(rFormat.pGraphicBrush) |
| { |
| pGraphicBrush = new SvxBrushItem(*rFormat.pGraphicBrush); |
| pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) ); |
| } |
| DELETEZ(pBulletFont); |
| if(rFormat.pBulletFont) |
| pBulletFont = new Font(*rFormat.pBulletFont); |
| return *this; |
| } |
| /* -----------------27.10.98 10:56------------------- |
| * |
| * --------------------------------------------------*/ |
| sal_Bool SvxNumberFormat::operator==( const SvxNumberFormat& rFormat) const |
| { |
| if( GetNumberingType() != rFormat.GetNumberingType() || |
| eNumAdjust != rFormat.eNumAdjust || |
| nInclUpperLevels != rFormat.nInclUpperLevels || |
| nStart != rFormat.nStart || |
| cBullet != rFormat.cBullet || |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| mePositionAndSpaceMode != rFormat.mePositionAndSpaceMode || |
| // <-- |
| nFirstLineOffset != rFormat.nFirstLineOffset || |
| nAbsLSpace != rFormat.nAbsLSpace || |
| nLSpace != rFormat.nLSpace || |
| nCharTextDistance != rFormat.nCharTextDistance || |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| meLabelFollowedBy != rFormat.meLabelFollowedBy || |
| mnListtabPos != rFormat.mnListtabPos || |
| mnFirstLineIndent != rFormat.mnFirstLineIndent || |
| mnIndentAt != rFormat.mnIndentAt || |
| // <-- |
| eVertOrient != rFormat.eVertOrient || |
| sPrefix != rFormat.sPrefix || |
| sSuffix != rFormat.sSuffix || |
| aGraphicSize != rFormat.aGraphicSize || |
| nBulletColor != rFormat.nBulletColor || |
| nBulletRelSize != rFormat.nBulletRelSize || |
| IsShowSymbol() != rFormat.IsShowSymbol() || |
| sCharStyleName != rFormat.sCharStyleName |
| ) |
| return sal_False; |
| if ( |
| (pGraphicBrush && !rFormat.pGraphicBrush) || |
| (!pGraphicBrush && rFormat.pGraphicBrush) || |
| (pGraphicBrush && *pGraphicBrush != *rFormat.pGraphicBrush) |
| ) |
| { |
| return sal_False; |
| } |
| if ( |
| (pBulletFont && !rFormat.pBulletFont) || |
| (!pBulletFont && rFormat.pBulletFont) || |
| (pBulletFont && *pBulletFont != *rFormat.pBulletFont) |
| ) |
| { |
| return sal_False; |
| } |
| return sal_True; |
| } |
| /* -----------------28.10.98 09:53------------------- |
| * |
| * --------------------------------------------------*/ |
| void SvxNumberFormat::SetGraphicBrush( const SvxBrushItem* pBrushItem, |
| const Size* pSize, const sal_Int16* pOrient) |
| { |
| if(!pBrushItem) |
| { |
| delete pGraphicBrush; |
| pGraphicBrush = 0; |
| } |
| else if ( !pGraphicBrush || (pGraphicBrush && !(*pBrushItem == *pGraphicBrush)) ) |
| { |
| delete pGraphicBrush; |
| pGraphicBrush = (SvxBrushItem*)pBrushItem->Clone(); |
| pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) ); |
| } |
| |
| if(pOrient) |
| eVertOrient = *pOrient; |
| else |
| eVertOrient = text::VertOrientation::NONE; |
| if(pSize) |
| aGraphicSize = *pSize; |
| else |
| aGraphicSize.Width() = aGraphicSize.Height() = 0; |
| } |
| /* -----------------28.10.98 09:59------------------- |
| * |
| * --------------------------------------------------*/ |
| void SvxNumberFormat::SetGraphic( const String& rName ) |
| { |
| const String* pName; |
| if( pGraphicBrush && |
| 0 != (pName = pGraphicBrush->GetGraphicLink()) |
| && *pName == rName ) |
| return ; |
| |
| delete pGraphicBrush; |
| String sTmp; |
| pGraphicBrush = new SvxBrushItem( rName, sTmp, GPOS_AREA, 0 ); |
| pGraphicBrush->SetDoneLink( STATIC_LINK( this, SvxNumberFormat, GraphicArrived) ); |
| if( eVertOrient == text::VertOrientation::NONE ) |
| eVertOrient = text::VertOrientation::TOP; |
| |
| aGraphicSize.Width() = aGraphicSize.Height() = 0; |
| } |
| /* -----------------------------22.02.01 15:55-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxNumberFormat::SetVertOrient(sal_Int16 eSet) |
| { |
| eVertOrient = eSet; |
| } |
| /* -----------------------------22.02.01 15:55-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Int16 SvxNumberFormat::GetVertOrient() const |
| { |
| return eVertOrient; |
| } |
| /* -----------------28.10.98 09:59------------------- |
| * |
| * --------------------------------------------------*/ |
| void SvxNumberFormat::SetBulletFont(const Font* pFont) |
| { |
| delete pBulletFont; |
| pBulletFont = pFont ? new Font(*pFont): 0; |
| } |
| |
| // --> OD 2008-01-09 #newlistlevelattrs# |
| SvxNumberFormat::SvxNumPositionAndSpaceMode SvxNumberFormat::GetPositionAndSpaceMode() const |
| { |
| return mePositionAndSpaceMode; |
| } |
| void SvxNumberFormat::SetPositionAndSpaceMode( SvxNumPositionAndSpaceMode ePositionAndSpaceMode ) |
| { |
| mePositionAndSpaceMode = ePositionAndSpaceMode; |
| } |
| |
| short SvxNumberFormat::GetLSpace() const |
| { |
| //#if OSL_DEBUG_LEVEL > 1 |
| // DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION, |
| // "<SvxNumberFormat::GetLSpace()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION"); |
| //#endif |
| return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION ? nLSpace : 0; |
| } |
| short SvxNumberFormat::GetAbsLSpace() const |
| { |
| //#if OSL_DEBUG_LEVEL > 1 |
| // DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION, |
| // "<SvxNumberFormat::GetAbsLSpace()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION"); |
| //#endif |
| return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION |
| ? nAbsLSpace |
| : static_cast<short>( GetFirstLineIndent() + GetIndentAt() ); |
| } |
| short SvxNumberFormat::GetFirstLineOffset() const |
| { |
| //#if OSL_DEBUG_LEVEL > 1 |
| // DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION, |
| // "<SvxNumberFormat::GetFirstLineOffset()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION"); |
| //#endif |
| return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION |
| ? nFirstLineOffset |
| : static_cast<short>( GetFirstLineIndent() ); |
| } |
| short SvxNumberFormat::GetCharTextDistance() const |
| { |
| //#if OSL_DEBUG_LEVEL > 1 |
| // DBG_ASSERT( mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION, |
| // "<SvxNumberFormat::GetCharTextDistance()> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION"); |
| //#endif |
| return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION ? nCharTextDistance : 0; |
| } |
| |
| void SvxNumberFormat::SetLabelFollowedBy( const SvxNumLabelFollowedBy eLabelFollowedBy ) |
| { |
| meLabelFollowedBy = eLabelFollowedBy; |
| } |
| SvxNumberFormat::SvxNumLabelFollowedBy SvxNumberFormat::GetLabelFollowedBy() const |
| { |
| return meLabelFollowedBy; |
| } |
| void SvxNumberFormat::SetListtabPos( const long nListtabPos ) |
| { |
| mnListtabPos = nListtabPos; |
| } |
| long SvxNumberFormat::GetListtabPos() const |
| { |
| return mnListtabPos; |
| } |
| void SvxNumberFormat::SetFirstLineIndent( const long nFirstLineIndent ) |
| { |
| mnFirstLineIndent = nFirstLineIndent; |
| } |
| long SvxNumberFormat::GetFirstLineIndent() const |
| { |
| return mnFirstLineIndent; |
| } |
| void SvxNumberFormat::SetIndentAt( const long nIndentAt ) |
| { |
| mnIndentAt = nIndentAt; |
| } |
| long SvxNumberFormat::GetIndentAt() const |
| { |
| return mnIndentAt; |
| } |
| // <-- |
| |
| /* -----------------28.10.98 10:03------------------- |
| * |
| * --------------------------------------------------*/ |
| IMPL_STATIC_LINK( SvxNumberFormat, GraphicArrived, void *, EMPTYARG ) |
| { |
| // ggfs. die GrfSize setzen: |
| if( !pThis->aGraphicSize.Width() || !pThis->aGraphicSize.Height() ) |
| { |
| const Graphic* pGrf = pThis->pGraphicBrush->GetGraphic(); |
| if( pGrf ) |
| pThis->aGraphicSize = SvxNumberFormat::GetGraphicSizeMM100( pGrf ); |
| } |
| pThis->NotifyGraphicArrived(); |
| return 0; |
| } |
| /* -----------------------------02.07.01 15:36-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxNumberFormat::NotifyGraphicArrived() |
| { |
| } |
| |
| /* -----------------28.10.98 10:38------------------- |
| * |
| * --------------------------------------------------*/ |
| Size SvxNumberFormat::GetGraphicSizeMM100(const Graphic* pGraphic) |
| { |
| const MapMode aMapMM100( MAP_100TH_MM ); |
| const Size& rSize = pGraphic->GetPrefSize(); |
| Size aRetSize; |
| if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL ) |
| { |
| OutputDevice* pOutDev = Application::GetDefaultDevice(); |
| MapMode aOldMap( pOutDev->GetMapMode() ); |
| pOutDev->SetMapMode( aMapMM100 ); |
| aRetSize = pOutDev->PixelToLogic( rSize ); |
| pOutDev->SetMapMode( aOldMap ); |
| } |
| else |
| aRetSize = OutputDevice::LogicToLogic( rSize, pGraphic->GetPrefMapMode(), aMapMM100 ); |
| return aRetSize; |
| } |
| /* -----------------28.10.98 15:57------------------- |
| * |
| * --------------------------------------------------*/ |
| String SvxNumberFormat::CreateRomanString( sal_uLong nNo, sal_Bool bUpper ) |
| { |
| nNo %= 4000; // mehr kann nicht dargestellt werden |
| // i, ii, iii, iv, v, vi, vii, vii, viii, ix |
| // (Dummy),1000,500,100,50,10,5,1 |
| const char *cRomanArr = bUpper |
| ? "MDCLXVI--" // +2 Dummy-Eintraege !! |
| : "mdclxvi--"; // +2 Dummy-Eintraege !! |
| |
| String sRet; |
| sal_uInt16 nMask = 1000; |
| while( nMask ) |
| { |
| sal_uInt8 nZahl = sal_uInt8(nNo / nMask); |
| sal_uInt8 nDiff = 1; |
| nNo %= nMask; |
| |
| if( 5 < nZahl ) |
| { |
| if( nZahl < 9 ) |
| sRet += sal_Unicode(*(cRomanArr-1)); |
| ++nDiff; |
| nZahl -= 5; |
| } |
| switch( nZahl ) |
| { |
| case 3: { sRet += sal_Unicode(*cRomanArr); } |
| case 2: { sRet += sal_Unicode(*cRomanArr); } |
| case 1: { sRet += sal_Unicode(*cRomanArr); } |
| break; |
| |
| case 4: { |
| sRet += sal_Unicode(*cRomanArr); |
| sRet += sal_Unicode(*(cRomanArr-nDiff)); |
| } |
| break; |
| case 5: { sRet += sal_Unicode(*(cRomanArr-nDiff)); } |
| break; |
| } |
| |
| nMask /= 10; // zur naechsten Dekade |
| cRomanArr += 2; |
| } |
| return sRet; |
| } |
| #ifdef OLD_NUMBER_FORMATTING |
| void SvxNumberFormat::GetCharStr( sal_uLong nNo, String& rStr ) const |
| { |
| DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" ); |
| |
| const sal_uLong coDiff = 'Z' - 'A' +1; |
| char cAdd = (SVX_NUM_CHARS_UPPER_LETTER == eNumType ? 'A' : 'a') - 1; |
| sal_uLong nCalc; |
| |
| do { |
| nCalc = nNo % coDiff; |
| if( !nCalc ) |
| nCalc = coDiff; |
| rStr.Insert( sal_Unicode(cAdd + nCalc ), 0 ); |
| nNo -= nCalc; |
| if( nNo ) |
| nNo /= coDiff; |
| } while( nNo ); |
| } |
| |
| void SvxNumberFormat::GetCharStrN( sal_uLong nNo, String& rStr ) const |
| { |
| DBG_ASSERT( nNo, "0 ist eine ungueltige Nummer !!" ); |
| |
| const sal_uLong coDiff = 'Z' - 'A' +1; |
| char cChar = (char)(--nNo % coDiff); |
| if( SVX_NUM_CHARS_UPPER_LETTER_N == eNumType ) |
| cChar += 'A'; |
| else |
| cChar += 'a'; |
| |
| rStr.Fill( (sal_uInt16)(nNo / coDiff) + 1, sal_Unicode(cChar) ); |
| } |
| #endif //OLD_NUMBER_FORMATTING |
| /* -----------------------------22.02.01 13:31-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| const String& SvxNumberFormat::GetCharFmtName()const |
| { |
| return sCharStyleName; |
| } |
| /* -----------------27.10.98 10:38------------------- |
| * |
| * --------------------------------------------------*/ |
| sal_Int32 SvxNumRule::nRefCount = 0; |
| static SvxNumberFormat* pStdNumFmt = 0; |
| static SvxNumberFormat* pStdOutlineNumFmt = 0; |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| SvxNumRule::SvxNumRule( sal_uLong nFeatures, |
| sal_uInt16 nLevels, |
| sal_Bool bCont, |
| SvxNumRuleType eType, |
| SvxNumberFormat::SvxNumPositionAndSpaceMode |
| eDefaultNumberFormatPositionAndSpaceMode ) |
| : nLevelCount(nLevels), |
| nFeatureFlags(nFeatures), |
| eNumberingType(eType), |
| bContinuousNumbering(bCont) |
| { |
| ++nRefCount; |
| LanguageType eLang = Application::GetSettings().GetLanguage(); |
| aLocale = SvxCreateLocale(eLang); |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| { |
| if(i < nLevels) |
| { |
| aFmts[i] = new SvxNumberFormat(SVX_NUM_CHARS_UPPER_LETTER); |
| //daran wird zwischen writer und draw unterschieden |
| if(nFeatures & NUM_CONTINUOUS) |
| { |
| // --> OD 2008-02-11 #newlistlevelattrs# |
| if ( eDefaultNumberFormatPositionAndSpaceMode == |
| SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) |
| { |
| aFmts[i]->SetLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE) ); |
| aFmts[i]->SetAbsLSpace( MM100_TO_TWIP(DEF_WRITER_LSPACE * (i+1)) ); |
| aFmts[i]->SetFirstLineOffset(MM100_TO_TWIP(-DEF_WRITER_LSPACE)); |
| } |
| else if ( eDefaultNumberFormatPositionAndSpaceMode == |
| SvxNumberFormat::LABEL_ALIGNMENT ) |
| { |
| // first line indent of general numbering in inch: -0,25 inch |
| const long cFirstLineIndent = -1440/4; |
| // indent values of general numbering in inch: |
| // 0,5 0,75 1,0 1,25 1,5 |
| // 1,75 2,0 2,25 2,5 2,75 |
| const long cIndentAt = 1440/4; |
| aFmts[i]->SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT ); |
| aFmts[i]->SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); |
| aFmts[i]->SetListtabPos( cIndentAt * (i+2) ); |
| aFmts[i]->SetFirstLineIndent( cFirstLineIndent ); |
| aFmts[i]->SetIndentAt( cIndentAt * (i+2) ); |
| } |
| // <-- |
| } |
| else |
| { |
| aFmts[i]->SetLSpace( DEF_DRAW_LSPACE ); |
| aFmts[i]->SetAbsLSpace( DEF_DRAW_LSPACE * (i) ); |
| } |
| } |
| else |
| aFmts[i] = 0; |
| aFmtsSet[i] = sal_False; |
| } |
| } |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumRule::SvxNumRule(const SvxNumRule& rCopy) |
| { |
| ++nRefCount; |
| aLocale = rCopy.aLocale; |
| nLevelCount = rCopy.nLevelCount ; |
| nFeatureFlags = rCopy.nFeatureFlags ; |
| bContinuousNumbering = rCopy.bContinuousNumbering; |
| eNumberingType = rCopy.eNumberingType; |
| memset( aFmts, 0, sizeof( aFmts )); |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| { |
| if(rCopy.aFmts[i]) |
| aFmts[i] = new SvxNumberFormat(*rCopy.aFmts[i]); |
| else |
| aFmts[i] = 0; |
| aFmtsSet[i] = rCopy.aFmtsSet[i]; |
| } |
| } |
| /* -----------------08.12.98 11:07------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumRule::SvxNumRule(SvStream &rStream) |
| { |
| ++nRefCount; |
| LanguageType eLang = Application::GetSettings().GetLanguage(); |
| aLocale = SvxCreateLocale(eLang); |
| sal_uInt16 nVersion; |
| sal_uInt16 nTemp; |
| rStream >> nVersion; |
| rStream >> nLevelCount; |
| rStream >> nTemp; |
| nFeatureFlags = nTemp; |
| rStream >> nTemp; |
| bContinuousNumbering = (sal_Bool)nTemp; |
| rStream >> nTemp; |
| eNumberingType = (SvxNumRuleType)nTemp; |
| memset( aFmts, 0, sizeof( aFmts )); |
| |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| { |
| sal_uInt16 nSet; |
| rStream >> nSet; |
| if(nSet) |
| aFmts[i] = new SvxNumberFormat(rStream); |
| else |
| aFmts[i] = 0; |
| aFmtsSet[i] = aFmts[i] ? sal_True : sal_False; |
| } |
| if(NUMITEM_VERSION_02 <= nVersion) |
| { |
| sal_uInt16 nShort; |
| rStream >> nShort; |
| nFeatureFlags = nShort; |
| } |
| } |
| |
| /* -----------------08.12.98 11:07------------------- |
| * |
| * --------------------------------------------------*/ |
| SvStream& SvxNumRule::Store(SvStream &rStream) |
| { |
| rStream<<(sal_uInt16)NUMITEM_VERSION_03; |
| rStream<<nLevelCount; |
| //first save of nFeatureFlags for old versions |
| rStream<<(sal_uInt16)nFeatureFlags; |
| rStream<<(sal_uInt16)bContinuousNumbering; |
| rStream<<(sal_uInt16)eNumberingType; |
| |
| FontToSubsFontConverter pConverter = 0; |
| sal_Bool bConvertBulletFont = rStream.GetVersion() <= SOFFICE_FILEFORMAT_50; |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| { |
| if(aFmts[i]) |
| { |
| rStream << sal_uInt16(1); |
| if(bConvertBulletFont && aFmts[i]->GetBulletFont()) |
| { |
| if(!pConverter) |
| pConverter = |
| CreateFontToSubsFontConverter(aFmts[i]->GetBulletFont()->GetName(), |
| FONTTOSUBSFONT_EXPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS); |
| } |
| aFmts[i]->Store(rStream, pConverter); |
| } |
| else |
| rStream << sal_uInt16(0); |
| } |
| //second save of nFeatureFlags for new versions |
| rStream<<(sal_uInt16)nFeatureFlags; |
| if(pConverter) |
| DestroyFontToSubsFontConverter(pConverter); |
| |
| return rStream; |
| } |
| |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumRule::~SvxNumRule() |
| { |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| delete aFmts[i]; |
| if(!--nRefCount) |
| { |
| DELETEZ(pStdNumFmt); |
| DELETEZ(pStdOutlineNumFmt); |
| } |
| } |
| /* -----------------29.10.98 16:07------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumRule& SvxNumRule::operator=( const SvxNumRule& rCopy ) |
| { |
| nLevelCount = rCopy.nLevelCount; |
| nFeatureFlags = rCopy.nFeatureFlags; |
| bContinuousNumbering = rCopy.bContinuousNumbering; |
| eNumberingType = rCopy.eNumberingType; |
| for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++) |
| { |
| delete aFmts[i]; |
| if(rCopy.aFmts[i]) |
| aFmts[i] = new SvxNumberFormat(*rCopy.aFmts[i]); |
| else |
| aFmts[i] = 0; |
| aFmtsSet[i] = rCopy.aFmtsSet[i]; |
| } |
| return *this; |
| } |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| int SvxNumRule::operator==( const SvxNumRule& rCopy) const |
| { |
| if(nLevelCount != rCopy.nLevelCount || |
| nFeatureFlags != rCopy.nFeatureFlags || |
| bContinuousNumbering != rCopy.bContinuousNumbering || |
| eNumberingType != rCopy.eNumberingType) |
| return sal_False; |
| for(sal_uInt16 i = 0; i < nLevelCount; i++) |
| { |
| if ( |
| (aFmtsSet[i] != rCopy.aFmtsSet[i]) || |
| (!aFmts[i] && rCopy.aFmts[i]) || |
| (aFmts[i] && !rCopy.aFmts[i]) || |
| (aFmts[i] && *aFmts[i] != *rCopy.aFmts[i]) |
| ) |
| { |
| return sal_False; |
| } |
| } |
| return sal_True; |
| } |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| const SvxNumberFormat* SvxNumRule::Get(sal_uInt16 nLevel)const |
| { |
| DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" ); |
| if( nLevel < SVX_MAX_NUM ) |
| return aFmtsSet[nLevel] ? aFmts[nLevel] : 0; |
| else |
| return 0; |
| } |
| /* -----------------02.11.98 09:10------------------- |
| * |
| * --------------------------------------------------*/ |
| const SvxNumberFormat& SvxNumRule::GetLevel(sal_uInt16 nLevel)const |
| { |
| if(!pStdNumFmt) |
| { |
| pStdNumFmt = new SvxNumberFormat(SVX_NUM_ARABIC); |
| pStdOutlineNumFmt = new SvxNumberFormat(SVX_NUM_NUMBER_NONE); |
| } |
| |
| DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" ); |
| |
| return ( ( nLevel < SVX_MAX_NUM ) && aFmts[nLevel] ) ? |
| *aFmts[nLevel] : eNumberingType == SVX_RULETYPE_NUMBERING ? |
| *pStdNumFmt : *pStdOutlineNumFmt; |
| } |
| |
| /* -----------------29.10.98 09:08------------------- |
| * |
| * --------------------------------------------------*/ |
| void SvxNumRule::SetLevel( sal_uInt16 i, const SvxNumberFormat& rNumFmt, sal_Bool bIsValid ) |
| { |
| DBG_ASSERT(i < SVX_MAX_NUM, "falsches Level" ); |
| |
| if( (i < SVX_MAX_NUM) && (!aFmtsSet[i] || !(rNumFmt == *Get( i ))) ) |
| { |
| delete aFmts[ i ]; |
| aFmts[ i ] = new SvxNumberFormat( rNumFmt ); |
| aFmtsSet[i] = bIsValid; |
| // bInvalidRuleFlag = sal_True; |
| } |
| } |
| /* -----------------30.10.98 12:44------------------- |
| * |
| * --------------------------------------------------*/ |
| void SvxNumRule::SetLevel(sal_uInt16 nLevel, const SvxNumberFormat* pFmt) |
| { |
| DBG_ASSERT(nLevel < SVX_MAX_NUM, "falsches Level" ); |
| |
| if( nLevel < SVX_MAX_NUM ) |
| { |
| aFmtsSet[nLevel] = 0 != pFmt; |
| if(pFmt) |
| SetLevel(nLevel, *pFmt); |
| else |
| { |
| delete aFmts[nLevel]; |
| aFmts[nLevel] = 0; |
| } |
| } |
| } |
| /* -----------------28.10.98 15:38------------------- |
| * |
| * --------------------------------------------------*/ |
| String SvxNumRule::MakeNumString( const SvxNodeNum& rNum, sal_Bool bInclStrings ) const |
| { |
| String aStr; |
| if( SVX_NO_NUM > rNum.GetLevel() && !( SVX_NO_NUMLEVEL & rNum.GetLevel() ) ) |
| { |
| const SvxNumberFormat& rMyNFmt = GetLevel( rNum.GetLevel() ); |
| if( SVX_NUM_NUMBER_NONE != rMyNFmt.GetNumberingType() ) |
| { |
| sal_uInt8 i = rNum.GetLevel(); |
| |
| if( !IsContinuousNumbering() && |
| 1 < rMyNFmt.GetIncludeUpperLevels() ) // nur der eigene Level ? |
| { |
| sal_uInt8 n = rMyNFmt.GetIncludeUpperLevels(); |
| if( 1 < n ) |
| { |
| if( i+1 >= n ) |
| i -= n - 1; |
| else |
| i = 0; |
| } |
| } |
| |
| for( ; i <= rNum.GetLevel(); ++i ) |
| { |
| const SvxNumberFormat& rNFmt = GetLevel( i ); |
| if( SVX_NUM_NUMBER_NONE == rNFmt.GetNumberingType() ) |
| { |
| // Soll aus 1.1.1 --> 2. NoNum --> 1..1 oder 1.1 ?? |
| // if( i != rNum.nMyLevel ) |
| // aStr += aDotStr; |
| continue; |
| } |
| |
| sal_Bool bDot = sal_True; |
| if( rNum.GetLevelVal()[ i ] ) |
| { |
| if(SVX_NUM_BITMAP != rNFmt.GetNumberingType()) |
| aStr += rNFmt.GetNumStr( rNum.GetLevelVal()[ i ], aLocale ); |
| else |
| bDot = sal_False; |
| } |
| else |
| aStr += sal_Unicode('0'); // alle 0-Level sind eine 0 |
| if( i != rNum.GetLevel() && bDot) |
| aStr += sal_Unicode('.'); |
| } |
| } |
| |
| if( bInclStrings ) |
| { |
| aStr.Insert( rMyNFmt.GetPrefix(), 0 ); |
| aStr += rMyNFmt.GetSuffix(); |
| } |
| } |
| return aStr; |
| } |
| /* -----------------18.08.99 10:18------------------- |
| Description: changes linked to embedded bitmaps |
| --------------------------------------------------*/ |
| sal_Bool SvxNumRule::UnLinkGraphics() |
| { |
| sal_Bool bRet = sal_False; |
| for(sal_uInt16 i = 0; i < GetLevelCount(); i++) |
| { |
| SvxNumberFormat aFmt(GetLevel(i)); |
| const SvxBrushItem* pBrush = aFmt.GetBrush(); |
| const String* pLinkStr; |
| const Graphic* pGraphic; |
| if(SVX_NUM_BITMAP == aFmt.GetNumberingType()) |
| { |
| if(pBrush && |
| 0 != (pLinkStr = pBrush->GetGraphicLink()) && |
| pLinkStr->Len() && |
| 0 !=(pGraphic = pBrush->GetGraphic())) |
| { |
| SvxBrushItem aTempItem(*pBrush); |
| aTempItem.SetGraphicLink( String()); |
| aTempItem.SetGraphic(*pGraphic); |
| sal_Int16 eOrient = aFmt.GetVertOrient(); |
| aFmt.SetGraphicBrush( &aTempItem, &aFmt.GetGraphicSize(), &eOrient ); |
| bRet = sal_True; |
| } |
| } |
| else if((SVX_NUM_BITMAP|LINK_TOKEN) == aFmt.GetNumberingType()) |
| aFmt.SetNumberingType(SVX_NUM_BITMAP); |
| SetLevel(i, aFmt); |
| } |
| return bRet; |
| } |
| |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule) : |
| SfxPoolItem(SID_ATTR_NUMBERING_RULE), |
| pNumRule(new SvxNumRule(rRule)) |
| { |
| } |
| |
| /*-----------------23.11.98 10:36------------------- |
| MT: Das sind ja sehr sinnige Kommentare... |
| --------------------------------------------------*/ |
| SvxNumBulletItem::SvxNumBulletItem(SvxNumRule& rRule, sal_uInt16 _nWhich ) : |
| SfxPoolItem(_nWhich), |
| pNumRule(new SvxNumRule(rRule)) |
| { |
| } |
| |
| SfxPoolItem* SvxNumBulletItem::Create(SvStream &s, sal_uInt16 n) const |
| { |
| return SfxPoolItem::Create(s, n ); |
| } |
| |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumBulletItem::SvxNumBulletItem(const SvxNumBulletItem& rCopy) : |
| SfxPoolItem(rCopy.Which()) |
| { |
| pNumRule = new SvxNumRule(*rCopy.pNumRule); |
| } |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumBulletItem::~SvxNumBulletItem() |
| { |
| delete pNumRule; |
| } |
| |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| int SvxNumBulletItem::operator==( const SfxPoolItem& rCopy) const |
| { |
| return *pNumRule == *((SvxNumBulletItem&)rCopy).pNumRule; |
| } |
| /* -----------------27.10.98 10:41------------------- |
| * |
| * --------------------------------------------------*/ |
| SfxPoolItem* SvxNumBulletItem::Clone( SfxItemPool * ) const |
| { |
| return new SvxNumBulletItem(*this); |
| } |
| /* -----------------08.12.98 10:43------------------- |
| * |
| * --------------------------------------------------*/ |
| sal_uInt16 SvxNumBulletItem::GetVersion( sal_uInt16 /*nFileVersion*/ ) const |
| { |
| return NUMITEM_VERSION_03; |
| } |
| /* -----------------08.12.98 10:43------------------- |
| * |
| * --------------------------------------------------*/ |
| SvStream& SvxNumBulletItem::Store(SvStream &rStream, sal_uInt16 /*nItemVersion*/ )const |
| { |
| pNumRule->Store(rStream); |
| return rStream; |
| } |
| |
| /* -----------------08.12.98 10:43------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| sal_Bool SvxNumBulletItem::QueryValue( com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const |
| { |
| rVal <<= SvxCreateNumRule( pNumRule ); |
| return sal_True; |
| } |
| |
| sal_Bool SvxNumBulletItem::PutValue( const com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) |
| { |
| uno::Reference< container::XIndexReplace > xRule; |
| if( rVal >>= xRule ) |
| { |
| try |
| { |
| SvxNumRule* pNewRule = new SvxNumRule( SvxGetNumRule( xRule ) ); |
| if( pNewRule->GetLevelCount() != pNumRule->GetLevelCount() || |
| pNewRule->GetNumRuleType() != pNumRule->GetNumRuleType() ) |
| { |
| SvxNumRule* pConverted = SvxConvertNumRule( pNewRule, pNumRule->GetLevelCount(), pNumRule->GetNumRuleType() ); |
| delete pNewRule; |
| pNewRule = pConverted; |
| } |
| delete pNumRule; |
| pNumRule = pNewRule; |
| return sal_True; |
| } |
| catch(lang::IllegalArgumentException&) |
| { |
| } |
| } |
| return sal_False; |
| } |
| |
| /* -----------------08.12.98 10:43------------------- |
| * |
| * --------------------------------------------------*/ |
| SvxNumRule* SvxConvertNumRule( const SvxNumRule* pRule, sal_uInt16 nLevels, SvxNumRuleType eType ) |
| { |
| const sal_uInt16 nSrcLevels = pRule->GetLevelCount(); |
| SvxNumRule* pNewRule = new SvxNumRule( pRule->GetFeatureFlags(), nLevels, pRule->IsContinuousNumbering(), eType ); |
| |
| for( sal_uInt16 nLevel = 0; (nLevel < nLevels) && (nLevel < nSrcLevels); nLevel++ ) |
| pNewRule->SetLevel( nLevel, pRule->GetLevel( nLevel ) ); |
| |
| return pNewRule; |
| } |