xref: /AOO41X/main/sw/source/core/edit/autofmt.cxx (revision 8ef2f12b1aeba1404ab3c221e6e26281826cc4fc)

/**************************************************************
 *
 * 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"


#define _SVSTDARR_LONGS
#define _SVSTDARR_USHORTS

#include <ctype.h>
#include <hintids.hxx>

#include <svl/svstdarr.hxx>

#include <unotools/charclass.hxx>

#include <vcl/msgbox.hxx>

#include <editeng/boxitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/brkitem.hxx>
#include <editeng/adjitem.hxx>
#include <editeng/tstpitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/cscoitem.hxx>
#include <editeng/unolingu.hxx>
#include <editeng/acorrcfg.hxx>

#include <swwait.hxx>
#include <fmtpdsc.hxx>
#include <fmtanchr.hxx>
#include <doc.hxx>
#include <IDocumentUndoRedo.hxx>
#include <docary.hxx>
#include <editsh.hxx>
#include <index.hxx>
#include <pam.hxx>
#include <edimp.hxx>
#include <fesh.hxx>
#include <swundo.hxx>		// fuer die UndoIds
#include <poolfmt.hxx>
#include <ndtxt.hxx>
#include <txtfrm.hxx>
#include <frminf.hxx>
#include <pagedesc.hxx>
#include <paratr.hxx>
#include <swtable.hxx>
#include <acorrect.hxx>
#include <shellres.hxx>
#include <section.hxx>
#include <frmatr.hxx>
#include <charatr.hxx>
#include <mdiexp.hxx>
#include <statstr.hrc>
#include <comcore.hrc>
#include <numrule.hxx>

using namespace ::com::sun::star;

//-------------------------------------------------------------------

//JP 16.12.99: definition:
//		from pos cPosEnDash to cPosEmDash all chars changed to endashes,
//		from pos cPosEmDash to cPosEnd    all chars changed to emdashes
// 		all other chars are changed to the user configuration

const sal_Unicode pBulletChar[6] = { '+', '*', '-', 0x2013, 0x2014, 0 };
const int cnPosEnDash = 2, cnPosEmDash = 4, cnPosEnd = 5;

const sal_Unicode cStarSymbolEnDash = 0x2013;
const sal_Unicode cStarSymbolEmDash = 0x2014;


SvxSwAutoFmtFlags* SwEditShell::pAutoFmtFlags = 0;

// Anzahl von Num-/Bullet-Absatzvorlagen. MAXLEVEL wird demnaechst auf
// x erhoeht, die Anzahl Vorlagen aber nicht (Ueberbleibsel aus <= 4.0)
const sal_uInt16 cnNumBullColls = 4;

class SwAutoFormat
{
	SvxSwAutoFmtFlags aFlags;
	SwPaM aDelPam;				// ein Pam der benutzt werden kann
	SwNodeIndex aNdIdx;			// der Index auf den akt. TextNode
	SwNodeIndex aEndNdIdx;		// Index auf das Ende vom Bereich

	SwEditShell* pEditShell;
	SwDoc* pDoc;
	SwTxtNode* pAktTxtNd;		// der akt. TextNode
	SwTxtFrm* pAktTxtFrm;		// Frame vom akt. TextNode
	CharClass* pCharClass;		// Character classification
	sal_uLong nEndNdIdx;			// fuer die Prozent-Anzeige
	LanguageType eCharClassLang;

	sal_uInt16 nLastHeadLvl, nLastCalcHeadLvl;
	sal_uInt16 nLastEnumLvl, nLastCalcEnumLvl;
	sal_uInt16 nRedlAutoFmtSeqId;

	enum
	{
		NONE = 0,
		DELIM = 1,
		DIGIT = 2,
		CHG = 4,
		LOWER_ALPHA = 8,
		UPPER_ALPHA = 16,
		LOWER_ROMAN = 32,
		UPPER_ROMAN = 64,
		NO_DELIM = (DIGIT|LOWER_ALPHA|UPPER_ALPHA|LOWER_ROMAN|UPPER_ROMAN)
	};

	enum Format_Status
	{
		READ_NEXT_PARA,
		TST_EMPTY_LINE,
		TST_ALPHA_LINE,
		GET_ALL_INFO,
		IS_ONE_LINE,
		TST_ENUMERIC,
		TST_IDENT,
		TST_NEG_IDENT,
		TST_TXT_BODY,
		HAS_FMTCOLL,
		IS_ENDE
	} eStat;

	sal_Bool bEnde : 1;
	sal_Bool bEmptyLine : 1;
	sal_Bool bMoreLines : 1;

    static sal_Bool  m_bAskForCancelUndoWhileBufferOverflow;
    static short m_nActionWhileAutoformatUndoBufferOverflow;


	// ------------- private methods -----------------------------
	void _GetCharClass( LanguageType eLang );
	CharClass& GetCharClass( LanguageType eLang ) const
	{
		if( !pCharClass || eLang != eCharClassLang )
		{
			SwAutoFormat* pThis = (SwAutoFormat*)this;
			pThis->_GetCharClass( eLang );
		}
		return *pCharClass;
	}


	sal_Bool IsSpace( const sal_Unicode c ) const
		{ return (' ' == c || '\t' == c || 0x0a == c|| 0x3000 == c /* Jap. space */) ? sal_True : sal_False; }

	void SetColl( sal_uInt16 nId, sal_Bool bHdLineOrText = sal_False );
	String GoNextPara();
	sal_Bool HasObjects( const SwNode& rNd );

	// TxtNode Methoden
	const SwTxtNode* GetNextNode() const;
	sal_Bool IsEmptyLine( const SwTxtNode& rNd ) const
		{	return 0 == rNd.GetTxt().Len() ||
				rNd.GetTxt().Len() == GetLeadingBlanks( rNd.GetTxt() ); }

	sal_Bool IsOneLine( const SwTxtNode& ) const;
	sal_Bool IsFastFullLine( const SwTxtNode& ) const;
	sal_Bool IsNoAlphaLine( const SwTxtNode&) const;
	sal_Bool IsEnumericChar( const SwTxtNode&) const;
	sal_Bool IsBlanksInString( const SwTxtNode&) const;
	sal_uInt16 CalcLevel( const SwTxtNode&, sal_uInt16 *pDigitLvl = 0 ) const;
	xub_StrLen GetBigIndent( xub_StrLen& rAktSpacePos ) const;

	String& DelLeadingBlanks( String& rStr ) const;
	String& DelTrailingBlanks( String& rStr ) const;
	xub_StrLen GetLeadingBlanks( const String& rStr ) const;
	xub_StrLen GetTrailingBlanks( const String& rStr ) const;

	sal_Bool IsFirstCharCapital( const SwTxtNode& rNd ) const;
	sal_uInt16 GetDigitLevel( const SwTxtNode& rTxtNd, xub_StrLen& rPos,
							String* pPreFix = 0, String* pPostFix = 0,
							String* pNumTypes = 0 ) const;
		// hole den FORMATIERTEN TextFrame
	SwTxtFrm* GetFrm( const SwTxtNode& rTxtNd ) const;

	void BuildIndent();
	void BuildText();
	void BuildTextIndent();
	void BuildEnum( sal_uInt16 nLvl, sal_uInt16 nDigitLevel );
	void BuildNegIndent( SwTwips nSpaces );
	void BuildHeadLine( sal_uInt16 nLvl );

	sal_Bool HasSelBlanks( SwPaM& rPam ) const;
	sal_Bool HasBreakAttr( const SwTxtNode& ) const;
	void DeleteSel( SwPaM& rPam );
	sal_Bool DeleteAktNxtPara( const String& rNxtPara );
	// loesche im Node Anfang oder/und Ende
	void DeleteAktPara( sal_Bool bStart = sal_True, sal_Bool nEnd = sal_True );
	void DelEmptyLine( sal_Bool bTstNextPara = sal_True );
		// loesche bei mehrzeiligen Absaetzen die "linken" und/oder
		// "rechten" Raender
	void DelMoreLinesBlanks( sal_Bool bWithLineBreaks = sal_False );
		// loesche den vorherigen Absatz
	void DelPrevPara();
		// dann lasse doch mal das AutoCorrect auf den akt. TextNode los
	void AutoCorrect( xub_StrLen nSttPos = 0 );

	sal_Bool CanJoin( const SwTxtNode* pTxtNd ) const
	{
		return !bEnde && pTxtNd &&
			 !IsEmptyLine( *pTxtNd ) &&
			 !IsNoAlphaLine( *pTxtNd) &&
			 !IsEnumericChar( *pTxtNd ) &&
			 ((STRING_MAXLEN - 50 - pTxtNd->GetTxt().Len()) >
					pAktTxtNd->GetTxt().Len()) &&
			 !HasBreakAttr( *pTxtNd );
	}

	// ist ein Punkt am Ende ??
	sal_Bool IsSentenceAtEnd( const SwTxtNode& rTxtNd ) const;

	sal_Bool DoUnderline();
	sal_Bool DoTable();

	void _SetRedlineTxt( sal_uInt16 nId );
	sal_Bool SetRedlineTxt( sal_uInt16 nId )
		{ if( aFlags.bWithRedlining )	_SetRedlineTxt( nId );  return sal_True; }
	sal_Bool ClearRedlineTxt()
		{ if( aFlags.bWithRedlining )	pDoc->SetAutoFmtRedlineComment(0);  return sal_True; }

public:
	SwAutoFormat( SwEditShell* pEdShell, SvxSwAutoFmtFlags& rFlags,
				SwNodeIndex* pSttNd = 0, SwNodeIndex* pEndNd = 0 );
	~SwAutoFormat() {
		delete pCharClass;
	}
};

sal_Bool  SwAutoFormat::m_bAskForCancelUndoWhileBufferOverflow     = sal_True;
short SwAutoFormat::m_nActionWhileAutoformatUndoBufferOverflow = RET_YES;

const sal_Unicode* StrChr( const sal_Unicode* pSrc, sal_Unicode c )
{
	while( *pSrc && *pSrc != c )
		++pSrc;
	return *pSrc ? pSrc : 0;
}

SwTxtFrm* SwAutoFormat::GetFrm( const SwTxtNode& rTxtNd ) const
{
	// besorge mal den Frame
	const SwCntntFrm *pFrm = rTxtNd.getLayoutFrm( pEditShell->GetLayout() );
	ASSERT( pFrm, "zum Autoformat muss das Layout vorhanden sein" );
	if( aFlags.bAFmtByInput && !pFrm->IsValid() )
	{
		SwRect aTmpFrm( pFrm->Frm() );
		SwRect aTmpPrt( pFrm->Prt() );
		pFrm->Calc();
		if( pFrm->Frm() != aTmpFrm || pFrm->Prt() != aTmpPrt ||
			( pFrm->IsTxtFrm() && !((SwTxtFrm*)pFrm)->Paint().IsEmpty() ) )
			pFrm->SetCompletePaint();
	}
	return ((SwTxtFrm*)pFrm)->GetFormatted();
}

void SwAutoFormat::_GetCharClass( LanguageType eLang )
{
	delete pCharClass;
	pCharClass = new CharClass( SvxCreateLocale( eLang ));
	eCharClassLang = eLang;
}

void SwAutoFormat::_SetRedlineTxt( sal_uInt16 nActionId )
{
	String sTxt;
	sal_uInt16 nSeqNo = 0;
	if( STR_AUTOFMTREDL_END > nActionId )
	{
		sTxt = *ViewShell::GetShellRes()->GetAutoFmtNameLst()[ nActionId ];
		switch( nActionId )
		{
		case STR_AUTOFMTREDL_SET_NUMBULET:
		case STR_AUTOFMTREDL_DEL_MORELINES:

		// AutoCorrect-Actions
		case STR_AUTOFMTREDL_USE_REPLACE:
		case STR_AUTOFMTREDL_CPTL_STT_WORD:
		case STR_AUTOFMTREDL_CPTL_STT_SENT:
		case STR_AUTOFMTREDL_TYPO:
		case STR_AUTOFMTREDL_UNDER:
		case STR_AUTOFMTREDL_BOLD:
		case STR_AUTOFMTREDL_FRACTION:
		case STR_AUTOFMTREDL_DASH:
		case STR_AUTOFMTREDL_ORDINAL:
        case STR_AUTOFMTREDL_NON_BREAK_SPACE:
			nSeqNo = ++nRedlAutoFmtSeqId;
			break;
		}
	}
#if OSL_DEBUG_LEVEL > 1
	else
		sTxt = String::CreateFromAscii(
							RTL_CONSTASCII_STRINGPARAM( "Action-Text fehlt" ));
#endif

	pDoc->SetAutoFmtRedlineComment( &sTxt, nSeqNo );
}

