mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
02255839a51a09caf853c1e6495f01c0e528d4f0
libreoffice/sw/source/core/doc/number.cxx

1019 lines
30 KiB
C++
Raw Normal View History

initial import
2000-09-18 23:08:29 +00:00
/*************************************************************************
*
* $RCSfile: number.cxx,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: hr $ $Date: 2000-09-19 00:08:16 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifdef PRECOMPILED
#include "core_pch.hxx"
#endif
#pragma hdrstop
#ifndef _HINTIDS_HXX
#include <hintids.hxx>
#endif
#include <string.h>
#ifndef _SV_FONT_HXX //autogen
#include <vcl/font.hxx>
#endif
#ifndef _SVX_BRSHITEM_HXX //autogen
#include <svx/brshitem.hxx>
#endif
#ifndef _SVX_LRSPITEM_HXX //autogen
#include <svx/lrspitem.hxx>
#endif
#ifndef _SVX_NUMITEM_HXX //autogen
#include <svx/numitem.hxx>
#endif
#ifndef _FMTORNT_HXX //autogen
#include <fmtornt.hxx>
#endif
#ifndef _DOC_HXX
#include <doc.hxx>
#endif
#ifndef _PAM_HXX
#include <pam.hxx>
#endif
#ifndef _CHARFMT_HXX
#include <charfmt.hxx>
#endif
#ifndef _PARATR_HXX
#include <paratr.hxx>
#endif
#ifndef _FRMFMT_HXX
#include <frmfmt.hxx>
#endif
#ifndef _NDTXT_HXX
#include <ndtxt.hxx>
#endif
#ifndef _HINTS_HXX
#include <hints.hxx>
#endif
#ifndef _NUMRULE_HXX
#include <numrule.hxx>
#endif
#ifndef _DOCARY_HXX
#include <docary.hxx>
#endif
#ifndef _DOCSH_HXX
#include <docsh.hxx>
#endif
USHORT SwNumRule::nRefCount = 0;
SwNumFmt* SwNumRule::aBaseFmts[ RULE_END ][ MAXLEVEL ] = {
0, 0, 0, 0, 0,
0, 0, 0, 0, 0 };
Font* SwNumRule::pDefBulletFont = 0;
sal_Char* SwNumRule::pDefOutlineName = "Outline";
USHORT SwNumRule::aDefNumIndents[ 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
};
#if defined UNX
#if defined GCC
extern const sal_Char __FAR_DATA sBulletFntName[];
const sal_Char __FAR_DATA sBulletFntName[] = "starbats";
#else
extern const sal_Char __FAR_DATA sBulletFntName[] = "starbats";
#endif
#else
extern const sal_Char __FAR_DATA sBulletFntName[] = "StarBats";
#endif
// Methoden fuer die Klassen aus NUMRULE.HXX
SwNumFmt::SwNumFmt()
: SwClient( 0 ),
pBulletFont( 0 ),
cBullet( cBulletChar ),
eNumAdjust( SVX_ADJUST_LEFT ),
nLSpace( 0 ),
nAbsLSpace( 0 ),
nFirstLineOffset( 0 ),
nCharTextOffset( 0 ),
nStart( 0 ),
pGrfBrush( 0 ), pVertOrient( 0 )
{
nInclUpperLevel = MAXLEVEL;
bRelLSpace = FALSE;
}
SwNumFmt::SwNumFmt( const SwNumFmt& rNumFmt )
: SwClient( rNumFmt.pRegisteredIn ), SwNumType( rNumFmt ),
cBullet( rNumFmt.cBullet ),
pBulletFont( 0 ),
eNumAdjust( rNumFmt.eNumAdjust ),
nLSpace( rNumFmt.nLSpace ),
nAbsLSpace( rNumFmt.nAbsLSpace ),
nFirstLineOffset( rNumFmt.nFirstLineOffset ),
nCharTextOffset( rNumFmt.nCharTextOffset ),
nStart( rNumFmt.nStart ),
aPrefix( rNumFmt.aPrefix ),
aPostfix( rNumFmt.aPostfix ),
pGrfBrush( 0 ), pVertOrient( 0 )
{
SetBulletFont(rNumFmt.GetBulletFont());
nInclUpperLevel = rNumFmt.nInclUpperLevel;
bRelLSpace = rNumFmt.bRelLSpace;
SetGrfBrush( rNumFmt.GetGrfBrush(), &rNumFmt.GetGrfSize(),
rNumFmt.GetGrfOrient() );
}
SwNumFmt::~SwNumFmt()
{
delete pBulletFont;
delete pGrfBrush;
delete pVertOrient;
}
void SwNumFmt::SetBulletFont(const Font* pFont)
{
if( pBulletFont )
{
if( pFont )
*pBulletFont = *pFont;
else
delete pBulletFont, pBulletFont = 0;
}
else if( pFont )
pBulletFont = new Font( *pFont );
}
void SwNumFmt::SetGrfBrush( const SvxBrushItem* pGrfBr, const Size* pSz,
const SwFmtVertOrient* pVOrient )
{
if( pGrfBr )
{
if( pGrfBrush )
{
if( !( *pGrfBrush == *pGrfBr ) )
{
delete pGrfBrush;
pGrfBrush = (SvxBrushItem*)pGrfBr->Clone();
}
}
else
pGrfBrush = (SvxBrushItem*)pGrfBr->Clone();
if( pVertOrient != pVOrient )
{
if(pVertOrient)
delete pVertOrient;
pVertOrient = pVOrient ? (SwFmtVertOrient*)pVOrient->Clone() : 0;
}
if( pSz )
aGrfSize = *pSz;
else
aGrfSize.Width() = aGrfSize.Height() = 0;
pGrfBrush->SetDoneLink( STATIC_LINK( this, SwNumFmt, GraphicArrived) );
}
else
{
delete pGrfBrush, pGrfBrush = 0;
delete pVertOrient, pVertOrient = 0;
aGrfSize.Width() = aGrfSize.Height() = 0;
}
}
SwNumFmt& SwNumFmt::operator=( const SwNumFmt& rNumFmt )
{
cBullet = rNumFmt.cBullet;
eType = rNumFmt.eType;
nInclUpperLevel = rNumFmt.nInclUpperLevel;
bRelLSpace = rNumFmt.bRelLSpace;
eNumAdjust = rNumFmt.eNumAdjust;
nLSpace = rNumFmt.nLSpace;
nAbsLSpace = rNumFmt.nAbsLSpace;
nFirstLineOffset = rNumFmt.nFirstLineOffset;
nCharTextOffset = rNumFmt.nCharTextOffset;
nStart = rNumFmt.nStart;
aPrefix = rNumFmt.aPrefix;
aPostfix = rNumFmt.aPostfix;
SetBulletFont(rNumFmt.GetBulletFont());
if( rNumFmt.GetRegisteredIn() )
rNumFmt.pRegisteredIn->Add( this );
else if( GetRegisteredIn() )
pRegisteredIn->Remove( this );
SetGrfBrush( rNumFmt.GetGrfBrush(), &rNumFmt.GetGrfSize(),
rNumFmt.GetGrfOrient() );
return *this;
}
BOOL SwNumFmt::operator==( const SwNumFmt& rNumFmt ) const
{
BOOL bRet = (
eType == rNumFmt.eType &&
nInclUpperLevel == rNumFmt.nInclUpperLevel &&
bRelLSpace == rNumFmt.bRelLSpace &&
eNumAdjust == rNumFmt.eNumAdjust &&
nLSpace == rNumFmt.nLSpace &&
nAbsLSpace == rNumFmt.nAbsLSpace &&
nFirstLineOffset == rNumFmt.nFirstLineOffset &&
nCharTextOffset == rNumFmt.nCharTextOffset &&
nStart == rNumFmt.nStart &&
aPrefix == rNumFmt.aPrefix &&
aPostfix == rNumFmt.aPostfix &&
pRegisteredIn == rNumFmt.pRegisteredIn);
if( bRet )
{
switch( eType )
{
case SVX_NUM_CHAR_SPECIAL:
if( cBullet != rNumFmt.cBullet ||
( pBulletFont
? ( !rNumFmt.GetBulletFont() ||
*pBulletFont != *rNumFmt.GetBulletFont() )
: 0 != rNumFmt.GetBulletFont() ) )
bRet = FALSE;
break;
case SVX_NUM_BITMAP:
if( aGrfSize != rNumFmt.aGrfSize ||
( pGrfBrush
? ( !rNumFmt.pGrfBrush ||
*pGrfBrush != *rNumFmt.pGrfBrush )
: 0 != rNumFmt.pGrfBrush ) ||
( pVertOrient
? ( !rNumFmt.pVertOrient ||
*pVertOrient != *rNumFmt.pVertOrient )
: 0 != rNumFmt.pVertOrient ) )
bRet = FALSE;
break;
}
}
return bRet;
}
void SwNumFmt::SetCharFmt( SwCharFmt* pChFmt )
{
if( pChFmt )
pChFmt->Add( this );
else if( GetRegisteredIn() )
pRegisteredIn->Remove( this );
}
void SwNumFmt::Modify( SfxPoolItem* pOld, SfxPoolItem* pNew )
{
// dann suche mal in dem Doc nach dem NumRules-Object, in dem dieses
// NumFormat gesetzt ist. Das Format muss es nicht geben!
const SwCharFmt* pFmt = 0;
switch( pOld ? pOld->Which() : pNew ? pNew->Which() : 0 )
{
case RES_ATTRSET_CHG:
case RES_FMT_CHG:
pFmt = GetCharFmt();
break;
}
if( pFmt && !pFmt->GetDoc()->IsInDtor() )
UpdateNumNodes( (SwDoc*)pFmt->GetDoc() );
else
SwClient::Modify( pOld, pNew );
}
void SwNumFmt::SetGraphic( const String& rName )
{
if( pGrfBrush && *pGrfBrush->GetGraphicLink() == rName )
return ;
delete pGrfBrush;
pGrfBrush = new SvxBrushItem( rName, aEmptyStr, GPOS_AREA );
pGrfBrush->SetDoneLink( STATIC_LINK( this, SwNumFmt, GraphicArrived) );
if( !pVertOrient )
pVertOrient = new SwFmtVertOrient( 0, VERT_TOP );
aGrfSize.Width() = aGrfSize.Height() = 0;
}
IMPL_STATIC_LINK( SwNumFmt, GraphicArrived, void *, EMPTYARG )
{
// ggfs. die GrfSize setzen:
if( !pThis->aGrfSize.Width() || !pThis->aGrfSize.Height() )
{
const Graphic* pGrf = pThis->pGrfBrush->GetGraphic();
if( pGrf )
pThis->aGrfSize = ::GetGraphicSizeTwip( *pGrf, 0 );
}
if( pThis->GetCharFmt() )
pThis->UpdateNumNodes( (SwDoc*)pThis->GetCharFmt()->GetDoc() );
return 0;
}
inline void lcl_SetRuleChgd( SwTxtNode& rNd, BYTE nLevel )
{
if( rNd.GetNum() &&
(~NO_NUMLEVEL & rNd.GetNum()->GetLevel() ) == nLevel )
rNd.NumRuleChgd();
}
void SwNumFmt::UpdateNumNodes( SwDoc* pDoc )
{
BOOL bDocIsModified = pDoc->IsModified();
BOOL bFnd = FALSE;
const SwNumRule* pRule;
for( USHORT n = pDoc->GetNumRuleTbl().Count(); !bFnd && n; )
{
pRule = pDoc->GetNumRuleTbl()[ --n ];
for( BYTE i = 0; i < MAXLEVEL; ++i )
if( pRule->GetNumFmt( i ) == this )
{
const String& rRuleNm = pRule->GetName();
SwModify* pMod;
const SfxPoolItem* pItem;
USHORT k, nMaxItems = pDoc->GetAttrPool().GetItemCount(
RES_PARATR_NUMRULE );
for( k = 0; k < nMaxItems; ++k )
if( 0 != (pItem = pDoc->GetAttrPool().GetItem(
RES_PARATR_NUMRULE, k ) ) &&
0 != ( pMod = (SwModify*)((SwNumRuleItem*)pItem)->
GetDefinedIn()) &&
((SwNumRuleItem*)pItem)->GetValue() == rRuleNm )
{
if( pMod->IsA( TYPE( SwFmt )) )
{
SwNumRuleInfo aInfo( rRuleNm );
pMod->GetInfo( aInfo );
for( ULONG nFirst = 0, nLast = aInfo.GetList().Count();
nFirst < nLast; ++nFirst )
lcl_SetRuleChgd(
*aInfo.GetList().GetObject( nFirst ), i );
}
else if( ((SwTxtNode*)pMod)->GetNodes().IsDocNodes() )
lcl_SetRuleChgd( *(SwTxtNode*)pMod, i );
}
bFnd = TRUE;
break;
}
}
if( !bFnd )
{
pRule = pDoc->GetOutlineNumRule();
for( BYTE i = 0; i < MAXLEVEL; ++i )
if( pRule->GetNumFmt( i ) == this )
{
ULONG nStt = pDoc->GetNodes().GetEndOfContent().StartOfSectionIndex();
const SwTxtFmtColls& rColls = *pDoc->GetTxtFmtColls();
for( USHORT n = 1; n < rColls.Count(); ++n )
{
const SwTxtFmtColl* pColl = rColls[ n ];
if( i == pColl->GetOutlineLevel() )
{
SwClientIter aIter( *(SwTxtFmtColl*)pColl );
for( SwTxtNode* pNd = (SwTxtNode*)aIter.First( TYPE( SwTxtNode ));
pNd; pNd = (SwTxtNode*)aIter.Next() )
if( pNd->GetNodes().IsDocNodes() &&
nStt < pNd->GetIndex() &&
pNd->GetOutlineNum() && i == (~NO_NUMLEVEL &
pNd->GetOutlineNum()->GetLevel() ) )
pNd->NumRuleChgd();
break;
}
}
bFnd = TRUE;
break;
}
}
if( bFnd && !bDocIsModified )
pDoc->ResetModified();
}
// Graphic ggfs. reinswappen
const Graphic* SwNumFmt::GetGraphic() const
{
const Graphic* pGrf = 0;
if( pGrfBrush && GetCharFmt() )
pGrf = pGrfBrush->GetGraphic( GetCharFmt()->GetDoc()->GetDocShell() );
return pGrf;
}
/* */
void SwNumType::GetRomanStr( ULONG nNo, String& rStr ) const
{
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 sal_Char *cRomanArr = SVX_NUM_ROMAN_UPPER == eType
? "MDCLXVI--" // +2 Dummy-Eintraege !!
: "mdclxvi--"; // +2 Dummy-Eintraege !!
USHORT nMask = 1000;
while( nMask )
{
BYTE nZahl = BYTE(nNo / nMask);
BYTE nDiff = 1;
nNo %= nMask;
if( 5 < nZahl )
{
if( nZahl < 9 )
rStr += *(cRomanArr-1);
++nDiff;
nZahl -= 5;
}
switch( nZahl )
{
case 3: { rStr += *cRomanArr; }
case 2: { rStr += *cRomanArr; }
case 1: { rStr += *cRomanArr; }
break;
case 4: {
rStr += *cRomanArr;
rStr += *(cRomanArr-nDiff);
}
break;
case 5: { rStr += *(cRomanArr-nDiff); }
break;
}
nMask /= 10; // zur naechsten Dekade
cRomanArr += 2;
}
}
void SwNumType::GetCharStr( ULONG nNo, String& rStr ) const
{
ASSERT( nNo, "0 ist eine ungueltige Nummer !!" );
const ULONG coDiff = 'Z' - 'A' +1;
char cAdd = (SVX_NUM_CHARS_UPPER_LETTER == eType ? 'A' : 'a') - 1;
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 SwNumType::GetCharStrN( ULONG nNo, String& rStr ) const
{
ASSERT( nNo, "0 ist eine ungueltige Nummer !!" );
const ULONG coDiff = 'Z' - 'A' +1;
sal_Unicode cChar = --nNo % coDiff;
if( SVX_NUM_CHARS_UPPER_LETTER_N == eType )
cChar += 'A';
else
cChar += 'a';
rStr.Fill( (nNo / coDiff) + 1, cChar );
}
String SwNumType::GetNumStr( ULONG nNo ) const
{
String aTmpStr;
if( nNo )
{
switch( eType )
{
case SVX_NUM_CHARS_UPPER_LETTER:
case SVX_NUM_CHARS_LOWER_LETTER:
GetCharStr( nNo, aTmpStr );
break;
case SVX_NUM_CHARS_UPPER_LETTER_N:
case SVX_NUM_CHARS_LOWER_LETTER_N:
GetCharStrN( nNo, aTmpStr );
break;
case SVX_NUM_ROMAN_UPPER:
case SVX_NUM_ROMAN_LOWER:
GetRomanStr( nNo, aTmpStr );
break;
case SVX_NUM_CHAR_SPECIAL: //JP 06.12.99: this types dont have
case SVX_NUM_BITMAP: // any number, so return emptystr
case SVX_NUM_NUMBER_NONE: // Bug: 70527
break;
// case ARABIC: ist jetzt default
default:
aTmpStr = String::CreateFromInt32( nNo );
break;
}
}
else
aTmpStr = '0';
return aTmpStr;
}
/* */
BOOL SwNodeNum::operator==( const SwNodeNum& rNum ) const
{
return nMyLevel == rNum.nMyLevel &&
nSetValue == rNum.nSetValue &&
bStartNum == rNum.bStartNum &&
( nMyLevel >= MAXLEVEL ||
0 == memcmp( nLevelVal, rNum.nLevelVal,
sizeof( USHORT ) * (nMyLevel+1) ));
}
SwNumRule::SwNumRule( const String& rNm, SwNumRuleType eType, BOOL bAutoFlg )
: eRuleType( eType ),
sName( rNm ),
bAutoRuleFlag( bAutoFlg ),
bInvalidRuleFlag( TRUE ),
bContinusNum( FALSE ),
bAbsSpaces( FALSE ),
nPoolFmtId( USHRT_MAX ),
nPoolHelpId( USHRT_MAX ),
nPoolHlpFileId( UCHAR_MAX )
{
if( !nRefCount++ ) // zum erstmal, also initialisiern
{
SwNumFmt* pFmt;
// Nummerierung:
for( int n = 0; n < MAXLEVEL; ++n )
{
pFmt = new SwNumFmt;
pFmt->SetUpperLevel( 1 );
// pFmt->SetRelLSpace( TRUE );
pFmt->SetRelLSpace( FALSE );
pFmt->SetStartValue( 1 );
pFmt->SetLSpace( lNumIndent );
pFmt->SetAbsLSpace( SwNumRule::GetNumIndent( n ) );
pFmt->SetFirstLineOffset( lNumFirstLineOffset );
pFmt->SetPostfix( aDotStr );
SwNumRule::aBaseFmts[ NUM_RULE ][ n ] = pFmt;
}
// Gliederung:
for( n = 0; n < MAXLEVEL; ++n )
{
pFmt = new SwNumFmt;
//JP 18.01.96: heute soll es mal wieder vollstaendig numeriert werden
//JP 10.03.96: und nun mal wieder nicht
pFmt->eType = SVX_NUM_NUMBER_NONE;
// pFmt->eType = ARABIC;
pFmt->SetStartValue( 1 );
SwNumRule::aBaseFmts[ OUTLINE_RULE ][ n ] = pFmt;
}
}
memset( aFmts, 0, sizeof( aFmts ));
ASSERT( sName.Len(), "NumRule ohne Namen!" );
}
SwNumRule::SwNumRule( const SwNumRule& rNumRule )
: eRuleType( rNumRule.eRuleType ),
sName( rNumRule.sName ),
bAutoRuleFlag( rNumRule.bAutoRuleFlag ),
bInvalidRuleFlag( TRUE ),
bContinusNum( rNumRule.bContinusNum ),
bAbsSpaces( rNumRule.bAbsSpaces ),
nPoolFmtId( rNumRule.GetPoolFmtId() ),
nPoolHelpId( rNumRule.GetPoolHelpId() ),
nPoolHlpFileId( rNumRule.GetPoolHlpFileId() )
{
++nRefCount;
memset( aFmts, 0, sizeof( aFmts ));
for( USHORT n = 0; n < MAXLEVEL; ++n )
if( rNumRule.aFmts[ n ] )
Set( n, *rNumRule.aFmts[ n ] );
}
SwNumRule::~SwNumRule()
{
for( USHORT n = 0; n < MAXLEVEL; ++n )
delete aFmts[ n ];
if( !--nRefCount ) // der letzte macht die Tuer zu
{
// Nummerierung:
SwNumFmt** ppFmts = (SwNumFmt**)SwNumRule::aBaseFmts;
for( int n = 0; n < MAXLEVEL; ++n, ++ppFmts )
delete *ppFmts, *ppFmts = 0;
// Gliederung:
for( n = 0; n < MAXLEVEL; ++n, ++ppFmts )
delete *ppFmts, *ppFmts = 0;
}
}
void SwNumRule::_MakeDefBulletFont()
{
pDefBulletFont = new Font( String::CreateFromAscii( sBulletFntName ),
aEmptyStr, Size( 0, 14 ) );
pDefBulletFont->SetCharSet( RTL_TEXTENCODING_SYMBOL );
pDefBulletFont->SetFamily( FAMILY_DONTKNOW );
pDefBulletFont->SetPitch( PITCH_DONTKNOW );
pDefBulletFont->SetWeight( WEIGHT_DONTKNOW );
pDefBulletFont->SetTransparent( TRUE );
}
void SwNumRule::CheckCharFmts( SwDoc* pDoc )
{
SwCharFmt* pFmt;
for( BYTE n = 0; n < MAXLEVEL; ++n )
if( aFmts[ n ] && 0 != ( pFmt = aFmts[ n ]->GetCharFmt() ) &&
pFmt->GetDoc() != pDoc )
{
// dann kopieren!
SwNumFmt* pNew = new SwNumFmt( *aFmts[ n ] );
pNew->SetCharFmt( pDoc->CopyCharFmt( *pFmt ) );
delete aFmts[ n ];
aFmts[ n ] = pNew;
}
}
// setzt Num oder NoNum fuer den Level am TextNode UND setzt die
// richtige Attributierung
BOOL SwNumRule::IsRuleLSpace( SwTxtNode& rNd ) const
{
const SfxPoolItem* pItem;
BYTE nLvl;
const SwAttrSet* pASet = rNd.GetpSwAttrSet();
BOOL bRet = rNd.GetNum() && pASet && SFX_ITEM_SET == pASet->GetItemState(
RES_LR_SPACE, FALSE, &pItem ) && ( nLvl = (~NO_NUMLEVEL &
rNd.GetNum()->GetLevel() )) < MAXLEVEL &&
Get( nLvl ).GetAbsLSpace() == ((SvxLRSpaceItem*)pItem)->GetTxtLeft();
return bRet;
}
SwNumRule& SwNumRule::operator=( const SwNumRule& rNumRule )
{
if( this != &rNumRule )
{
for( USHORT n = 0; n < MAXLEVEL; ++n )
Set( n, rNumRule.aFmts[ n ] );
eRuleType = rNumRule.eRuleType;
sName = rNumRule.sName;
bAutoRuleFlag = rNumRule.bAutoRuleFlag;
bInvalidRuleFlag = TRUE;
bContinusNum = rNumRule.bContinusNum;
bAbsSpaces = rNumRule.bAbsSpaces;
nPoolFmtId = rNumRule.GetPoolFmtId();
nPoolHelpId = rNumRule.GetPoolHelpId();
nPoolHlpFileId = rNumRule.GetPoolHlpFileId();
}
return *this;
}
BOOL SwNumRule::operator==( const SwNumRule& rRule ) const
{
BOOL bRet = eRuleType == rRule.eRuleType &&
sName == rRule.sName &&
bAutoRuleFlag == rRule.bAutoRuleFlag &&
bContinusNum == rRule.bContinusNum &&
bAbsSpaces == rRule.bAbsSpaces &&
nPoolFmtId == rRule.GetPoolFmtId() &&
nPoolHelpId == rRule.GetPoolHelpId() &&
nPoolHlpFileId == rRule.GetPoolHlpFileId();
if( bRet )
{
for( BYTE n = 0; n < MAXLEVEL; ++n )
if( !( rRule.Get( n ) == Get( n ) ))
{
bRet = FALSE;
break;
}
}
return bRet;
}
void SwNumRule::Set( USHORT i, const SwNumFmt& rNumFmt )
{
if( !aFmts[ i ] || !(rNumFmt == Get( i )) )
{
delete aFmts[ i ];
aFmts[ i ] = new SwNumFmt( rNumFmt );
bInvalidRuleFlag = TRUE;
}
}
void SwNumRule::Set( USHORT i, const SwNumFmt* pNumFmt )
{
SwNumFmt* pOld = aFmts[ i ];
if( !pOld )
{
if( pNumFmt )
{
aFmts[ i ] = new SwNumFmt( *pNumFmt );
bInvalidRuleFlag = TRUE;
}
}
else if( !pNumFmt )
delete pOld, aFmts[ i ] = 0, bInvalidRuleFlag = TRUE;
else if( *pOld != *pNumFmt )
*pOld = *pNumFmt, bInvalidRuleFlag = TRUE;
}
String SwNumRule::MakeNumString( const SwNodeNum& rNum, BOOL bInclStrings,
BOOL bOnlyArabic ) const
{
String aStr;
if( NO_NUM > rNum.GetLevel() && !( NO_NUMLEVEL & rNum.GetLevel() ) )
{
const SwNumFmt& rMyNFmt = Get( rNum.GetLevel() );
if( SVX_NUM_NUMBER_NONE != rMyNFmt.eType )
{
BYTE i = rNum.GetLevel();
if( !IsContinusNum() &&
rMyNFmt.IsInclUpperLevel() ) // nur der eigene Level ?
{
BYTE n = rMyNFmt.GetUpperLevel();
if( 1 < n )
{
if( i+1 >= n )
i -= n - 1;
else
i = 0;
}
}
for( ; i <= rNum.GetLevel(); ++i )
{
const SwNumFmt& rNFmt = Get( i );
if( SVX_NUM_NUMBER_NONE == rNFmt.eType )
{
// Soll aus 1.1.1 --> 2. NoNum --> 1..1 oder 1.1 ??
// if( i != rNum.nMyLevel )
// aStr += aDotStr;
continue;
}
if( rNum.GetLevelVal()[ i ] )
{
if( bOnlyArabic )
aStr += String::CreateFromInt32( rNum.GetLevelVal()[ i ] );
else
aStr += rNFmt.GetNumStr( rNum.GetLevelVal()[ i ] );
}
else
aStr += '0'; // alle 0-Level sind eine 0
if( i != rNum.GetLevel() && aStr.Len() )
aStr += aDotStr;
}
}
//JP 14.12.99: the type dont have any number, so dont append
// the Post-/Prefix String
if( bInclStrings && !bOnlyArabic &&
SVX_NUM_CHAR_SPECIAL != rMyNFmt.eType &&
SVX_NUM_BITMAP != rMyNFmt.eType )
{
aStr.Insert( rMyNFmt.GetPrefix(), 0 );
aStr += rMyNFmt.GetPostfix();
}
}
return aStr;
}
// ----- Copy-Methode vom SwNumRule ------
// eine Art Copy-Constructor, damit die Num-Formate auch an den
// richtigen CharFormaten eines Dokumentes haengen !!
// (Kopiert die NumFormate und returnt sich selbst)
SwNumRule& SwNumRule::CopyNumRule( SwDoc* pDoc, const SwNumRule& rNumRule )
{
for( USHORT n = 0; n < MAXLEVEL; ++n )
{
Set( n, rNumRule.aFmts[ n ] );
if( aFmts[ n ] && aFmts[ n ]->GetCharFmt() &&
USHRT_MAX == pDoc->GetCharFmts()->GetPos( aFmts[n]->GetCharFmt() ))
// ueber unterschiedliche Dokumente kopieren, dann
// kopiere das entsprechende Char-Format ins neue
// Dokument.
aFmts[n]->SetCharFmt( pDoc->CopyCharFmt( *aFmts[n]->
GetCharFmt() ) );
}
eRuleType = rNumRule.eRuleType;
sName = rNumRule.sName;
bAutoRuleFlag = rNumRule.bAutoRuleFlag;
nPoolFmtId = rNumRule.GetPoolFmtId();
nPoolHelpId = rNumRule.GetPoolHelpId();
nPoolHlpFileId = rNumRule.GetPoolHlpFileId();
bInvalidRuleFlag = TRUE;
return *this;
}
/* -----------------30.10.98 08:40-------------------
*
* --------------------------------------------------*/
SwNumFmt::SwNumFmt(const SvxNumberFormat& rNumFmt, SwDoc* pDoc) :
pBulletFont( 0 ),
pGrfBrush( 0 ),
pVertOrient( 0 )
{
cBullet = rNumFmt.GetBulletChar();
eType = rNumFmt.GetNumType();
nInclUpperLevel = rNumFmt.GetIncludeUpperLevels();
bRelLSpace = FALSE;
eNumAdjust = rNumFmt.GetNumAdjust();
nLSpace = rNumFmt.GetLSpace();
nAbsLSpace = rNumFmt.GetAbsLSpace();
nFirstLineOffset = rNumFmt.GetFirstLineOffset();
nCharTextOffset = rNumFmt.GetCharTextDistance();
nStart = rNumFmt.GetStart();
aPrefix = rNumFmt.GetPrefix();
aPostfix = rNumFmt.GetSuffix();
SetBulletFont(rNumFmt.GetBulletFont());
if( rNumFmt.GetCharFmt().Len() )
{
SwCharFmt* pCFmt = pDoc->FindCharFmtByName( rNumFmt.GetCharFmt() );
if( !pCFmt )
{
USHORT nId = pDoc->GetPoolId( rNumFmt.GetCharFmt(),
GET_POOLID_CHRFMT );
pCFmt = nId != USHRT_MAX
? pDoc->GetCharFmtFromPool( nId )
: pDoc->MakeCharFmt( rNumFmt.GetCharFmt(), 0 );
}
pCFmt->Add( this );
}
else if( GetRegisteredIn() )
pRegisteredIn->Remove( this );
SwVertOrient eOrient = (SwVertOrient)(USHORT) rNumFmt.GetVertOrient();
SwFmtVertOrient aOrient(0, eOrient);
Size aTmpSize(rNumFmt.GetGraphicSize());
SetGrfBrush( rNumFmt.GetBrush(), &aTmpSize,
&aOrient );
}
/* -----------------30.10.98 12:36-------------------
*
* --------------------------------------------------*/
SvxNumberFormat SwNumFmt::MakeSvxFormat() const
{
SvxNumberFormat aRet(eType);
aRet.SetNumAdjust(eNumAdjust);
aRet.SetIncludeUpperLevels(nInclUpperLevel);
aRet.SetStart(nStart);
aRet.SetBulletChar(cBullet);
aRet.SetFirstLineOffset(nFirstLineOffset);
aRet.SetAbsLSpace(nAbsLSpace);
aRet.SetLSpace(nLSpace);
aRet.SetPrefix(aPrefix);
aRet.SetSuffix(aPostfix);
if( GetCharFmt() )
aRet.SetCharFmt( GetCharFmt()->GetName() );
aRet.SetCharTextDistance(nCharTextOffset);
SvxFrameVertOrient eOrient = SVX_VERT_NONE;
if(pVertOrient)
eOrient = (SvxFrameVertOrient)(USHORT)pVertOrient->GetVertOrient();
aRet.SetGraphicBrush( pGrfBrush, &aGrfSize, &eOrient);
aRet.SetBulletFont(pBulletFont);
return aRet;
}
/* -----------------30.10.98 08:33-------------------
*
* --------------------------------------------------*/
void SwNumRule::SetSvxRule(const SvxNumRule& rNumRule, SwDoc* pDoc)
{
for( USHORT n = 0; n < MAXLEVEL; ++n )
{
const SvxNumberFormat* pSvxFmt = rNumRule.Get(n);
delete aFmts[n];
aFmts[n] = pSvxFmt ? new SwNumFmt(*pSvxFmt, pDoc) : 0;
}
// eRuleType = rNumRule.eRuleType;
// sName = rNumRule.sName;
// bAutoRuleFlag = rNumRule.bAutoRuleFlag;
bInvalidRuleFlag = TRUE;
bContinusNum = rNumRule.IsContinuousNumbering();
//!!! bAbsSpaces = rNumRule.IsAbsSpaces();
}
/* -----------------30.10.98 08:33-------------------
*
* --------------------------------------------------*/
SvxNumRule SwNumRule::MakeSvxNumRule() const
{
SvxNumRule aRule(NUM_CONTINUOUS|NUM_CHAR_TEXT_DISTANCE|NUM_CHAR_STYLE|
NUM_ENABLE_LINKED_BMP|NUM_ENABLE_EMBEDDED_BMP,
MAXLEVEL,
eRuleType ==
NUM_RULE ?
SVX_RULETYPE_NUMBERING :
SVX_RULETYPE_OUTLINE_NUMBERING );
aRule.SetContinuousNumbering(bContinusNum);
//!!! aRule.SetAbsSpaces( bAbsSpaces );
for( USHORT n = 0; n < MAXLEVEL; ++n )
{
const SwNumFmt rNumFmt = Get(n);
SvxNumberFormat aSvxFormat = rNumFmt.MakeSvxFormat();
aRule.SetLevel(n, aSvxFormat, aFmts[n] != 0);
}
return aRule;
}
Reference in New Issue Copy Permalink