String SwAutoFormat::GoNextPara()
{
	SwNode* pNewNd = 0;
	do {
		//has to be checed twice before and after incrementation
		if( aNdIdx.GetIndex() >= aEndNdIdx.GetIndex() )
		{
			bEnde = sal_True;
			return aEmptyStr;
		}

		aNdIdx++;
		if( aNdIdx.GetIndex() >= aEndNdIdx.GetIndex() )
		{
			bEnde = sal_True;
			return aEmptyStr;
		}
		else
			pNewNd = &aNdIdx.GetNode();

		// kein TextNode ->
		// 		TableNode	: Tabelle ueberspringen
		// 		NoTxtNode	: Nodes ueberspringen
		// 		EndNode		: Ende erreicht, beenden
		if( pNewNd->IsEndNode() )
		{
			bEnde = sal_True;
			return aEmptyStr;
		}
		else if( pNewNd->IsTableNode() )
			aNdIdx = *pNewNd->EndOfSectionNode();
		else if( pNewNd->IsSectionNode() )
		{
			const SwSection& rSect = pNewNd->GetSectionNode()->GetSection();
			if( rSect.IsHiddenFlag() || rSect.IsProtectFlag() )
				aNdIdx = *pNewNd->EndOfSectionNode();
		}
	} while( !pNewNd->IsTxtNode() );

	if( !aFlags.bAFmtByInput )
		::SetProgressState( aNdIdx.GetIndex() + nEndNdIdx - aEndNdIdx.GetIndex(),
							pDoc->GetDocShell() );

	pAktTxtNd = (SwTxtNode*)pNewNd;
	pAktTxtFrm = GetFrm( *pAktTxtNd );
	return pAktTxtNd->GetTxt();
}

sal_Bool SwAutoFormat::HasObjects( const SwNode& rNd )
{
	// haengt irgend etwas absatzgebundenes am Absatz?
	// z.B. Rahmen, DrawObjecte, ..
	sal_Bool bRet = sal_False;
	const SwSpzFrmFmts& rFmts = *pDoc->GetSpzFrmFmts();
	for( sal_uInt16 n = 0; n < rFmts.Count(); ++n )
	{
		const SwFmtAnchor& rAnchor = rFmts[ n ]->GetAnchor();
        if ((FLY_AT_PAGE != rAnchor.GetAnchorId()) &&
			rAnchor.GetCntntAnchor() &&
			&rAnchor.GetCntntAnchor()->nNode.GetNode() == &rNd )
		{
			bRet = sal_True;
			break;
		}
	}
	return bRet;
}

const SwTxtNode* SwAutoFormat::GetNextNode() const
{
	if( aNdIdx.GetIndex()+1 >= aEndNdIdx.GetIndex() )
		return 0;
	return pDoc->GetNodes()[ aNdIdx.GetIndex() + 1 ]->GetTxtNode();
}


sal_Bool SwAutoFormat::IsOneLine( const SwTxtNode& rNd ) const
{
	SwTxtFrmInfo aFInfo( GetFrm( rNd ) );
	return aFInfo.IsOneLine();
}


sal_Bool SwAutoFormat::IsFastFullLine( const SwTxtNode& rNd ) const
{
	sal_Bool bRet = aFlags.bRightMargin;
	if( bRet )
	{
		SwTxtFrmInfo aFInfo( GetFrm( rNd ) );
		bRet = aFInfo.IsFilled( aFlags.nRightMargin );
	}
	return bRet;
}


sal_Bool SwAutoFormat::IsEnumericChar( const SwTxtNode& rNd ) const
{
	const String& rTxt = rNd.GetTxt();
	String sTmp( rTxt );
	xub_StrLen nBlnks = GetLeadingBlanks( sTmp );
	xub_StrLen nLen = rTxt.Len() - nBlnks;
	if( !nLen )
		return sal_False;

	// -, +, * getrennt durch Blank ??
	if( 2 < nLen && IsSpace( rTxt.GetChar( nBlnks + 1 ) ) )
	{
		if( StrChr( pBulletChar, rTxt.GetChar( nBlnks ) ) )
			return sal_True;
		// sollte an der Position ein Symbolfont existieren ?
		SwTxtFrmInfo aFInfo( GetFrm( rNd ) );
		if( aFInfo.IsBullet( nBlnks ))
			return sal_True;
	}

	// 1.) / 1. / 1.1.1 / (1). / (1) / ....
	return USHRT_MAX != GetDigitLevel( rNd, nBlnks );
}


sal_Bool SwAutoFormat::IsBlanksInString( const SwTxtNode& rNd ) const
{
	// suche im String mehr als 5 Blanks/Tabs
	String sTmp( rNd.GetTxt() );
	DelTrailingBlanks( DelLeadingBlanks( sTmp ));
	const sal_Unicode* pTmp = sTmp.GetBuffer();
	while( *pTmp )
	{
		if( IsSpace( *pTmp ) )
		{
			if( IsSpace( *++pTmp ))		// 2 Space nach einander
			{
				const sal_Unicode* pStt = pTmp;
				while( *pTmp && IsSpace( *++pTmp ))
					;
				if( 5 <= pTmp - pStt )
					return sal_True;
			}
			else
				++pTmp;
		}
		else
			++pTmp;
	}
	return sal_False;
}


sal_uInt16 SwAutoFormat::CalcLevel( const SwTxtNode& rNd, sal_uInt16 *pDigitLvl ) const
{
	sal_uInt16 nLvl = 0, nBlnk = 0;
	const String& rTxt = rNd.GetTxt();
	if( pDigitLvl )
		*pDigitLvl = USHRT_MAX;

	if( RES_POOLCOLL_TEXT_MOVE == rNd.GetTxtColl()->GetPoolFmtId() )
	{
		if( aFlags.bAFmtByInput )
		{
			nLvl = rNd.GetAutoFmtLvl();
			((SwTxtNode&)rNd).SetAutoFmtLvl( 0 );
			if( nLvl )
				return nLvl;
		}
		++nLvl;
	}


	for( xub_StrLen n = 0, nEnd = rTxt.Len(); n < nEnd; ++n )
	{
		switch( rTxt.GetChar( n ) )
		{
		case ' ': 	if( 3 == ++nBlnk )
						++nLvl, nBlnk = 0;
					break;
		case '\t':	++nLvl, nBlnk = 0;
					break;
		default:
			if( pDigitLvl )
				// Teste auf 1.) / 1. / 1.1.1 / (1). / (1) / ....
				*pDigitLvl = GetDigitLevel( rNd, n );
			return nLvl;
		}
	}
	return nLvl;
}



xub_StrLen SwAutoFormat::GetBigIndent( xub_StrLen& rAktSpacePos ) const
{
	SwTxtFrmInfo aFInfo( GetFrm( *pAktTxtNd ) );
	const SwTxtFrm* pNxtFrm = 0;

	if( !bMoreLines )
	{
		const SwTxtNode* pNxtNd = GetNextNode();
		if( !CanJoin( pNxtNd ) || !IsOneLine( *pNxtNd ) )
			return 0;

		pNxtFrm = GetFrm( *pNxtNd );
	}

	return aFInfo.GetBigIndent( rAktSpacePos, pNxtFrm );
}


sal_Bool SwAutoFormat::IsNoAlphaLine( const SwTxtNode& rNd ) const
{
	const String& rStr = rNd.GetTxt();
	if( !rStr.Len() )
		return sal_False;
	// oder besser: ueber die Anzahl von Alpha/Num- und !AN-Zeichen
	//				bestimmen.
	xub_StrLen nANChar = 0, nBlnk = 0;

	CharClass& rCC = GetCharClass( rNd.GetSwAttrSet().GetLanguage().GetLanguage() );
	for( xub_StrLen n = 0, nEnd = rStr.Len(); n < nEnd; ++n )
		if( IsSpace( rStr.GetChar( n ) ) )
			++nBlnk;
		else if( rCC.isLetterNumeric( rStr, n ))
			++nANChar;

	// sind zu 75% keine Alpha-Nummerische-Zeichen, dann sal_True
	sal_uLong nLen = rStr.Len() - nBlnk;
	nLen = ( nLen * 3 ) / 4;		    // long overflow, if the strlen > sal_uInt16
	return xub_StrLen(nLen) < (rStr.Len() - nANChar - nBlnk);
}



sal_Bool SwAutoFormat::DoUnderline()
{
	if( !aFlags.bSetBorder )
		return sal_False;

	const sal_Unicode* pStr = pAktTxtNd->GetTxt().GetBuffer();
	int eState = 0;
	xub_StrLen nCnt = 0;
	while( *pStr )
	{
//JP 29.03.96: Spaces unterbrechen die Umrandung!
//		if( !IsSpace( *pStr ) )
		{
			int eTmp = 0;
			switch( *pStr )
			{
			case '-': eTmp = 1;	break;
			case '_': eTmp = 2;	break;
			case '=': eTmp = 3;	break;
			case '*': eTmp = 4;	break;
			case '~': eTmp = 5;	break;
			case '#': eTmp = 6;	break;
			default:
				return sal_False;
			}
			if( 0 == eState )
				eState = eTmp;
			else if( eState != eTmp )
				return sal_False;
			++nCnt;
		}
		++pStr;
	}

	if( 2 < nCnt )
	{
		// dann unterstreiche mal den vorherigen Absatz, wenn es diesen gibt!
		DelEmptyLine( sal_False );
		aDelPam.SetMark();
		aDelPam.GetMark()->nContent = 0;
//JP 19.03.96: kein Underline sondern eine Umrandung setzen!
//		pDoc->Insert( aDelPam, SvxUnderlineItem( eState ) );

		SvxBorderLine aLine;
		switch( eState )
		{
		case 1:			// einfach, 0,05 pt
			aLine.SetOutWidth( DEF_LINE_WIDTH_0 );
			break;
		case 2:			// einfach, 1,0 pt
			aLine.SetOutWidth( DEF_LINE_WIDTH_1 );
			break;
		case 3:			// doppelt, 1,1 pt
			aLine.SetOutWidth( DEF_DOUBLE_LINE0_OUT );
			aLine.SetInWidth( DEF_DOUBLE_LINE0_IN );
			aLine.SetDistance( DEF_DOUBLE_LINE0_DIST );
			break;
		case 4:			// doppelt, 4,5 pt
			aLine.SetOutWidth( DEF_DOUBLE_LINE4_OUT );
			aLine.SetInWidth( DEF_DOUBLE_LINE4_IN );
			aLine.SetDistance( DEF_DOUBLE_LINE4_DIST );
			break;
		case 5:			// doppelt, 6,0 pt
			aLine.SetOutWidth( DEF_DOUBLE_LINE5_OUT );
			aLine.SetInWidth( DEF_DOUBLE_LINE5_IN );
			aLine.SetDistance( DEF_DOUBLE_LINE5_DIST );
			break;
		case 6:			// doppelt, 9,0 pt
			aLine.SetOutWidth( DEF_DOUBLE_LINE6_OUT );
			aLine.SetInWidth( DEF_DOUBLE_LINE6_IN );
			aLine.SetDistance( DEF_DOUBLE_LINE6_DIST );
			break;
		}
        SfxItemSet aSet(pDoc->GetAttrPool(),
                    RES_PARATR_CONNECT_BORDER, RES_PARATR_CONNECT_BORDER,
                    RES_BOX, RES_BOX,
                    0);
        aSet.Put( SwParaConnectBorderItem( sal_False ) );
        SvxBoxItem aBox( RES_BOX );
		aBox.SetLine( &aLine, BOX_LINE_BOTTOM );
		aBox.SetDistance( 42 );		// ~0,75 mm
        aSet.Put(aBox);
        pDoc->InsertItemSet( aDelPam, aSet, 0 );

		aDelPam.DeleteMark();
	}
	return 2 < nCnt;
}


sal_Bool SwAutoFormat::DoTable()
{
	if( !aFlags.bCreateTable || !aFlags.bAFmtByInput ||
		pAktTxtNd->FindTableNode() )
		return sal_False;

	const String& rTmp = pAktTxtNd->GetTxt();
	xub_StrLen nSttPlus = GetLeadingBlanks( rTmp );
	xub_StrLen nEndPlus = GetTrailingBlanks( rTmp );
	sal_Unicode cChar;

	if( 2 > nEndPlus - nSttPlus ||
		( '+' != ( cChar = rTmp.GetChar( nSttPlus )) && '|' != cChar ) ||
		( '+' != ( cChar = rTmp.GetChar( nEndPlus - 1)) && '|' != cChar ))
		return sal_False;

	SwTxtFrmInfo aInfo( pAktTxtFrm );

	xub_StrLen n = nSttPlus;
	const sal_Unicode* pStr = rTmp.GetBuffer() + n;
	SvUShorts aPosArr( 5, 5 );

	while( *pStr )
	{
		switch( *pStr )
		{
		case '-':
		case '_':
		case '=':
		case ' ':
		case '\t':
			break;

		case '+':
		case '|':
			aPosArr.Insert( static_cast<sal_uInt16>(aInfo.GetCharPos(n)), aPosArr.Count() );
			break;

		default:
			return sal_False;
		}
		if( ++n == nEndPlus )
			break;

		++pStr;
	}

	if( 1 < aPosArr.Count() )
	{
		// Ausrichtung vom Textnode besorgen:
		sal_uInt16 nColCnt = aPosArr.Count() - 1;
		SwTwips nSttPos = aPosArr[ 0 ];
        sal_Int16 eHori;
		switch( pAktTxtNd->GetSwAttrSet().GetAdjust().GetAdjust() )
		{
        case SVX_ADJUST_CENTER:     eHori = text::HoriOrientation::CENTER;    break;
        case SVX_ADJUST_RIGHT:      eHori = text::HoriOrientation::RIGHT;     break;

		default:
			if( nSttPos )
			{
                eHori = text::HoriOrientation::NONE;
				// dann muss als letztes noch die akt. FrameBreite
				// ins Array
				aPosArr.Insert( static_cast<sal_uInt16>(pAktTxtFrm->Frm().Width()), aPosArr.Count() );
			}
			else
                eHori = text::HoriOrientation::LEFT;
			break;
		}

		// dann erzeuge eine Tabelle, die den Zeichen entspricht
		DelEmptyLine();
		SwNodeIndex aIdx( aDelPam.GetPoint()->nNode );
		aDelPam.Move( fnMoveForward );
        pDoc->InsertTable( SwInsertTableOptions( tabopts::ALL_TBL_INS_ATTR , 1 ),
                           *aDelPam.GetPoint(), 1, nColCnt, eHori,
                           0, &aPosArr );
		aDelPam.GetPoint()->nNode = aIdx;
	}
	return 1 < aPosArr.Count();
}


String& SwAutoFormat::DelLeadingBlanks( String& rStr ) const
{
	xub_StrLen nL;
	xub_StrLen n;

	for( nL = rStr.Len(), n = 0; n < nL && IsSpace( rStr.GetChar(n) ); ++n )
		;
	if( n )		// keine Spaces
		rStr.Erase( 0, n );
	return rStr;
}


String& SwAutoFormat::DelTrailingBlanks( String& rStr ) const
{
	xub_StrLen nL = rStr.Len(), n = nL;
	if( !nL )
		return rStr;

	while( --n && IsSpace( rStr.GetChar( n ) )  )
		;
	if( n+1 != nL )		// keine Spaces
		rStr.Erase( n+1 );
	return rStr;
}


xub_StrLen SwAutoFormat::GetLeadingBlanks( const String& rStr ) const
{
	xub_StrLen nL;
	xub_StrLen n;

	for( nL = rStr.Len(), n = 0; n < nL && IsSpace( rStr.GetChar( n ) ); ++n )
		;
	return n;
}


xub_StrLen SwAutoFormat::GetTrailingBlanks( const String& rStr ) const
{
	xub_StrLen nL = rStr.Len(), n = nL;
	if( !nL )
		return 0;

	while( --n && IsSpace( rStr.GetChar( n ) )  )
		;
	return ++n;
}


sal_Bool SwAutoFormat::IsFirstCharCapital( const SwTxtNode& rNd ) const
{
	const String& rTxt = rNd.GetTxt();
	for( xub_StrLen n = 0, nEnd = rTxt.Len(); n < nEnd; ++n )
		if( !IsSpace( rTxt.GetChar( n ) ) )
		{
			CharClass& rCC = GetCharClass( rNd.GetSwAttrSet().
										GetLanguage().GetLanguage() );
			sal_Int32 nCharType = rCC.getCharacterType( rTxt, n );
			return CharClass::isLetterType( nCharType ) &&
                   0 != ( i18n::KCharacterType::UPPER &
													nCharType );
		}
	return sal_False;
}


sal_uInt16 SwAutoFormat::GetDigitLevel( const SwTxtNode& rNd, xub_StrLen& rPos,
		String* pPreFix, String* pPostFix, String* pNumTypes ) const
{
	// Teste auf 1.) / 1. / 1.1.1 / (1). / (1) / ....
	const String& rTxt = rNd.GetTxt();
	xub_StrLen nPos = rPos;
	int eScan = NONE;

	sal_uInt16 nStart = 0;
	sal_uInt8 nDigitLvl = 0, nDigitCnt = 0;
	//count number of parenthesis to assure a sensible order is found
	sal_uInt16 nOpeningParentheses = 0;
	sal_uInt16 nClosingParentheses = 0;

	CharClass& rCC = GetCharClass( rNd.GetSwAttrSet().GetLanguage().GetLanguage() );

	while( nPos < rTxt.Len() && nDigitLvl < MAXLEVEL - 1)
	{
		const sal_Unicode cCurrentChar = rTxt.GetChar( nPos );
		if( ('0' <= cCurrentChar &&  '9' >= cCurrentChar) ||
            (0xff10 <= cCurrentChar &&  0xff19 >= cCurrentChar) )
		{
			if( eScan & DELIM )
			{
				if( eScan & CHG )		// nicht wenns mit einer Zahl beginnt
				{
					++nDigitLvl;
					if( pPostFix )
						*pPostFix += (sal_Unicode)1;
				}

				if( pNumTypes )
					*pNumTypes += (sal_Unicode)('0' + SVX_NUM_ARABIC);

				eScan = eScan | CHG;
			}
			else if( pNumTypes && !(eScan & DIGIT) )
				*pNumTypes += (sal_Unicode)('0' + SVX_NUM_ARABIC);

			eScan &= ~DELIM;		// Delim raus
			if( 0 != (eScan & ~CHG) && DIGIT != (eScan & ~CHG))
				return USHRT_MAX;

			eScan |= DIGIT;			// Digit rein
			if( 3 == ++nDigitCnt )	// mehr als 2 Nummern sind kein Enum mehr
				return USHRT_MAX;

			nStart *= 10;
            nStart += cCurrentChar <= '9' ? cCurrentChar - '0' : cCurrentChar - 0xff10;
		}
		else if( rCC.isAlpha( rTxt, nPos ) )
		{
			sal_Bool bIsUpper =
                0 != ( i18n::KCharacterType::UPPER &
										rCC.getCharacterType( rTxt, nPos ));
			sal_Unicode cLow = rCC.toLower( rTxt, nPos, 1 ).GetChar(0), cNumTyp;
			int eTmpScan;

			// roemische Zeichen sind "mdclxvi". Da man aber eher mal eine
			// Numerierung mit c oder d anfangen will, werden diese erstmal
			// zu chars und spaeter ggfs. zu romischen Zeichen!
//			if( strchr( "mdclxvi", cLow ))
#ifdef WITH_ALPHANUM_AS_NUMFMT
			//detection of 'c' and 'd' a ROMAN numbering should not be done here
			if( 256 > cLow  &&( (eScan & (LOWER_ROMAN|UPPER_ROMAN))
									? strchr( "mdclxvi", cLow )
									: strchr( "mlxvi", cLow ) ))
#else
			if( 256 > cLow  && ( strchr( "mdclxvi", cLow ) ))
#endif
			{
				if( bIsUpper )
					cNumTyp = '0' + SVX_NUM_ROMAN_UPPER, eTmpScan = UPPER_ROMAN;
				else
					cNumTyp = '0' + SVX_NUM_ROMAN_LOWER, eTmpScan = LOWER_ROMAN;
			}
			else if( bIsUpper )
				cNumTyp = '0' + SVX_NUM_CHARS_UPPER_LETTER, eTmpScan = UPPER_ALPHA;
			else
				cNumTyp = '0' + SVX_NUM_CHARS_LOWER_LETTER, eTmpScan = LOWER_ALPHA;


			//ggfs. auf roemische Zeichen umschalten (nur bei c/d!)?
			if( 1 == nDigitCnt && ( eScan & (UPPER_ALPHA|LOWER_ALPHA) ) &&
				( 3 == nStart || 4 == nStart) && 256 > cLow &&
				strchr( "mdclxvi", cLow ) &&
				(( eScan & UPPER_ALPHA ) ? (eTmpScan & (UPPER_ALPHA|UPPER_ROMAN))
										 : (eTmpScan & (LOWER_ALPHA|LOWER_ROMAN))) )
			{
				sal_Unicode c = '0';
				nStart = 3 == nStart ? 100 : 500;
				if( UPPER_ALPHA == eTmpScan )
					eTmpScan = UPPER_ROMAN, c += SVX_NUM_ROMAN_UPPER;
				else
					eTmpScan = LOWER_ROMAN, c += SVX_NUM_ROMAN_LOWER;

				( eScan &= ~(UPPER_ALPHA|LOWER_ALPHA)) |= eTmpScan;
				if( pNumTypes )
					pNumTypes->SetChar( pNumTypes->Len() - 1, c );
			}

			if( eScan & DELIM )
			{
				if( eScan & CHG )		// nicht wenns mit einer Zahl beginnt
				{
					++nDigitLvl;
					if( pPostFix )
						*pPostFix += (sal_Unicode)1;
				}

				if( pNumTypes )
					*pNumTypes += cNumTyp;
				eScan = eScan | CHG;
			}
			else if( pNumTypes && !(eScan & eTmpScan) )
				*pNumTypes += cNumTyp;

			eScan &= ~DELIM;		// Delim raus

			// falls ein andere Type gesetzt ist, brechen wir ab
			if( 0 != ( eScan & ~CHG ) && eTmpScan != ( eScan & ~CHG ))
				return USHRT_MAX;

			if( eTmpScan & (UPPER_ALPHA | LOWER_ALPHA) )
			{
				// Buchstaben nur zulassen, wenn sie einmalig vorkommen
                return USHRT_MAX;
			}
			else
			{
				// roemische Zahlen: checke ob das gueltige Zeichen sind
				sal_uInt16 nVal;
				sal_Bool bError = sal_False;
				switch( cLow )
				{
				case 'm':	nVal = 1000; goto CHECK_ROMAN_1;
				case 'd':	nVal =  500; goto CHECK_ROMAN_5;
				case 'c':	nVal =  100; goto CHECK_ROMAN_1;
				case 'l':	nVal =   50; goto CHECK_ROMAN_5;
				case 'x':	nVal =   10; goto CHECK_ROMAN_1;
				case 'v':	nVal =    5; goto CHECK_ROMAN_5;

CHECK_ROMAN_1:
					{
						int nMod5 = nStart % (nVal * 5);
						int nLast = nStart % nVal;
						int n10 = nVal / 10;

						if( nMod5 == ((3 * nVal) + n10 ) ||
							nMod5 == ((4 * nVal) + n10 ) ||
							nLast == n10 )
							nStart = static_cast<sal_uInt16>(nStart + (n10 * 8));
						else if( nMod5 == 0 ||
								 nMod5 == (1 * nVal) ||
								 nMod5 == (2 * nVal) )
							nStart = nStart + nVal;
						else
							bError = sal_True;
					}
					break;

CHECK_ROMAN_5:
					{
						if( ( nStart / nVal ) & 1 )
							bError = sal_True;
						else
						{
							int nMod = nStart % nVal;
							int n10 = nVal / 5;
							if( n10 == nMod )
								nStart = static_cast<sal_uInt16>(nStart + (3 * n10));
							else if( 0 == nMod )
								nStart = nStart + nVal;
							else
								bError = sal_True;
						}
					}
					break;

				case 'i':
						if( nStart % 5 >= 3 )
							bError = sal_True;
						else
							nStart += 1;
						break;

				default:
					bError = sal_True;
				}

				if( bError )
					return USHRT_MAX;
			}
			eScan |= eTmpScan;			// Digit rein
			++nDigitCnt;
		}
        else if( (256 > cCurrentChar &&
                 strchr( ".)(", cCurrentChar )) ||
                 0x3002 == cCurrentChar /* Chinese trad. dot */||
                 0xff0e == cCurrentChar /* Japanese dot */||
                 0xFF08 == cCurrentChar /* opening bracket Chin./Jap.*/||
                 0xFF09 == cCurrentChar )/* closing bracket Chin./Jap. */
		{
            if(cCurrentChar == '(' || cCurrentChar == 0xFF09)
				nOpeningParentheses++;
            else if(cCurrentChar == ')'|| cCurrentChar == 0xFF08)
				nClosingParentheses++;
			// nur wenn noch keine Zahlen gelesen wurden!
			if( pPreFix && !( eScan & ( NO_DELIM | CHG )) )
				*pPreFix += rTxt.GetChar( nPos );
			else if( pPostFix )
				*pPostFix += rTxt.GetChar( nPos );

			if( NO_DELIM & eScan )
			{
				eScan |= CHG;
				if( pPreFix )
					(*pPreFix += (sal_Unicode)1)
							  += String::CreateFromInt32( nStart );
			}
			eScan &= ~NO_DELIM;		// Delim raus
			eScan |= DELIM;			// Digit rein
			nDigitCnt = 0;
			nStart = 0;
		}
		else
			break;
		++nPos;
	}
    if( !( CHG & eScan ) || rPos == nPos ||
		nPos == rTxt.Len() || !IsSpace( rTxt.GetChar( nPos ) ) ||
		(nOpeningParentheses > nClosingParentheses))
		return USHRT_MAX;

	if( (NO_DELIM & eScan) && pPreFix )		// den letzen nicht vergessen
		(*pPreFix += (sal_Unicode)1) += String::CreateFromInt32( nStart );

	rPos = nPos;
	return nDigitLvl;		// 0 .. 9 (MAXLEVEL - 1)
}


void SwAutoFormat::SetColl( sal_uInt16 nId, sal_Bool bHdLineOrText )
{
	aDelPam.DeleteMark();
	aDelPam.GetPoint()->nNode = aNdIdx;
	aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );

	// behalte harte Tabs, Ausrichtung, Sprache, Silbentrennung,
	// DropCaps und fast alle Frame-Attribute
	SfxItemSet aSet( pDoc->GetAttrPool(),
						RES_PARATR_ADJUST, RES_PARATR_ADJUST,
						RES_PARATR_TABSTOP, RES_PARATR_DROP,
						RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
						RES_BACKGROUND, RES_SHADOW,
						0 );

    if( pAktTxtNd->HasSwAttrSet() )
	{
		aSet.Put( *pAktTxtNd->GetpSwAttrSet() );
		// einige Sonderbedingungen:
		// HeaderLine/Textkoerper: nur zentriert oder rechts mitnehmem
		// sonst nur den Blocksatz
		SvxAdjustItem* pAdj;
		if( SFX_ITEM_SET == aSet.GetItemState( RES_PARATR_ADJUST,
						sal_False, (const SfxPoolItem**)&pAdj ))
		{
			SvxAdjust eAdj = pAdj->GetAdjust();
			if( bHdLineOrText ? (SVX_ADJUST_RIGHT != eAdj &&
								 SVX_ADJUST_CENTER != eAdj)
							  : SVX_ADJUST_BLOCK != eAdj )
				aSet.ClearItem( RES_PARATR_ADJUST );
		}
	}

	pDoc->SetTxtFmtCollByAutoFmt( *aDelPam.GetPoint(), nId, &aSet );
}


sal_Bool SwAutoFormat::HasSelBlanks( SwPaM& rPam ) const
{
	// noch ein Blank am Anfang oder Ende ?
	// nicht loeschen, wird wieder eingefuegt.
	SwPosition * pPos = rPam.End();
	xub_StrLen nBlnkPos = pPos->nContent.GetIndex();
	SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
	if( nBlnkPos && nBlnkPos-- < pTxtNd->GetTxt().Len() &&
		( ' ' == pTxtNd->GetTxt().GetChar( nBlnkPos ) ))
// JP 23.08.95: keine Tabs stehen lassen, diese in Blanks wandeln
//        ( ' ' == ( cCh = pTxtNd->GetTxt()[ nBlnkPos ] ) || '\t' == cCh ))
		pPos->nContent--;
	else
	{
		pPos = rPam.GetPoint() == pPos ? rPam.GetMark() : rPam.GetPoint();
		nBlnkPos = pPos->nContent.GetIndex();
		pTxtNd = pPos->nNode.GetNode().GetTxtNode();
		if( nBlnkPos < pTxtNd->GetTxt().Len() &&
			( ' ' == pTxtNd->GetTxt().GetChar( nBlnkPos )))
// JP 23.08.95: keine Tabs stehen lassen, diese in Blanks wandeln
//            ( ' ' == ( cCh = pTxtNd->GetTxt()[ nBlnkPos ] ) || '\t' == cCh ))
			pPos->nContent++;
		else
			return sal_False;
	}
	return sal_True;
}


sal_Bool SwAutoFormat::HasBreakAttr( const SwTxtNode& rTxtNd ) const
{
    const SfxItemSet* pSet = rTxtNd.GetpSwAttrSet();
	if( !pSet )
		return sal_False;

	const SfxPoolItem* pItem;
	if( SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pItem )
		&& SVX_BREAK_NONE != ((SvxFmtBreakItem*)pItem)->GetBreak() )
		return sal_True;

	if( SFX_ITEM_SET == pSet->GetItemState( RES_PAGEDESC, sal_False, &pItem )
		&& ((SwFmtPageDesc*)pItem)->GetPageDesc()
		&& nsUseOnPage::PD_NONE != ((SwFmtPageDesc*)pItem)->GetPageDesc()->GetUseOn() )
		return sal_True;
	return sal_False;
}


// ist ein Punkt am Ende ??
sal_Bool SwAutoFormat::IsSentenceAtEnd( const SwTxtNode& rTxtNd ) const
{
	const String& rStr = rTxtNd.GetTxt();
	xub_StrLen n = rStr.Len();
	if( !n )
		return sal_True;

	while( --n && IsSpace( rStr.GetChar( n  ) ) )
		;
	return '.' == rStr.GetChar( n );
}


// loesche im Node Anfang oder/und Ende
void SwAutoFormat::DeleteAktPara( sal_Bool bStart, sal_Bool bEnd )
{
	if( aFlags.bAFmtByInput
		? aFlags.bAFmtByInpDelSpacesAtSttEnd
		: aFlags.bAFmtDelSpacesAtSttEnd )
	{
		// Loesche Blanks am Ende vom akt. und am Anfang vom naechsten
		aDelPam.DeleteMark();
		aDelPam.GetPoint()->nNode = aNdIdx;
		xub_StrLen nPos;
		if( bStart && 0 != ( nPos = GetLeadingBlanks( pAktTxtNd->GetTxt() )))
		{
			aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );
			aDelPam.SetMark();
			aDelPam.GetPoint()->nContent = nPos;
			DeleteSel( aDelPam );
			aDelPam.DeleteMark();
		}
		if( bEnd && pAktTxtNd->GetTxt().Len() !=
					( nPos = GetTrailingBlanks( pAktTxtNd->GetTxt() )) )
		{
			aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, pAktTxtNd->GetTxt().Len() );
			aDelPam.SetMark();
			aDelPam.GetPoint()->nContent = nPos;
			DeleteSel( aDelPam );
			aDelPam.DeleteMark();
		}
	}
}

void SwAutoFormat::DeleteSel( SwPaM& rDelPam )
{
	if( aFlags.bWithRedlining )
	{
		// damit der DelPam auch verschoben wird, in den Shell-Cursr-Ring
		// mit aufnehmen !!
		SwPaM* pShCrsr = pEditShell->_GetCrsr();
		SwPaM aTmp( *pAktTxtNd, 0, pShCrsr );

		Ring *pPrev = rDelPam.GetPrev();
		rDelPam.MoveRingTo( pShCrsr );

		pEditShell->DeleteSel( rDelPam );

		// und den Pam wieder herausnehmen:
		Ring *p, *pNext = (Ring*)&rDelPam;
		do {
			p = pNext;
			pNext = p->GetNext();
			p->MoveTo( &rDelPam );
		} while( p != pPrev );

		aNdIdx = aTmp.GetPoint()->nNode;
		pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
	}
	else
		pEditShell->DeleteSel( rDelPam );
}

sal_Bool SwAutoFormat::DeleteAktNxtPara( const String& rNxtPara )
{
	// Loesche Blanks am Ende vom akt. und am Anfang vom naechsten
	aDelPam.DeleteMark();
	aDelPam.GetPoint()->nNode = aNdIdx;
	aDelPam.GetPoint()->nContent.Assign( pAktTxtNd,
					GetTrailingBlanks( pAktTxtNd->GetTxt() ) );
	aDelPam.SetMark();

	aDelPam.GetPoint()->nNode++;
	SwTxtNode* pTNd = aDelPam.GetNode()->GetTxtNode();
	if( !pTNd )
	{
		// dann nur bis zum Ende von Absatz loeschen
		aDelPam.GetPoint()->nNode--;
		aDelPam.GetPoint()->nContent = pAktTxtNd->GetTxt().Len();
	}
	else
		aDelPam.GetPoint()->nContent.Assign( pTNd,
							GetLeadingBlanks( rNxtPara ));

	// noch ein Blank am Anfang oder Ende ?
	// nicht loeschen, wird wieder eingefuegt.
	sal_Bool bHasBlnks = HasSelBlanks( aDelPam );

	if( *aDelPam.GetPoint() != *aDelPam.GetMark() )
		DeleteSel( aDelPam );
	aDelPam.DeleteMark();

	return !bHasBlnks;
}


void SwAutoFormat::DelEmptyLine( sal_Bool bTstNextPara )
{
	SetRedlineTxt( STR_AUTOFMTREDL_DEL_EMPTY_PARA );
	// Loesche Blanks den leeren Absatz
	aDelPam.DeleteMark();
	aDelPam.GetPoint()->nNode = aNdIdx;
	aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, pAktTxtNd->GetTxt().Len() );
	aDelPam.SetMark();

	aDelPam.GetMark()->nNode--;
	SwTxtNode* pTNd = aDelPam.GetNode( sal_False )->GetTxtNode();
	if( pTNd )
		// erstmal den vorherigen Textnode benutzen.
		aDelPam.GetMark()->nContent.Assign( pTNd, pTNd->GetTxt().Len() );
	else if( bTstNextPara )
	{
		// dann versuche den naechsten (am Anfang vom Dok, Tabellen-Zellen,
		// Rahmen, ...
		aDelPam.GetMark()->nNode += 2;
		pTNd = aDelPam.GetNode( sal_False )->GetTxtNode();
		if( pTNd )
		{
			aDelPam.GetMark()->nContent.Assign( pTNd, 0 );
			aDelPam.GetPoint()->nContent = 0;
		}
	}
	else
	{
		aDelPam.GetMark()->nNode = aNdIdx;
		aDelPam.GetMark()->nContent = 0;
		pTNd = pAktTxtNd;
	}
	if( pTNd )
		DeleteSel( aDelPam );

	aDelPam.DeleteMark();
	ClearRedlineTxt();
}


void SwAutoFormat::DelMoreLinesBlanks( sal_Bool bWithLineBreaks )
{
	if( aFlags.bAFmtByInput
		? aFlags.bAFmtByInpDelSpacesBetweenLines
		: aFlags.bAFmtDelSpacesBetweenLines	)
	{
		// loesche alle "Blanks" Links und Rechts vom Einzug
		aDelPam.DeleteMark();
		aDelPam.GetPoint()->nNode = aNdIdx;
		aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );

		SwTxtFrmInfo aFInfo( pAktTxtFrm );
		aFInfo.GetSpaces( aDelPam, !aFlags.bAFmtByInput || bWithLineBreaks );

		SwPaM* pNxt;
		do {
			pNxt = (SwPaM*)aDelPam.GetNext();
			if( pNxt->HasMark() && *pNxt->GetPoint() != *pNxt->GetMark() )
			{
				sal_Bool bHasBlnks = HasSelBlanks( *pNxt );
				DeleteSel( *pNxt );
				if( !bHasBlnks )
                {
                    pDoc->InsertString( *pNxt, sal_Unicode(' ') );
                }
			}

			if( pNxt == &aDelPam )
				break;
			delete pNxt;
		} while( sal_True );

		aDelPam.DeleteMark();
	}
}


		// loesche den vorherigen Absatz
void SwAutoFormat::DelPrevPara()
{
	aDelPam.DeleteMark();
	aDelPam.GetPoint()->nNode = aNdIdx;
	aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );
	aDelPam.SetMark();

	aDelPam.GetPoint()->nNode--;
	SwTxtNode* pTNd = aDelPam.GetNode()->GetTxtNode();
	if( pTNd )
	{
		// erstmal den vorherigen Textnode benutzen.
		aDelPam.GetPoint()->nContent.Assign( pTNd, pTNd->GetTxt().Len() );
		DeleteSel( aDelPam );
	}
	aDelPam.DeleteMark();
}


void SwAutoFormat::BuildIndent()
{
	SetRedlineTxt( STR_AUTOFMTREDL_SET_TMPL_INDENT );

	// lese alle nachfolgenden Absaetze die zu diesem Einzug gehoeren
	sal_Bool bBreak = sal_True;
	if( bMoreLines )
		DelMoreLinesBlanks( sal_True );
	else
		bBreak = !IsFastFullLine( *pAktTxtNd ) ||
				IsBlanksInString( *pAktTxtNd ) ||
				IsSentenceAtEnd( *pAktTxtNd );
	SetColl( RES_POOLCOLL_TEXT_IDENT );
	if( !bBreak )
	{
		SetRedlineTxt( STR_AUTOFMTREDL_DEL_MORELINES );
		const SwTxtNode* pNxtNd = GetNextNode();
		if( pNxtNd && !bEnde )
		{
			do {
				bBreak = !IsFastFullLine( *pNxtNd ) ||
						IsBlanksInString( *pNxtNd ) ||
						IsSentenceAtEnd( *pNxtNd );
				if( DeleteAktNxtPara( pNxtNd->GetTxt() ))
                {
                    pDoc->InsertString( aDelPam, sal_Unicode(' ') );
                }
				if( bBreak )
					break;
				pNxtNd = GetNextNode();
			} while( CanJoin( pNxtNd ) &&
					!CalcLevel( *pNxtNd ) );
		}
	}
	DeleteAktPara( sal_True, sal_True );
	AutoCorrect();
}


void SwAutoFormat::BuildTextIndent()
{
	SetRedlineTxt( STR_AUTOFMTREDL_SET_TMPL_TEXT_INDENT);
	// lese alle nachfolgenden Absaetze die zu diesem Einzug gehoeren
	sal_Bool bBreak = sal_True;
	if( bMoreLines )
		DelMoreLinesBlanks( sal_True );
	else
		bBreak = !IsFastFullLine( *pAktTxtNd ) ||
					IsBlanksInString( *pAktTxtNd ) ||
					IsSentenceAtEnd( *pAktTxtNd );

	if( aFlags.bAFmtByInput )
		pAktTxtNd->SetAutoFmtLvl( (sal_uInt8)CalcLevel( *pAktTxtNd ) );

	SetColl( RES_POOLCOLL_TEXT_MOVE );
	if( !bBreak )
	{
		SetRedlineTxt( STR_AUTOFMTREDL_DEL_MORELINES );
		const SwTxtNode* pNxtNd = GetNextNode();
		while(	CanJoin( pNxtNd ) &&
				CalcLevel( *pNxtNd ) )
		{
			bBreak = !IsFastFullLine( *pNxtNd ) || IsBlanksInString( *pNxtNd ) ||
					IsSentenceAtEnd( *pNxtNd );
			if( DeleteAktNxtPara( pNxtNd->GetTxt() ) )
            {
                pDoc->InsertString( aDelPam, sal_Unicode(' ') );
            }
			if( bBreak )
				break;
			pNxtNd = GetNextNode();
		}
	}
	DeleteAktPara( sal_True, sal_True );
	AutoCorrect();
}


void SwAutoFormat::BuildText()
{
	SetRedlineTxt( STR_AUTOFMTREDL_SET_TMPL_TEXT );
	// lese alle nachfolgenden Absaetze die zu diesem Text
	// ohne Einzug gehoeren
	sal_Bool bBreak = sal_True;
	if( bMoreLines )
		DelMoreLinesBlanks();
	else
		bBreak = !IsFastFullLine( *pAktTxtNd ) ||
					IsBlanksInString( *pAktTxtNd ) ||
					IsSentenceAtEnd( *pAktTxtNd );
	SetColl( RES_POOLCOLL_TEXT, sal_True );
	if( !bBreak )
	{
		SetRedlineTxt( STR_AUTOFMTREDL_DEL_MORELINES );
		const SwTxtNode* pNxtNd = GetNextNode();
		while(	CanJoin( pNxtNd ) &&
				!CalcLevel( *pNxtNd ) )
		{
			bBreak = !IsFastFullLine( *pNxtNd ) || IsBlanksInString( *pNxtNd ) ||
					IsSentenceAtEnd( *pNxtNd );
			if( DeleteAktNxtPara( pNxtNd->GetTxt() ) )
            {
                pDoc->InsertString( aDelPam, sal_Unicode(' ') );
            }
			if( bBreak )
				break;
            const SwTxtNode* pCurrNode = pNxtNd;
			pNxtNd = GetNextNode();
            if(!pNxtNd || pCurrNode == pNxtNd)
                break;
		}
	}
	DeleteAktPara( sal_True, sal_True );
	AutoCorrect();
}


void SwAutoFormat::BuildEnum( sal_uInt16 nLvl, sal_uInt16 nDigitLevel )
{
	SetRedlineTxt( STR_AUTOFMTREDL_SET_NUMBULET );

	sal_Bool bBreak = sal_True;

	// als erstes den akt. Einzug bestimmen und die Framebreite bestimmen
	SwTwips nFrmWidth = pAktTxtFrm->Prt().Width();;
	SwTwips nLeftTxtPos;
	{
		const sal_Unicode* pTxt = pAktTxtNd->GetTxt().GetBuffer(), *pSav = pTxt;
		while( IsSpace( *pTxt ) )
			++pTxt;

		SwTxtFrmInfo aInfo( pAktTxtFrm );
		nLeftTxtPos = aInfo.GetCharPos( static_cast<xub_StrLen>(pTxt - pSav) );
        nLeftTxtPos -= pAktTxtNd->GetSwAttrSet().GetLRSpace().GetLeft();
    }

	if( bMoreLines )
		DelMoreLinesBlanks();
	else
		bBreak = !IsFastFullLine( *pAktTxtNd ) ||
					IsBlanksInString( *pAktTxtNd ) ||
					IsSentenceAtEnd( *pAktTxtNd );
    sal_Bool bRTL = pEditShell->IsInRightToLeftText();
//	SetColl( RES_POOLCOLL_NUM_LEVEL1 + ( nLvl * 4 ) );
	DeleteAktPara( sal_True, sal_True );

	sal_Bool bChgBullet = sal_False, bChgEnum = sal_False;
	xub_StrLen nAutoCorrPos = 0;

	// falls die Numerierung gesetzt werden, die akt. besorgen
    // --> OD 2008-02-11 #newlistlevelattrs#
    SwNumRule aRule( pDoc->GetUniqueNumRuleName(),
                     // --> OD 2008-06-06 #i89178#
                     numfunc::GetDefaultPositionAndSpaceMode() );
                     // <--
    // <--
    const SwNumRule* pCur = 0;
	if( aFlags.bSetNumRule && 0 != (pCur = pAktTxtNd->GetNumRule()) )
		aRule = *pCur;

	// ersetze das Bullet-Zeichen mit dem definiertem
	const String& rStr = pAktTxtNd->GetTxt();
	xub_StrLen nTxtStt = 0, nOrigTxtStt = 0;
	const sal_Unicode* pFndBulletChr;
//	if( aFlags.bAFmtByInput ? aFlags.bSetNumRule : aFlags.bChgEnumNum &&
	if( aFlags.bChgEnumNum &&
		2 < rStr.Len() &&
		0 != ( pFndBulletChr = StrChr( pBulletChar, rStr.GetChar( nTxtStt ) ))
		&& IsSpace( rStr.GetChar( nTxtStt + 1 ) ) )
	{
		if( aFlags.bAFmtByInput )
		{
			if( aFlags.bSetNumRule )
			{
				SwCharFmt* pCFmt = pDoc->GetCharFmtFromPool(
											RES_POOLCHR_BUL_LEVEL );
				bChgBullet = sal_True;
				// wurde das Format schon mal angepasst?
				if( !aRule.GetNumFmt( nLvl ) )
				{
					int nBulletPos = pFndBulletChr - pBulletChar;
					sal_Unicode cBullChar;
                    const Font* pBullFnt( 0 );
					if( nBulletPos < cnPosEnDash )
					{
						cBullChar = aFlags.cBullet;
						pBullFnt = &aFlags.aBulletFont;
					}
					else
					{
						cBullChar = nBulletPos < cnPosEmDash
										? cStarSymbolEnDash
										: cStarSymbolEmDash;
                        // --> OD 2008-06-03 #i63395#
                        // Only apply user defined default bullet font
                        if ( numfunc::IsDefBulletFontUserDefined() )
                        {
                            pBullFnt = &numfunc::GetDefBulletFont();
                        }
                        // <--
					}

					sal_uInt16 nAbsPos = lBullIndent;
					sal_uInt16 nSpaceSteps = nLvl
											? sal_uInt16(nLeftTxtPos / nLvl)
											: lBullIndent;
					for( sal_uInt8 n = 0; n < MAXLEVEL; ++n, nAbsPos = nAbsPos + nSpaceSteps )
					{
						SwNumFmt aFmt( aRule.Get( n ) );
						aFmt.SetBulletFont( pBullFnt );
						aFmt.SetBulletChar( cBullChar );
						aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
                        // #i93908# clear suffix for bullet lists
                        aFmt.SetPrefix(::rtl::OUString());
                        aFmt.SetSuffix(::rtl::OUString());
						aFmt.SetFirstLineOffset( lBullFirstLineOffset );
						aFmt.SetAbsLSpace( nAbsPos );
						if( !aFmt.GetCharFmt() )
							aFmt.SetCharFmt( pCFmt );
                        if( bRTL )
                            aFmt.SetNumAdjust( SVX_ADJUST_RIGHT );

						aRule.Set( n, aFmt );

						if( n == nLvl &&
							nFrmWidth < ( nSpaceSteps * MAXLEVEL ) )
							nSpaceSteps = static_cast<sal_uInt16>(( nFrmWidth - nLeftTxtPos ) /
												( MAXLEVEL - nLvl ));
					}
				}
			}
		}
		else
		{
			bChgBullet = sal_True;
			SetColl( static_cast<sal_uInt16>(RES_POOLCOLL_BUL_LEVEL1 + ( Min( nLvl, cnNumBullColls ) * 4 )) );
		}
	}
	else
	{
		// dann ist das eine Nummerierung

		//JP 21.11.97: Der NumLevel wird entweder der DigitLevel oder
		// 				wenn der nicht vorhanden oder 0 ist, durch den
		//				(Einrueckungs-)Level.

		String aPostFix, aPreFix, aNumTypes;
		if( USHRT_MAX != ( nDigitLevel = GetDigitLevel( *pAktTxtNd, nTxtStt,
										&aPreFix, &aPostFix, &aNumTypes )) )
		{
			bChgEnum = sal_True;

			// Ebene 0 und Einrueckung dann wird die Ebene durch den linken
			// Einzug und der default NumEinrueckung bestimmt.
			if( !nDigitLevel && nLeftTxtPos )
				nLvl = Min( sal_uInt16( nLeftTxtPos / lNumIndent ),
							sal_uInt16( MAXLEVEL - 1 ) );
			else
				nLvl = nDigitLevel;
		}

		if( bChgEnum && aFlags.bSetNumRule )
		{
			if( !pCur )			// NumRule anpassen, wenn sie neu ist
			{
				SwCharFmt* pCFmt = pDoc->GetCharFmtFromPool(
											RES_POOLCHR_NUM_LEVEL );
				if( !nDigitLevel )
				{
					SwNumFmt aFmt( aRule.Get( nLvl ) );
					aFmt.SetStart( static_cast<sal_uInt16>(aPreFix.GetToken( 1,
											(sal_Unicode)1 ).ToInt32()));
					aFmt.SetPrefix( aPreFix.GetToken( 0, (sal_Unicode)1 ));
					aFmt.SetSuffix( aPostFix.GetToken( 0, (sal_Unicode)1 ));
					aFmt.SetIncludeUpperLevels( 0 );

					if( !aFmt.GetCharFmt() )
						aFmt.SetCharFmt( pCFmt );

					if( aNumTypes.Len() )
						aFmt.SetNumberingType(aNumTypes.GetChar( 0 ) - '0');

                    if( bRTL )
                        aFmt.SetNumAdjust( SVX_ADJUST_RIGHT );
					aRule.Set( nLvl, aFmt );
				}
				else
				{
					sal_uInt16 nSpaceSteps = nLvl ? sal_uInt16(nLeftTxtPos / nLvl) : 0;
                    sal_uInt8 n;
                    for( n = 0; n <= nLvl; ++n )
					{
						SwNumFmt aFmt( aRule.Get( n ) );

						aFmt.SetStart( static_cast<sal_uInt16>(aPreFix.GetToken( n+1,
													(sal_Unicode)1 ).ToInt32() ));
						if( !n )
							aFmt.SetPrefix( aPreFix.GetToken( n, (sal_Unicode)1 ));
						aFmt.SetSuffix( aPostFix.GetToken( n, (sal_Unicode)1 ));
						aFmt.SetIncludeUpperLevels( MAXLEVEL );
						if( n < aNumTypes.Len() )
							aFmt.SetNumberingType((aNumTypes.GetChar( n ) - '0'));

						aFmt.SetAbsLSpace( sal_uInt16( nSpaceSteps * n )
											+ lNumIndent );

						if( !aFmt.GetCharFmt() )
							aFmt.SetCharFmt( pCFmt );
                        if( bRTL )
                            aFmt.SetNumAdjust( SVX_ADJUST_RIGHT );

						aRule.Set( n, aFmt );
					}

					// passt alles vollstaendig in den Frame?
					sal_Bool bDefStep = nFrmWidth < (nSpaceSteps * MAXLEVEL);
					for( ; n < MAXLEVEL; ++n )
					{
						SwNumFmt aFmt( aRule.Get( n ) );
						aFmt.SetIncludeUpperLevels( MAXLEVEL );
						if( bDefStep )
							aFmt.SetAbsLSpace( sal_uInt16( (nLeftTxtPos +
                                SwNumRule::GetNumIndent(static_cast<sal_uInt8>(n-nLvl)))));
						else
							aFmt.SetAbsLSpace( sal_uInt16( nSpaceSteps * n )
												+ lNumIndent );
						aRule.Set( n, aFmt );
					}
				}
			}
		}
		else if( !aFlags.bAFmtByInput )
			SetColl( static_cast<sal_uInt16>(RES_POOLCOLL_NUM_LEVEL1 + ( Min( nLvl, cnNumBullColls ) * 4 ) ));
		else
			bChgEnum = sal_False;
	}

	if( bChgEnum || bChgBullet )
	{
		aDelPam.DeleteMark();
		aDelPam.GetPoint()->nNode = aNdIdx;

		if( aFlags.bSetNumRule )
		{
			if( aFlags.bAFmtByInput )
			{
				aDelPam.SetMark();
				aDelPam.GetMark()->nNode++;
                aDelPam.GetNode(sal_False)->GetTxtNode()->SetAttrListLevel( nLvl );
			}

            pAktTxtNd->SetAttrListLevel(nLvl);
			pAktTxtNd->SetNumLSpace( sal_True );

            // --> OD 2008-03-17 #refactorlists#
            // start new list
            pDoc->SetNumRule( aDelPam, aRule, true );
            // <--
			aDelPam.DeleteMark();

			aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );
		}
		else
			aDelPam.GetPoint()->nContent.Assign( pAktTxtNd,
						bChgEnum ? (nTxtStt - nOrigTxtStt) : 0 );
		aDelPam.SetMark();

		if( bChgBullet )
			nTxtStt += 2;

		while( nTxtStt < rStr.Len() && IsSpace( rStr.GetChar( nTxtStt ) ))
			nTxtStt++;

		aDelPam.GetPoint()->nContent = nTxtStt - nOrigTxtStt;
		DeleteSel( aDelPam );

		if( !aFlags.bSetNumRule )
		{
			String sChgStr( '\t' );
			if( bChgBullet )
				sChgStr.Insert( aFlags.cBullet, 0 );
            pDoc->InsertString( aDelPam, sChgStr );

			SfxItemSet aSet( pDoc->GetAttrPool(), aTxtNodeSetRange );
			if( bChgBullet )
			{
				aDelPam.GetPoint()->nContent = 0;
				aDelPam.SetMark();
				aDelPam.GetMark()->nContent = 1;
				SetAllScriptItem( aSet,
					 SvxFontItem( aFlags.aBulletFont.GetFamily(),
								  aFlags.aBulletFont.GetName(),
								  aFlags.aBulletFont.GetStyleName(),
								  aFlags.aBulletFont.GetPitch(),
                                  aFlags.aBulletFont.GetCharSet(),
                                  RES_CHRATR_FONT ) );
				pDoc->SetFmtItemByAutoFmt( aDelPam, aSet );
				aDelPam.DeleteMark();
				nAutoCorrPos = 2;
				aSet.ClearItem();
			}
            SvxTabStopItem aTStops( RES_PARATR_TABSTOP );    aTStops.Insert( SvxTabStop( 0 ));
			aSet.Put( aTStops );
			pDoc->SetFmtItemByAutoFmt( aDelPam, aSet );
		}
	}

	if( bBreak )
	{
		AutoCorrect( nAutoCorrPos );	   /* Offset wegen Bullet + Tab */
		return;
	}

	const SwTxtNode* pNxtNd = GetNextNode();
	while( CanJoin( pNxtNd ) &&
			nLvl == CalcLevel( *pNxtNd ) )
	{
		SetRedlineTxt( STR_AUTOFMTREDL_DEL_MORELINES );
		bBreak = !IsFastFullLine( *pNxtNd ) || IsBlanksInString( *pNxtNd ) ||
				IsSentenceAtEnd( *pNxtNd );
		if( DeleteAktNxtPara( pNxtNd->GetTxt() ) )
        {
            pDoc->InsertString( aDelPam, sal_Unicode(' ') );
        }
		if( bBreak )
			break;
        const SwTxtNode* pCurrNode = pNxtNd;
		pNxtNd = GetNextNode();
        if(!pNxtNd || pCurrNode == pNxtNd)
            break;
	}
	DeleteAktPara( sal_False, sal_True );
	AutoCorrect( nAutoCorrPos );
}


void SwAutoFormat::BuildNegIndent( SwTwips nSpaces )
{
	SetRedlineTxt( STR_AUTOFMTREDL_SET_TMPL_NEG_INDENT );
	// Test auf Gegenueberstellung:
	// (n Worte, durch Space/Tabs getrennt, mit gleicher
	//   Einrueckung in der 2.Zeile)

	// lese alle nachfolgenden Absaetze die zu dieser Aufzaehlung gehoeren
	sal_Bool bBreak = sal_True;
	xub_StrLen nSpacePos, nTxtPos = GetBigIndent( nSpacePos );
	if( bMoreLines )
		DelMoreLinesBlanks( sal_True );
	else
		bBreak = !IsFastFullLine( *pAktTxtNd ) ||
					( !nTxtPos && IsBlanksInString( *pAktTxtNd )) ||
					IsSentenceAtEnd( *pAktTxtNd );

	SetColl( static_cast<sal_uInt16>( nTxtPos
				? RES_POOLCOLL_CONFRONTATION
				: RES_POOLCOLL_TEXT_NEGIDENT ) );

	if( nTxtPos )
	{
		const String& rStr = pAktTxtNd->GetTxt();
		sal_Bool bInsTab = sal_True;

		if( '\t' == rStr.GetChar( nSpacePos+1 ))       // ein Tab, das belassen wir
		{
			--nSpacePos;
			bInsTab = sal_False;
		}

		xub_StrLen nSpaceStt = nSpacePos;
		while( nSpaceStt && IsSpace( rStr.GetChar( --nSpaceStt ) ) )
			;
		++nSpaceStt;

		if( bInsTab && '\t' == rStr.GetChar( nSpaceStt ) )		// ein Tab, das belassen wir
		{
			++nSpaceStt;
			bInsTab = sal_False;
		}


		aDelPam.DeleteMark();
		aDelPam.GetPoint()->nNode = aNdIdx;
		aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, nSpacePos );

		// alten Spaces, usw. loeschen
		if( nSpaceStt < nSpacePos )
		{
			aDelPam.SetMark();
			aDelPam.GetMark()->nContent = nSpaceStt;
			DeleteSel( aDelPam );
			if( bInsTab )
            {
                pDoc->InsertString( aDelPam, sal_Unicode('\t') );
            }
        }
    }

	if( !bBreak )
	{
		SetRedlineTxt( STR_AUTOFMTREDL_DEL_MORELINES );
		SwTxtFrmInfo aFInfo( pAktTxtFrm );
		const SwTxtNode* pNxtNd = GetNextNode();
		while(	CanJoin( pNxtNd ) &&
				20 < Abs( (long)(nSpaces - aFInfo.SetFrm(
								GetFrm( *pNxtNd ) ).GetLineStart() ))
			)
		{
			bBreak = !IsFastFullLine( *pNxtNd ) ||
					IsBlanksInString( *pNxtNd ) ||
					IsSentenceAtEnd( *pNxtNd );
			if( DeleteAktNxtPara( pNxtNd->GetTxt() ) )
            {
                pDoc->InsertString( aDelPam, sal_Unicode(' ') );
            }
			if( bBreak )
				break;
			pNxtNd = GetNextNode();
		}
	}
	DeleteAktPara( sal_True, sal_True );
	AutoCorrect();
}


void SwAutoFormat::BuildHeadLine( sal_uInt16 nLvl )
{
	if( aFlags.bWithRedlining )
	{
		String sTxt( *ViewShell::GetShellRes()->GetAutoFmtNameLst()[
									STR_AUTOFMTREDL_SET_TMPL_HEADLINE ] );
		sTxt.SearchAndReplace( String::CreateFromAscii(
									RTL_CONSTASCII_STRINGPARAM( "$(ARG1)" )),
								String::CreateFromInt32( nLvl + 1 ) );
		pDoc->SetAutoFmtRedlineComment( &sTxt );
	}

	SetColl( static_cast<sal_uInt16>(RES_POOLCOLL_HEADLINE1 + nLvl ), sal_True );
	if( aFlags.bAFmtByInput )
	{
		SwTxtFmtColl& rNxtColl = pAktTxtNd->GetTxtColl()->GetNextTxtFmtColl();

		DelPrevPara();

		DeleteAktPara( sal_True, sal_False );
		DeleteAktNxtPara( aEmptyStr );

		aDelPam.DeleteMark();
		aDelPam.GetPoint()->nNode = aNdIdx.GetIndex() + 1;
		aDelPam.GetPoint()->nContent.Assign( aDelPam.GetCntntNode(), 0 );
		pDoc->SetTxtFmtColl( aDelPam, &rNxtColl );
	}
	else
	{
		DeleteAktPara( sal_True, sal_True );
		AutoCorrect();
	}
}


		// dann lasse doch mal das AutoCorrect auf den akt. TextNode los
void SwAutoFormat::AutoCorrect( xub_StrLen nPos )
{
	SvxAutoCorrect* pATst = SvxAutoCorrCfg::Get()->GetAutoCorrect();
    long aSvxFlags = pATst->GetFlags( );
    bool bReplaceQuote = ( aSvxFlags & ChgQuotes ) > 0;
    bool bReplaceSglQuote = ( aSvxFlags & ChgSglQuotes ) > 0;

	if( aFlags.bAFmtByInput ||
		(!aFlags.bAutoCorrect && !bReplaceQuote && !bReplaceSglQuote &&
		!aFlags.bCptlSttSntnc && !aFlags.bCptlSttWrd &&
		!aFlags.bChgOrdinalNumber &&
		!aFlags.bChgToEnEmDash && !aFlags.bSetINetAttr &&
		!aFlags.bChgWeightUnderl && !aFlags.bAddNonBrkSpace) )
		return;

	const String* pTxt = &pAktTxtNd->GetTxt();
	if( nPos >= pTxt->Len() )
		return;

	sal_Bool bGetLanguage = aFlags.bChgOrdinalNumber ||
						aFlags.bChgToEnEmDash || aFlags.bSetINetAttr ||
						aFlags.bCptlSttWrd || aFlags.bCptlSttSntnc ||
                        aFlags.bAddNonBrkSpace;


	aDelPam.DeleteMark();
	aDelPam.GetPoint()->nNode = aNdIdx;
	aDelPam.GetPoint()->nContent.Assign( pAktTxtNd, 0 );

	SwAutoCorrDoc aACorrDoc( *pEditShell, aDelPam );

	SwTxtFrmInfo aFInfo( 0 );

	xub_StrLen nSttPos, nLastBlank = nPos;
	sal_Bool bFirst = aFlags.bCptlSttSntnc, bFirstSent = bFirst;
    sal_Unicode cChar = 0;

	CharClass& rAppCC = GetAppCharClass();

	do {
		while( nPos < pTxt->Len() && IsSpace( cChar = pTxt->GetChar( nPos ) ))
			++nPos;
		if( nPos == pTxt->Len() )
			break;		// das wars

		if( ( ( bReplaceQuote && '\"' == cChar ) ||
              ( bReplaceSglQuote && '\'' == cChar ) ) &&
			( !nPos || ' ' == pTxt->GetChar( nPos-1 ) ) )
		{
			// --------------------------------------
			// beachte: Sonderfall Symbolfonts !!!
			if( !aFInfo.GetFrm() )
				aFInfo.SetFrm( GetFrm( *pAktTxtNd ) );
			if( !aFInfo.IsBullet( nPos ))
			{
				SetRedlineTxt( STR_AUTOFMTREDL_TYPO );
				aDelPam.GetPoint()->nContent = nPos;
				sal_Bool bSetHardBlank = sal_False;

				String sReplace( pATst->GetQuote( aACorrDoc,
									nPos, cChar, sal_True ));

				aDelPam.SetMark();
				aDelPam.GetPoint()->nContent = nPos+1;
				if( 2 == sReplace.Len() && ' ' == sReplace.GetChar( 1 ))
				{
					sReplace.Erase( 1 );
					bSetHardBlank = sal_True;
				}
                pDoc->ReplaceRange( aDelPam, sReplace, false );

				if( aFlags.bWithRedlining )
				{
					aNdIdx = aDelPam.GetPoint()->nNode;
					pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
					pTxt = &pAktTxtNd->GetTxt();
					aDelPam.SetMark();
					aFInfo.SetFrm( 0 );
				}

				nPos += sReplace.Len() - 1;
				aDelPam.DeleteMark();
				if( bSetHardBlank )
				{
                    pDoc->InsertString( aDelPam, CHAR_HARDBLANK );
					++nPos;
				}
			}
		}

		int bCallACorr = sal_False;
		int bBreak = 0;
		if( nPos && IsSpace( pTxt->GetChar( nPos-1 )))
			nLastBlank = nPos;
		for( nSttPos = nPos; !bBreak && nPos < pTxt->Len(); ++nPos )
			switch( cChar = pTxt->GetChar( nPos ) )
			{
			case '\"':
			case '\'':
				if( ( cChar == '\"' && bReplaceQuote ) || ( cChar == '\'' && bReplaceSglQuote ) )
				{
					// --------------------------------------
					// beachte: Sonderfall Symbolfonts !!!
					if( !aFInfo.GetFrm() )
						aFInfo.SetFrm( GetFrm( *pAktTxtNd ) );
					if( !aFInfo.IsBullet( nPos ))
					{
						SetRedlineTxt( STR_AUTOFMTREDL_TYPO );
						sal_Bool bSetHardBlank = sal_False;
						aDelPam.GetPoint()->nContent = nPos;
						String sReplace( pATst->GetQuote( aACorrDoc,
													nPos, cChar, sal_False ));

						if( 2 == sReplace.Len() && ' ' == sReplace.GetChar( 0 ))
						{
							sReplace.Erase( 0, 1 );
							bSetHardBlank = sal_True;
						}

						aDelPam.SetMark();
						aDelPam.GetPoint()->nContent = nPos+1;
                        pDoc->ReplaceRange( aDelPam, sReplace, false );

						if( aFlags.bWithRedlining )
						{
							aNdIdx = aDelPam.GetPoint()->nNode;
							pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
							pTxt = &pAktTxtNd->GetTxt();
							aDelPam.SetMark();
							aDelPam.DeleteMark();
							aFInfo.SetFrm( 0 );
						}

						nPos += sReplace.Len() - 1;
						aDelPam.DeleteMark();

						if( bSetHardBlank )
						{
							aDelPam.GetPoint()->nContent = nPos;
                            pDoc->InsertString( aDelPam, CHAR_HARDBLANK );
							aDelPam.GetPoint()->nContent = ++nPos;
						}
					}
				}
				break;
			case '*':
			case '_':
				if( aFlags.bChgWeightUnderl )
				{
					// --------------------------------------
					// beachte: Sonderfall Symbolfonts !!!
					if( !aFInfo.GetFrm() )
						aFInfo.SetFrm( GetFrm( *pAktTxtNd ) );
					if( !aFInfo.IsBullet( nPos ))
					{
						SetRedlineTxt( '*' == cChar
											? STR_AUTOFMTREDL_BOLD
											: STR_AUTOFMTREDL_UNDER );

						sal_Unicode cBlank = nSttPos ? pTxt->GetChar(nSttPos - 1) : 0;
						aDelPam.GetPoint()->nContent = nPos;

						if( pATst->FnChgWeightUnderl( aACorrDoc, *pTxt,
															nSttPos, nPos ))
						{
                            if( aFlags.bWithRedlining )
                            {
                                aNdIdx = aDelPam.GetPoint()->nNode;
                                pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
                                pTxt = &pAktTxtNd->GetTxt();
                                aDelPam.SetMark();
                                aDelPam.DeleteMark();
                                aFInfo.SetFrm( 0 );
                            }
                            //#125102# in case of the mode REDLINE_SHOW_DELETE the ** are still contained in pTxt
                            if(0 == (pDoc->GetRedlineMode() & nsRedlineMode_t::REDLINE_SHOW_DELETE))
                                nPos = aDelPam.GetPoint()->nContent.GetIndex() - 1;
							// wurde vorm Start ein Zeichen entfernt?
							if( cBlank && cBlank != pTxt->GetChar(nSttPos - 1) )
								--nSttPos;
						}
					}
				}
				break;
            case '/':
                if ( aFlags.bAddNonBrkSpace )
                {
			        LanguageType eLang = (bGetLanguage && pAktTxtNd)
										   ? pAktTxtNd->GetLang( nSttPos )
										   : LANGUAGE_SYSTEM;

                    SetRedlineTxt( STR_AUTOFMTREDL_NON_BREAK_SPACE );
                    if ( pATst->FnAddNonBrkSpace( aACorrDoc, *pTxt, nSttPos, nPos, eLang ) )
                        --nPos;
                }
                break;

			case '.':
			case '!':
			case '?':
				if( aFlags.bCptlSttSntnc )
					bFirstSent = sal_True;
//alle Wortrenner loesen die Autokorrektur aus!
//				break;
			default:
//alle Wortrenner loesen die Autokorrektur aus!
//			case ' ':
//			case '\t':
				if( !( rAppCC.isLetterNumeric( *pTxt, nPos )
                        || '/' == cChar )) //  '/' should not be a word seperator (e.g. '1/2' needs to be handled as one word for replacement)
				{
					--nPos;		// ++nPos von dem for ungueltig machen !
					++bBreak;
				}
				break;
			}

		if( nPos == nSttPos )
		{
			if( ++nPos == pTxt->Len() )
				bCallACorr = sal_True;
		}
		else
			bCallACorr = sal_True;


		if( bCallACorr )
		{
			bCallACorr = sal_False;
			aDelPam.GetPoint()->nContent = nPos;
			SetRedlineTxt( STR_AUTOFMTREDL_USE_REPLACE );
			if( aFlags.bAutoCorrect &&
				aACorrDoc.ChgAutoCorrWord( nSttPos, nPos, *pATst, 0 ) )
			{
				nPos = aDelPam.GetPoint()->nContent.GetIndex();

				if( aFlags.bWithRedlining )
				{
					aNdIdx = aDelPam.GetPoint()->nNode;
					pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
					pTxt = &pAktTxtNd->GetTxt();
					aDelPam.SetMark();
					aDelPam.DeleteMark();
				}

				continue;		// nichts weiter mehr abpruefen
			}

			LanguageType eLang = (bGetLanguage && pAktTxtNd)
										   ? pAktTxtNd->GetLang( nSttPos )
										   : LANGUAGE_SYSTEM;

            if ( aFlags.bAddNonBrkSpace )
            {
                SetRedlineTxt( STR_AUTOFMTREDL_NON_BREAK_SPACE );
                pATst->FnAddNonBrkSpace( aACorrDoc, *pTxt, nSttPos, nPos, eLang );
            }

			if( ( aFlags.bChgOrdinalNumber &&
					SetRedlineTxt( STR_AUTOFMTREDL_ORDINAL ) &&
					pATst->FnChgOrdinalNumber( aACorrDoc, *pTxt, nSttPos, nPos, eLang ) ) ||
				( aFlags.bChgToEnEmDash &&
					SetRedlineTxt( STR_AUTOFMTREDL_DASH ) &&
					pATst->FnChgToEnEmDash( aACorrDoc, *pTxt, nSttPos, nPos, eLang ) ) ||
				( aFlags.bSetINetAttr &&
					( nPos == pTxt->Len() || IsSpace( pTxt->GetChar( nPos )) ) &&
					SetRedlineTxt( STR_AUTOFMTREDL_DETECT_URL ) &&
					pATst->FnSetINetAttr( aACorrDoc, *pTxt, nLastBlank, nPos, eLang ) ) )
					nPos = aDelPam.GetPoint()->nContent.GetIndex();
			else
			{
				// Zwei Grossbuchstaben am Wort-Anfang ??
				if( aFlags.bCptlSttWrd )
				{
					SetRedlineTxt( STR_AUTOFMTREDL_CPTL_STT_WORD );
					pATst->FnCptlSttWrd( aACorrDoc, *pTxt, nSttPos, nPos, eLang );
				}
				// Grossbuchstabe am Satz-Anfang ??
				if( aFlags.bCptlSttSntnc && bFirst )
				{
					SetRedlineTxt( STR_AUTOFMTREDL_CPTL_STT_SENT );
					pATst->FnCptlSttSntnc( aACorrDoc, *pTxt, sal_True, nSttPos, nPos, eLang);
					bFirst = sal_False;
				}

				bFirst = bFirstSent;
				bFirstSent = sal_False;

				if( aFlags.bWithRedlining )
				{
					aNdIdx = aDelPam.GetPoint()->nNode;
					pAktTxtNd = aNdIdx.GetNode().GetTxtNode();
					pTxt = &pAktTxtNd->GetTxt();
					aDelPam.SetMark();
					aDelPam.DeleteMark();
				}
			}
		}
	} while( nPos < pTxt->Len() );
	ClearRedlineTxt();
}


SwAutoFormat::SwAutoFormat( SwEditShell* pEdShell, SvxSwAutoFmtFlags& rFlags,
							SwNodeIndex* pSttNd, SwNodeIndex* pEndNd )
	: aFlags( rFlags ),
	aDelPam( pEdShell->GetDoc()->GetNodes().GetEndOfExtras() ),
	aNdIdx( pEdShell->GetDoc()->GetNodes().GetEndOfExtras(), +1 ),
	aEndNdIdx( pEdShell->GetDoc()->GetNodes().GetEndOfContent() ),
	pEditShell( pEdShell ),
	pDoc( pEdShell->GetDoc() ),
	pAktTxtNd( 0 ), pAktTxtFrm( 0 ),
	pCharClass( 0 ),
	nRedlAutoFmtSeqId( 0 )
{
	ASSERT( (pSttNd && pEndNd) || (!pSttNd && !pEndNd),
			"Kein Bereich angegeben" );

	if( aFlags.bSetNumRule && !aFlags.bAFmtByInput )
		aFlags.bSetNumRule = sal_False;

	sal_Bool bReplaceStyles = !aFlags.bAFmtByInput || aFlags.bReplaceStyles;

    const SwTxtNode* pNxtNd = 0;
    sal_Bool bNxtEmpty = sal_False;
    sal_Bool bNxtAlpha = sal_False;
    sal_uInt16 nNxtLevel = 0;

	// setze den Bereich zum Autoformatieren
	if( pSttNd )
	{
		aNdIdx = *pSttNd;
		aNdIdx--;			// fuer GoNextPara, ein Absatz davor
		aEndNdIdx = *pEndNd;
		aEndNdIdx++;

		// teste den vorhergehenden TextNode
		pNxtNd = aNdIdx.GetNode().GetTxtNode();
		bEmptyLine = !pNxtNd ||
					IsEmptyLine( *pNxtNd ) ||
					IsNoAlphaLine( *pNxtNd );
	}
	else
		bEmptyLine = sal_True;		// am Dokument Anfang

	bEnde = sal_False;

	// setze die Werte fuer die Prozent-Anzeige
	nEndNdIdx = aEndNdIdx.GetIndex();

	if( !aFlags.bAFmtByInput )
		::StartProgress( STR_STATSTR_AUTOFORMAT, aNdIdx.GetIndex(),
						 nEndNdIdx = aEndNdIdx.GetIndex(),
						 pDoc->GetDocShell() );

	RedlineMode_t eRedlMode = pDoc->GetRedlineMode(), eOldMode = eRedlMode;
	if( aFlags.bWithRedlining )
	{
		pDoc->SetAutoFmtRedline( sal_True );
		eRedlMode = (RedlineMode_t)(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_SHOW_INSERT);
	}
	else
	  eRedlMode = (RedlineMode_t)(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_IGNORE);
	pDoc->SetRedlineMode( eRedlMode );

    // save undo state (might be turned off)
    bool const bUndoState = pDoc->GetIDocumentUndoRedo().DoesUndo();

	// wenn mehrere Zeilen, dann erstmal nicht mit
	// dem nachfolgenden Absatz zusammenfassen.
	bMoreLines = sal_False;

	nLastCalcHeadLvl = nLastCalcEnumLvl = 0;
	nLastHeadLvl = nLastEnumLvl = USHRT_MAX;
    sal_uInt16 nLevel = 0;
    sal_uInt16 nDigitLvl = 0;

	// defaulten
	SwTxtFrmInfo aFInfo( 0 );

	// das ist unser Automat fuer die Auto-Formatierung
	eStat = READ_NEXT_PARA;
	while( !bEnde )
	{
		switch( eStat )
		{
		case READ_NEXT_PARA:
			{
				GoNextPara();
				eStat = bEnde ? IS_ENDE : TST_EMPTY_LINE;
			}
			break;

		case TST_EMPTY_LINE:
			if( IsEmptyLine( *pAktTxtNd ) )
			{
				if( aFlags.bDelEmptyNode && !HasObjects( *pAktTxtNd ) )
				{
					bEmptyLine = sal_True;
					sal_uLong nOldCnt = pDoc->GetNodes().Count();
					DelEmptyLine();
					// wurde wiklich ein Node geloescht ?
					if( nOldCnt != pDoc->GetNodes().Count() )
						aNdIdx--;		// nicht den naechsten Absatz ueberspringen
				}
				eStat = READ_NEXT_PARA;
			}
			else
				eStat = TST_ALPHA_LINE;
			break;

		case TST_ALPHA_LINE:
			if( IsNoAlphaLine( *pAktTxtNd ))
			{
				// erkenne eine Tabellendefinition +---+---+
				if( aFlags.bAFmtByInput && aFlags.bCreateTable && DoTable() )
				{
					//JP 30.09.96: das DoTable() verlaesst sich auf das
					//				Pop und Move - Crsr nach dem AutoFormat!
					pEdShell->Pop( sal_False );
					*pEdShell->GetCrsr() = aDelPam;
					pEdShell->Push();

					eStat = IS_ENDE;
					break;
				}

				// dann teste mal auf 3 "---" oder "===". In dem Fall
				// soll der vorherige Absatz unterstrichen und dieser
				// geloescht werden!
				if( !DoUnderline() && bReplaceStyles )
				{
					SetColl( RES_POOLCOLL_STANDARD, sal_True );
					bEmptyLine = sal_True;
				}
				eStat = READ_NEXT_PARA;
			}
			else
				eStat = GET_ALL_INFO;
			break;

		case GET_ALL_INFO:
			{
				if( pAktTxtNd->GetNumRule() )
				{
					// in Numerierung nichts machen, zum naechsten
					bEmptyLine = sal_False;
					eStat = READ_NEXT_PARA;
					// loesche alle Blanks am Anfang/Ende
					// und alle mitten drin
					//JP 29.04.98: erstmal nur alle "mitten drin".
					DelMoreLinesBlanks( sal_False );
					break;
				}

				aFInfo.SetFrm( pAktTxtFrm );

				// erstmal: wurden schon mal entsprechende Vorlagen
				//			vergeben, so behalte die bei, gehe zum
				//			naechsten Node.
				sal_uInt16 nPoolId = pAktTxtNd->GetTxtColl()->GetPoolFmtId();
				if( IsPoolUserFmt( nPoolId )
						? !aFlags.bChgUserColl
						: ( RES_POOLCOLL_STANDARD != nPoolId &&
						   ( !aFlags.bAFmtByInput ||
							(RES_POOLCOLL_TEXT_MOVE != nPoolId &&
							 RES_POOLCOLL_TEXT != nPoolId )) ))
				{
					eStat = HAS_FMTCOLL;
					break;
				}

				// teste auf Harte oder aus Vorlagen gesetzte LRSpaces
				if( IsPoolUserFmt( nPoolId ) ||
					RES_POOLCOLL_STANDARD == nPoolId )
				{
					short nSz;
					SvxLRSpaceItem* pLRSpace;
					if( SFX_ITEM_SET == pAktTxtNd->GetSwAttrSet().
						GetItemState( RES_LR_SPACE, sal_True,
										(const SfxPoolItem**)&pLRSpace ) &&
						( 0 != (nSz = pLRSpace->GetTxtFirstLineOfst()) ||
							0 != pLRSpace->GetTxtLeft() ) )
					{
						// Ausnahme: Numerierun/Aufzaehlung kann mit Einzug
						//		existieren!!
						if( IsEnumericChar( *pAktTxtNd ))
						{
							nLevel = CalcLevel( *pAktTxtNd, &nDigitLvl );
							if( nLevel >= MAXLEVEL )
								nLevel = MAXLEVEL-1;
							BuildEnum( nLevel, nDigitLvl );
							eStat = READ_NEXT_PARA;
							break;
						}


						// nie zusammenfassen, so belassen
						// (Opt. vielleicht als Ausnahmen nur Einzug)
						bMoreLines = sal_True;

						if( bReplaceStyles )
						{
							// dann setze doch eine unserer Vorlagen
							if( 0 < nSz )			// positiver 1. Zeileneinzug
								BuildIndent();
							else if( 0 > nSz )		// negativer 1. Zeileneinzug
								BuildNegIndent( aFInfo.GetLineStart() );
							else if( pLRSpace->GetTxtLeft() )	// ist ein Einzug
								BuildTextIndent();
						}
						eStat = READ_NEXT_PARA;
						break;
					}
				}

				nLevel = CalcLevel( *pAktTxtNd, &nDigitLvl );
				bMoreLines = !IsOneLine( *pAktTxtNd );
				pNxtNd = GetNextNode();
				if( pNxtNd )
				{
					bNxtEmpty = IsEmptyLine( *pNxtNd );
					bNxtAlpha = IsNoAlphaLine( *pNxtNd );
					nNxtLevel = CalcLevel( *pNxtNd );

					if( !bEmptyLine && HasBreakAttr( *pAktTxtNd ) )
						bEmptyLine = sal_True;
					if( !bNxtEmpty && HasBreakAttr( *pNxtNd ) )
						bNxtEmpty = sal_True;

					// fuer z.B. selbst definierte Einzuege oder
					// rechts/zentierte Ausrichtung
//					if( !nLevel && 0 != aFInfo.GetLineStart() )
//						nLevel = 1;
				}
				else
				{
					bNxtEmpty = sal_False; // sal_True;
					bNxtAlpha = sal_False;
					nNxtLevel = 0;
				}
				eStat = !bMoreLines ? IS_ONE_LINE : TST_ENUMERIC;
			}
			break;

		case IS_ONE_LINE:
			{
				eStat = TST_ENUMERIC;
				if( !bReplaceStyles )
					break;

				String sClrStr( pAktTxtNd->GetTxt() );

				if( !DelLeadingBlanks( sClrStr ).Len() )
				{
					bEmptyLine = sal_True;
					eStat = READ_NEXT_PARA;
					break;		// naechsten Absatz lesen
				}

				// Teste auf Ueberschrift
				if( !bEmptyLine || !IsFirstCharCapital( *pAktTxtNd ) ||
					IsBlanksInString( *pAktTxtNd ) )
					break;

				bEmptyLine = sal_False;
				String sEndClrStr( sClrStr );
				xub_StrLen nLen = DelTrailingBlanks( sEndClrStr ).Len();

				// nicht, dann teste auf Ueberschrift
				if( ':' == sEndClrStr.GetChar( nLen - 1 ) )
				{
//---------------------------------------------------------------------------
// Wie ist denn nun die Bedingung fuer die Ueberschrift auf Ebene 3 ??
// Zur Zeit: generell wenn am Ende ein ':' ist.
//
//					if( bNxtEmpty || bNxtAlpha )
//						!IsEnumericChar( *pNxtNd ) )
//---------------------------------------------------------------------------
					{
						BuildHeadLine( 2 );
						eStat = READ_NEXT_PARA;
						break;
					}
				}
				else if( 256 <= sEndClrStr.GetChar( nLen-1 ) ||
						 !strchr( ",.;", sEndClrStr.GetChar( nLen-1 )) )
				{
					if( bNxtEmpty || bNxtAlpha
						|| ( pNxtNd && IsEnumericChar( *pNxtNd ))

//---------------------------------------------------------------------------
// ist zum Verwechseln mit neg. Einzug !!
						/*|| nLevel < nNxtLevel*/
//---------------------------------------------------------------------------

						)
					{
						// wurde Level vom Text vorgegeben ?
//						if( USHRT_MAX != nDigitLvl )
//							nLevel = nDigitLvl;

						// eine Ebene runter ?
						if( nLevel >= MAXLEVEL )
							nLevel = MAXLEVEL-1;

						if( USHRT_MAX == nLastHeadLvl )
							nLastHeadLvl = 0;
						else if( nLastCalcHeadLvl < nLevel )
						{
							if( nLastHeadLvl+1 < MAXLEVEL )
								++nLastHeadLvl;
						}
						// eine Ebene hoch ?
						else if( nLastCalcHeadLvl > nLevel )
						{
							if( nLastHeadLvl )
								--nLastHeadLvl;
						}
						nLastCalcHeadLvl = nLevel;

						if( aFlags.bAFmtByInput )
							BuildHeadLine( nLevel );
						else
							BuildHeadLine( nLastHeadLvl );
						eStat = READ_NEXT_PARA;
						break;
					}
				}
			}
			break;

		case TST_ENUMERIC:
			{
				bEmptyLine = sal_False;
				if( IsEnumericChar( *pAktTxtNd ))
				{
					if( nLevel >= MAXLEVEL )
						nLevel = MAXLEVEL-1;
					BuildEnum( nLevel, nDigitLvl );
					eStat = READ_NEXT_PARA;
				}
//JP 25.03.96: Vorlagen fuer Einzug zulassen
//				else if( aFlags.bAFmtByInput )
//					eStat = READ_NEXT_PARA;
				else if( bReplaceStyles )
					eStat = nLevel ? TST_IDENT : TST_NEG_IDENT;
				else
					eStat = READ_NEXT_PARA;
			}
			break;

		case TST_IDENT:
			// Spaces am Anfang, dann teste doch mal auf Einzuege
			if( bMoreLines && nLevel )
			{
				SwTwips nSz = aFInfo.GetFirstIndent();
				if( 0 < nSz )			// positiver 1. Zeileneinzug
					BuildIndent();
				else if( 0 > nSz )		// negativer 1. Zeileneinzug
					BuildNegIndent( aFInfo.GetLineStart() );
				else					// ist ein Einzug
					BuildTextIndent();
				eStat = READ_NEXT_PARA;
			}
			else if( nLevel && pNxtNd && !bEnde &&
					 !bNxtEmpty && !bNxtAlpha && !nNxtLevel &&
					 !IsEnumericChar( *pNxtNd ) )
			{
				// ist ein Einzug
				BuildIndent();
				eStat = READ_NEXT_PARA;
			}
			else
				eStat = TST_TXT_BODY;
			break;

		case TST_NEG_IDENT:
			// keine Spaces am Anfang, dann teste doch mal auf neg. Einzuege
			{
				if( bMoreLines && !nLevel )
				{
					SwTwips nSz = aFInfo.GetFirstIndent();
					if( 0 < nSz )			// positiver 1. Zeileneinzug
						BuildIndent();
					else if( 0 > nSz )		// negativer 1. Zeileneinzug
						BuildNegIndent( aFInfo.GetLineStart() );
					else					// ist ein kein Einzug
						BuildText();
					eStat = READ_NEXT_PARA;
				}
				else if( !nLevel && pNxtNd && !bEnde &&
						 !bNxtEmpty && !bNxtAlpha && nNxtLevel &&
						 !IsEnumericChar( *pNxtNd ) )
				{
					// ist ein neg. Einzug
					BuildNegIndent( aFInfo.GetLineStart() );
					eStat = READ_NEXT_PARA;
				}
				else
					eStat = TST_TXT_BODY;
			}
			break;

		case TST_TXT_BODY:
			{
				if( bMoreLines )
				{
					SwTwips nSz = aFInfo.GetFirstIndent();
					if( 0 < nSz )			// positiver 1. Zeileneinzug
						BuildIndent();
					else if( 0 > nSz )		// negativer 1. Zeileneinzug
						BuildNegIndent( aFInfo.GetLineStart() );
					else if( nLevel )		// ist ein Einzug
						BuildTextIndent();
					else
						BuildText();
				}
				else if( nLevel )
					BuildTextIndent();
				else
					BuildText();
				eStat = READ_NEXT_PARA;
			}
			break;

		case HAS_FMTCOLL:
			{
				// erstmal: wurden schon mal entsprechende Vorlagen
				//			vergeben, so behalte die bei, gehe zum
				//			naechsten Node.
				bEmptyLine = sal_False;
				eStat = READ_NEXT_PARA;
				// loesche alle Blanks am Anfang/Ende
				// und alle mitten drin
				//JP 29.04.98: erstmal nur alle "mitten drin".
				DelMoreLinesBlanks( sal_False );

				// behandel die harte Attributierung
                if( pAktTxtNd->HasSwAttrSet() )
				{
					short nSz;
					SvxLRSpaceItem* pLRSpace;
					if( bReplaceStyles &&
                        SFX_ITEM_SET == pAktTxtNd->GetSwAttrSet().
						GetItemState( RES_LR_SPACE, sal_False,
										(const SfxPoolItem**)&pLRSpace ) &&
						( 0 != (nSz = pLRSpace->GetTxtFirstLineOfst()) ||
							0 != pLRSpace->GetTxtLeft() ) )
					{
						// dann setze doch eine unserer Vorlagen
						if( 0 < nSz )			// positiver 1. Zeileneinzug
							BuildIndent();
						else if( 0 > nSz )		// negativer 1. Zeileneinzug
						{
							BuildNegIndent( aFInfo.GetLineStart() );
						}
						else if( pLRSpace->GetTxtLeft() )	// ist ein Einzug
							BuildTextIndent();
						else
							BuildText();
					}
				}
			}
			break;

		case IS_ENDE:
			bEnde = sal_True;
			break;
		}
	}

	if( aFlags.bWithRedlining )
		pDoc->SetAutoFmtRedline( sal_False );
	pDoc->SetRedlineMode( eOldMode );

    // restore undo (in case it has been changed)
    pDoc->GetIDocumentUndoRedo().DoUndo(bUndoState);

	// Prozent-Anzeige wieder abschalten
	if( !aFlags.bAFmtByInput )
		::EndProgress( pDoc->GetDocShell() );
}

void SwEditShell::AutoFormat( const SvxSwAutoFmtFlags* pAFlags )
{
	SwWait* pWait = 0;

	SET_CURR_SHELL( this );
	StartAllAction();
	StartUndo( UNDO_AUTOFORMAT );

	SvxSwAutoFmtFlags aAFFlags;		// erst mal default - Werte
	if( pAFlags )					// oder doch angegeben ??
	{
		aAFFlags = *pAFlags;
		if( !aAFFlags.bAFmtByInput )
			pWait = new SwWait( *GetDoc()->GetDocShell(), true );
	}

	SwPaM* pCrsr = GetCrsr();
	// es gibt mehr als einen oder ist eine Selektion offen
	if( pCrsr->GetNext() != pCrsr || pCrsr->HasMark() )
	{
		FOREACHPAM_START(this)
			if( PCURCRSR->HasMark() )
			{
				SwAutoFormat aFmt( this, aAFFlags, &PCURCRSR->Start()->nNode,
									 &PCURCRSR->End()->nNode );
			}
		FOREACHPAM_END()
	}
	else
	{
		SwAutoFormat aFmt( this, aAFFlags );
	}

	EndUndo( UNDO_AUTOFORMAT );
	EndAllAction();

	delete pWait;
}


void SwEditShell::AutoFmtBySplitNode()
{
	SET_CURR_SHELL( this );
	SwPaM* pCrsr = GetCrsr();
	if( pCrsr->GetNext() == pCrsr && pCrsr->Move( fnMoveBackward, fnGoNode ) )
	{
		StartAllAction();
		StartUndo( UNDO_AUTOFORMAT );

		sal_Bool bRange = sal_False;
		pCrsr->SetMark();
		SwIndex* pCntnt = &pCrsr->GetMark()->nContent;
		if( pCntnt->GetIndex() )
		{
			*pCntnt = 0;
			bRange = sal_True;
		}
		else
		{
			// dann einen Node zurueckspringen
			SwNodeIndex aNdIdx( pCrsr->GetMark()->nNode, -1 );
			SwTxtNode* pTxtNd = aNdIdx.GetNode().GetTxtNode();
			if( pTxtNd && pTxtNd->GetTxt().Len() )
			{
				pCntnt->Assign( pTxtNd, 0 );
				pCrsr->GetMark()->nNode = aNdIdx;
				bRange = sal_True;
			}
		}

		if( bRange )
		{
			Push();		// Cursor sichern

			SvxSwAutoFmtFlags aAFFlags = *GetAutoFmtFlags();		// erst mal default - Werte

			SwAutoFormat aFmt( this, aAFFlags, &pCrsr->GetMark()->nNode,
									&pCrsr->GetPoint()->nNode );

			//JP 30.09.96: das DoTable() verlaesst sich auf das PopCrsr
			//				und MoveCrsr!
			Pop( sal_False );
			pCrsr = GetCrsr();
		}
		pCrsr->DeleteMark();
		pCrsr->Move( fnMoveForward, fnGoNode );

		EndUndo( UNDO_AUTOFORMAT );
		EndAllAction();
	}
}

SvxSwAutoFmtFlags* SwEditShell::GetAutoFmtFlags()
{
	if (!pAutoFmtFlags)
		pAutoFmtFlags = new SvxSwAutoFmtFlags;

	return pAutoFmtFlags;
}

void SwEditShell::SetAutoFmtFlags(SvxSwAutoFmtFlags * pFlags)
{
	SvxSwAutoFmtFlags* pEditFlags = GetAutoFmtFlags();

	pEditFlags->bSetNumRule		= pFlags->bSetNumRule;
	pEditFlags->bChgEnumNum		= pFlags->bChgEnumNum;
	pEditFlags->bSetBorder		= pFlags->bSetBorder;
	pEditFlags->bCreateTable	= pFlags->bCreateTable;
	pEditFlags->bReplaceStyles	= pFlags->bReplaceStyles;
	pEditFlags->bAFmtByInpDelSpacesAtSttEnd =
									pFlags->bAFmtByInpDelSpacesAtSttEnd;
	pEditFlags->bAFmtByInpDelSpacesBetweenLines =
									pFlags->bAFmtByInpDelSpacesBetweenLines;

	//JP 15.12.98: BulletZeichen und Font in die "normalen" kopieren,
	//			weil beim Autoformat nur mit diesen gearbeitet wird!
	pEditFlags->cBullet				= pFlags->cByInputBullet;
	pEditFlags->aBulletFont			= pFlags->aByInputBulletFont;
	pEditFlags->cByInputBullet		= pFlags->cByInputBullet;
	pEditFlags->aByInputBulletFont	= pFlags->aByInputBulletFont;
}