AOO410/main/cui/source/tabpages/paragrph.cxx

/**************************************************************
 * 
 * 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_cui.hxx"

#include <svl/style.hxx>
#include <sfx2/app.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/module.hxx>
#include <vcl/mnemonic.hxx>
#include <svx/dialogs.hrc>

#define _SVX_PARAGRPH_CXX   0

#include <svl/languageoptions.hxx>
#include <editeng/pgrditem.hxx>
#include <cuires.hrc>
#include "paragrph.hrc"
#include "paragrph.hxx"
#include <editeng/frmdiritem.hxx>
#include <editeng/lspcitem.hxx>
#include <editeng/adjitem.hxx>
#include <editeng/orphitem.hxx>
#include <editeng/widwitem.hxx>
#include <editeng/tstpitem.hxx>
#include <editeng/pmdlitem.hxx>
#include <editeng/spltitem.hxx>
#include <editeng/hyznitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/brkitem.hxx>
#include <editeng/keepitem.hxx>
#include "svx/dlgutil.hxx"
#include <dialmgr.hxx>
#include "svx/htmlmode.hxx"
#include <editeng/paravertalignitem.hxx>
#include <svl/eitem.hxx> //add CHINA001
#include <sfx2/request.hxx> //add CHINA001
#include <svl/intitem.hxx> //add CHINA001

// static ----------------------------------------------------------------

static sal_uInt16 pStdRanges[] =
{
	SID_ATTR_PARA_LINESPACE,		// 10033
	SID_ATTR_PARA_LINESPACE,
	SID_ATTR_LRSPACE,				// 10048 -
	SID_ATTR_ULSPACE,				// 10049
	SID_ATTR_PARA_REGISTER,			// 10413
	SID_ATTR_PARA_REGISTER,
	0
};

static sal_uInt16 pAlignRanges[] =
{
	SID_ATTR_PARA_ADJUST,			// 10027
	SID_ATTR_PARA_ADJUST,
	0
};

static sal_uInt16 pExtRanges[] =
{
	SID_ATTR_PARA_PAGEBREAK,		// 10037 -
	SID_ATTR_PARA_WIDOWS,			// 10041
	SID_ATTR_PARA_MODEL,			// 10065 -
	SID_ATTR_PARA_KEEP,				// 10066
	0
};

// define ----------------------------------------------------------------

#define MAX_DURCH 5670      // 10 cm ist sinnvoll als maximaler Durchschuss
							// laut BP
#define FIX_DIST_DEF 283    // Standard-Fix-Abstand 0,5cm

// enum ------------------------------------------------------------------

enum LineSpaceList
{
	LLINESPACE_1    = 0,
	LLINESPACE_15   = 1,
	LLINESPACE_2    = 2,
	LLINESPACE_PROP = 3,
	LLINESPACE_MIN  = 4,
	LLINESPACE_DURCH= 5,
	LLINESPACE_FIX 	= 6,
	LLINESPACE_END
};

// C-Funktion ------------------------------------------------------------

void SetLineSpace_Impl( SvxLineSpacingItem&, int, long lValue = 0 );

void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace,
						int eSpace, long lValue )
{
	switch ( eSpace )
	{
		case LLINESPACE_1:
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
			rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
			break;

		case LLINESPACE_15:
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
			rLineSpace.SetPropLineSpace( 150 );
			break;

		case LLINESPACE_2:
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
			rLineSpace.SetPropLineSpace( 200 );
			break;

		case LLINESPACE_PROP:
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
			rLineSpace.SetPropLineSpace( (sal_uInt8)lValue );
			break;

		case LLINESPACE_MIN:
			rLineSpace.SetLineHeight( (sal_uInt16)lValue );
			rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
			break;

		case LLINESPACE_DURCH:
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
			rLineSpace.SetInterLineSpace( (sal_uInt16)lValue );
			break;

		case LLINESPACE_FIX:
			rLineSpace.SetLineHeight((sal_uInt16)lValue);
			rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_FIX;
			rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
		break;
	}
}


sal_uInt16 GetHtmlMode_Impl(const SfxItemSet& rSet)
{
	sal_uInt16 nHtmlMode = 0;
	const SfxPoolItem* pItem = 0;
	SfxObjectShell* pShell;
	if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem) ||
		( 0 != (pShell = SfxObjectShell::Current()) &&
					0 != (pItem = pShell->GetItem(SID_HTML_MODE))))
	{
		nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
	}
	return nHtmlMode;

}

// class SvxStdParagraphTabPage ------------------------------------------

IMPL_LINK( SvxStdParagraphTabPage, ELRLoseFocusHdl, Edit *, EMPTYARG )
{
//! if ( aLeftIndent.IsRelativeMode() )
//! 	return 0; //!!!

	SfxItemPool* pPool = GetItemSet().GetPool();
	DBG_ASSERT( pPool, "Wo ist der Pool" );
	FieldUnit eUnit =
		MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );

	sal_Int64 nL = aLeftIndent.Denormalize( aLeftIndent.GetValue( eUnit ) );
	sal_Int64 nR = aRightIndent.Denormalize( aRightIndent.GetValue( eUnit ) );
	String aTmp = aFLineIndent.GetText();

	// Erstzeilen Einzug
    if( aLeftIndent.GetMin() < 0 )
		aFLineIndent.SetMin( -99999, FUNIT_MM );
	else
		aFLineIndent.SetMin( aFLineIndent.Normalize( -nL ), eUnit );

	// Check nur fuer konkrete Breite (Shell)
	sal_Int64 nTmp = nWidth - nL - nR - MM50;
	aFLineIndent.SetMax( aFLineIndent.Normalize( nTmp ), eUnit );

	if ( !aTmp.Len() )
		aFLineIndent.SetEmptyFieldValue();
	// Maximum Links Rechts
	aTmp = aLeftIndent.GetText();
	nTmp = nWidth - nR - MM50;
	aLeftIndent.SetMax( aLeftIndent.Normalize( nTmp ), eUnit );

	if ( !aTmp.Len() )
		aLeftIndent.SetEmptyFieldValue();
	aTmp = aRightIndent.GetText();
	nTmp = nWidth - nL - MM50;
	aRightIndent.SetMax( aRightIndent.Normalize( nTmp ), eUnit );

	if ( !aTmp.Len() )
		aRightIndent.SetEmptyFieldValue();
	return 0;
}

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

SfxTabPage* SvxStdParagraphTabPage::Create( Window* pParent,
											const SfxItemSet& rSet)
{
	return new SvxStdParagraphTabPage( pParent, rSet );
}

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

sal_Bool SvxStdParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
{
	SfxItemState eState = SFX_ITEM_UNKNOWN;
	const SfxPoolItem* pOld = 0;
	SfxItemPool* pPool = rOutSet.GetPool();
	DBG_ASSERT( pPool, "Wo ist der Pool" );

	sal_Bool bModified = sal_False;
	sal_uInt16 nWhich;
	sal_uInt16 nPos = aLineDist.GetSelectEntryPos();

	if ( LISTBOX_ENTRY_NOTFOUND != nPos &&
		 ( nPos != aLineDist.GetSavedValue() ||
		   aLineDistAtPercentBox.IsValueModified() ||
		   aLineDistAtMetricBox.IsValueModified() ) )
	{
		nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
		SfxMapUnit eUnit = pPool->GetMetric( nWhich );
		SvxLineSpacingItem aSpacing(
			(const SvxLineSpacingItem&)GetItemSet().Get( nWhich ) );

		switch ( nPos )
		{
			case LLINESPACE_1:
			case LLINESPACE_15:
			case LLINESPACE_2:
				SetLineSpace_Impl( aSpacing, nPos );
				break;

			case LLINESPACE_PROP:
				SetLineSpace_Impl( aSpacing, nPos,
								   static_cast<long>(aLineDistAtPercentBox.Denormalize(
								   aLineDistAtPercentBox.GetValue() )) );
				break;

			case LLINESPACE_MIN:
			case LLINESPACE_DURCH:
			case LLINESPACE_FIX:
				SetLineSpace_Impl( aSpacing, nPos,
					GetCoreValue( aLineDistAtMetricBox, eUnit ) );
			break;

			default:
				DBG_ERROR( "unbekannter Type fuer Zeilenabstand." );
				break;
		}
		eState = GetItemSet().GetItemState( nWhich );
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_LINESPACE );

		if ( !pOld || !( *(const SvxLineSpacingItem*)pOld == aSpacing ) ||
			 SFX_ITEM_DONTCARE == eState )
		{
			rOutSet.Put( aSpacing );
			bModified |= sal_True;
		}
	}

	if ( aTopDist.IsValueModified() || aBottomDist.IsValueModified() )
	{
		nWhich = GetWhich( SID_ATTR_ULSPACE );
		SfxMapUnit eUnit = pPool->GetMetric( nWhich );
		pOld = GetOldItem( rOutSet, SID_ATTR_ULSPACE );
		SvxULSpaceItem aMargin( nWhich );

		if ( bRelativeMode )
		{
			DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );

			const SvxULSpaceItem& rOldItem =
				(const SvxULSpaceItem&)GetItemSet().GetParent()->Get( nWhich );

			if ( aTopDist.IsRelative() )
				aMargin.SetUpper( rOldItem.GetUpper(),
								  (sal_uInt16)aTopDist.GetValue() );
			else
				aMargin.SetUpper( (sal_uInt16)GetCoreValue( aTopDist, eUnit ) );

			if ( aBottomDist.IsRelative() )
				aMargin.SetLower( rOldItem.GetLower(),
								  (sal_uInt16)aBottomDist.GetValue() );
			else
				aMargin.SetLower( (sal_uInt16)GetCoreValue( aBottomDist, eUnit ) );

		}
		else
		{
			aMargin.SetUpper( (sal_uInt16)GetCoreValue( aTopDist, eUnit ) );
			aMargin.SetLower( (sal_uInt16)GetCoreValue( aBottomDist, eUnit ) );
		}
		eState = GetItemSet().GetItemState( nWhich );

		if ( !pOld || !( *(const SvxULSpaceItem*)pOld == aMargin ) ||
			 SFX_ITEM_DONTCARE == eState )
		{
			rOutSet.Put( aMargin );
			bModified |= sal_True;
		}
	}
	FASTBOOL bNullTab = sal_False;

	if ( aLeftIndent.IsValueModified() ||
		 aFLineIndent.IsValueModified() ||
		 aRightIndent.IsValueModified()
		 ||	 aAutoCB.GetSavedValue() != aAutoCB.IsChecked() )
	{
		nWhich = GetWhich( SID_ATTR_LRSPACE );
		SfxMapUnit eUnit = pPool->GetMetric( nWhich );
		SvxLRSpaceItem aMargin( nWhich );
		pOld = GetOldItem( rOutSet, SID_ATTR_LRSPACE );

		if ( bRelativeMode )
		{
			DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );

			const SvxLRSpaceItem& rOldItem =
				(const SvxLRSpaceItem&)GetItemSet().GetParent()->Get( nWhich );

			if ( aLeftIndent.IsRelative() )
				aMargin.SetTxtLeft( rOldItem.GetTxtLeft(),
									(sal_uInt16)aLeftIndent.GetValue() );
			else
				aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );

			if ( aRightIndent.IsRelative() )
				aMargin.SetRight( rOldItem.GetRight(),
								  (sal_uInt16)aRightIndent.GetValue() );
			else
				aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );

			if ( aFLineIndent.IsRelative() )
				aMargin.SetTxtFirstLineOfst( rOldItem.GetTxtFirstLineOfst(),
											 (sal_uInt16)aFLineIndent.GetValue() );
			else
				aMargin.SetTxtFirstLineOfst(
					(sal_uInt16)GetCoreValue( aFLineIndent, eUnit ) );
		}
		else
		{
			aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );
			aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );
			aMargin.SetTxtFirstLineOfst(
				(sal_uInt16)GetCoreValue( aFLineIndent, eUnit ) );
		}
		aMargin.SetAutoFirst(aAutoCB.IsChecked());
		if ( aMargin.GetTxtFirstLineOfst() < 0 )
			bNullTab = sal_True;
		eState = GetItemSet().GetItemState( nWhich );

		if ( !pOld || !( *(const SvxLRSpaceItem*)pOld == aMargin ) ||
			 SFX_ITEM_DONTCARE == eState )
		{
			rOutSet.Put( aMargin );
			bModified |= sal_True;
		}
	}

	if ( bNullTab )
	{
		MapUnit eUnit = (MapUnit)pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) );
		if ( MAP_100TH_MM != eUnit )
		{

			// negativer Erstzeileneinzug -> ggf. Null Default-Tabstop setzen
            sal_uInt16 _nWhich = GetWhich( SID_ATTR_TABSTOP );
			const SfxItemSet& rInSet = GetItemSet();

            if ( rInSet.GetItemState( _nWhich ) >= SFX_ITEM_AVAILABLE )
			{
				const SvxTabStopItem& rTabItem =
                    (const SvxTabStopItem&)rInSet.Get( _nWhich );
				SvxTabStopItem aNullTab( rTabItem );
				SvxTabStop aNull( 0, SVX_TAB_ADJUST_DEFAULT );
				aNullTab.Insert( aNull );
				rOutSet.Put( aNullTab );
			}
		}
	}
	if( aRegisterCB.IsVisible())
	{
		const SfxBoolItem* pBoolItem = (SfxBoolItem*)GetOldItem(
							rOutSet, SID_ATTR_PARA_REGISTER);
		SfxBoolItem* pRegItem = (SfxBoolItem*)pBoolItem->Clone();
        sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
		sal_Bool bSet = pRegItem->GetValue();

		if(aRegisterCB.IsChecked() != bSet )
		{
			pRegItem->SetValue(!bSet);
			rOutSet.Put(*pRegItem);
			bModified |= sal_True;
		}
        else if ( SFX_ITEM_DEFAULT == GetItemSet().GetItemState( _nWhich, sal_False ) )
            rOutSet.ClearItem(_nWhich);
		delete pRegItem;
	}

	return bModified;
}

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

void SvxStdParagraphTabPage::Reset( const SfxItemSet& rSet )
{
	SfxItemPool* pPool = rSet.GetPool();
	DBG_ASSERT( pPool, "Wo ist der Pool?" );
	String aEmpty;

	// Metrik einstellen
	FieldUnit eFUnit = GetModuleFieldUnit( rSet );
	SetFieldUnit( aLeftIndent, eFUnit );
	SetFieldUnit( aRightIndent, eFUnit );
	SetFieldUnit( aFLineIndent, eFUnit );
	SetFieldUnit( aTopDist, eFUnit );
	SetFieldUnit( aBottomDist, eFUnit );
	SetFieldUnit( aLineDistAtMetricBox, eFUnit );

    sal_uInt16 _nWhich = GetWhich( SID_ATTR_LRSPACE );
    SfxItemState eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
	{
        SfxMapUnit eUnit = pPool->GetMetric( _nWhich );

		if ( bRelativeMode )
		{
			const SvxLRSpaceItem& rOldItem =
                (const SvxLRSpaceItem&)rSet.Get( _nWhich );

			if ( rOldItem.GetPropLeft() != 100 )
			{
				aLeftIndent.SetRelative( sal_True );
				aLeftIndent.SetValue( rOldItem.GetPropLeft() );
			}
			else
			{
				aLeftIndent.SetRelative();
				SetFieldUnit( aLeftIndent, eFUnit );
				SetMetricValue( aLeftIndent, rOldItem.GetTxtLeft(), eUnit );
            }

			if ( rOldItem.GetPropRight() != 100 )
			{
				aRightIndent.SetRelative( sal_True );
				aRightIndent.SetValue( rOldItem.GetPropRight() );
			}
			else
			{
				aRightIndent.SetRelative();
				SetFieldUnit( aRightIndent, eFUnit );
				SetMetricValue( aRightIndent, rOldItem.GetRight(), eUnit );
			}

			if ( rOldItem.GetPropTxtFirstLineOfst() != 100 )
			{
				aFLineIndent.SetRelative( sal_True );
				aFLineIndent.SetValue( rOldItem.GetPropTxtFirstLineOfst() );
			}
			else
			{
				aFLineIndent.SetRelative();
                aFLineIndent.SetMin(-9999);
				SetFieldUnit( aFLineIndent, eFUnit );
				SetMetricValue( aFLineIndent, rOldItem.GetTxtFirstLineOfst(),
								eUnit );
			}
			aAutoCB.Check(rOldItem.IsAutoFirst());
		}
		else
		{
			const SvxLRSpaceItem& rSpace =
                (const SvxLRSpaceItem&)rSet.Get( _nWhich );

			SetMetricValue( aLeftIndent, rSpace.GetTxtLeft(), eUnit );
			SetMetricValue( aRightIndent, rSpace.GetRight(), eUnit );
			SetMetricValue( aFLineIndent, rSpace.GetTxtFirstLineOfst(), eUnit );
			aAutoCB.Check(rSpace.IsAutoFirst());
		}
		AutoHdl_Impl(&aAutoCB);
	}
	else
	{
		aLeftIndent.SetEmptyFieldValue();
		aRightIndent.SetEmptyFieldValue();
		aFLineIndent.SetEmptyFieldValue();
	}

    _nWhich = GetWhich( SID_ATTR_ULSPACE );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
	{
        SfxMapUnit eUnit = pPool->GetMetric( _nWhich );

		if ( bRelativeMode )
		{
			const SvxULSpaceItem& rOldItem =
                (const SvxULSpaceItem&)rSet.Get( _nWhich );

			if ( rOldItem.GetPropUpper() != 100 )
			{
				aTopDist.SetRelative( sal_True );
				aTopDist.SetValue( rOldItem.GetPropUpper() );
			}
			else
			{
				aTopDist.SetRelative();
				SetFieldUnit( aTopDist, eFUnit );
				SetMetricValue( aTopDist, rOldItem.GetUpper(), eUnit );
			}

			if ( rOldItem.GetPropLower() != 100 )
			{
				aBottomDist.SetRelative( sal_True );
				aBottomDist.SetValue( rOldItem.GetPropLower() );
			}
			else
			{
				aBottomDist.SetRelative();
				SetFieldUnit( aBottomDist, eFUnit );
				SetMetricValue( aBottomDist, rOldItem.GetLower(), eUnit );
			}
		}
		else
		{
			const SvxULSpaceItem& rTopMargin =
                (const SvxULSpaceItem&)rSet.Get( _nWhich );
			SetMetricValue( aTopDist, rTopMargin.GetUpper(), eUnit );
			SetMetricValue( aBottomDist, rTopMargin.GetLower(), eUnit );
		}
	}
	else
	{
		aTopDist.SetEmptyFieldValue();
		aBottomDist.SetEmptyFieldValue();
	}

    _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
        SetLineSpacing_Impl( (const SvxLineSpacingItem &)rSet.Get( _nWhich ) );
	else
		aLineDist.SetNoSelection();


    _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
        aRegisterCB.Check( ((const SfxBoolItem &)rSet.Get( _nWhich )).GetValue());
	aRegisterCB.SaveValue();
	sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
	if(nHtmlMode & HTMLMODE_ON)
	{
		aRegisterCB.Hide();
        aRegisterFL.Hide();
		aAutoCB.Hide();
		if(!(nHtmlMode & HTMLMODE_SOME_STYLES)) // IE oder SW
		{
			aRightLabel.Disable();
			aRightIndent.Disable();
			aTopDist.Disable();  //HTML3.2 und NS 3.0
			aBottomDist.Disable();
			if(!(nHtmlMode & HTMLMODE_FIRSTLINE)) //NS 3.0
			{
				aFLineIndent.Disable();
				aFLineLabel.Disable();
			}
		}
	}

	ELRLoseFocusHdl( NULL );
	aAutoCB.SaveValue();
	aLineDist.SaveValue();
}

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

void SvxStdParagraphTabPage::EnableRelativeMode()
{
	DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" );

	aLeftIndent.EnableRelativeMode( 0, 999 );
	aFLineIndent.EnableRelativeMode( 0, 999 );
	aRightIndent.EnableRelativeMode( 0, 999 );
	aTopDist.EnableRelativeMode( 0, 999 );
	aBottomDist.EnableRelativeMode( 0, 999 );
	bRelativeMode = sal_True;
}

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

int SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
{
	ELRLoseFocusHdl( NULL );

    if ( _pSet )
        FillItemSet( *_pSet );
	return LEAVE_PAGE;
}

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

SvxStdParagraphTabPage::SvxStdParagraphTabPage( Window* pParent,
												const SfxItemSet& rAttr ) :

	SfxTabPage( pParent, CUI_RES( RID_SVXPAGE_STD_PARAGRAPH ), rAttr ),

    aIndentFrm              ( this, CUI_RES( FL_INDENT ) ),
	aLeftLabel              ( this, CUI_RES( FT_LEFTINDENT ) ),
	aLeftIndent             ( this, CUI_RES( ED_LEFTINDENT ) ),
    aRightLabel             ( this, CUI_RES( FT_RIGHTINDENT ) ),
    aRightIndent            ( this, CUI_RES( ED_RIGHTINDENT ) ),
    
    aFLineLabel             ( this, CUI_RES( FT_FLINEINDENT ) ),
	aFLineIndent            ( this, CUI_RES( ED_FLINEINDENT ) ),
	aAutoCB                 ( this, CUI_RES( CB_AUTO ) ),
    aDistFrm                ( this, CUI_RES( FL_DIST ) ),
	aTopLabel               ( this, CUI_RES( FT_TOPDIST ) ),
	aTopDist                ( this, CUI_RES( ED_TOPDIST ) ),
	aBottomLabel            ( this, CUI_RES( FT_BOTTOMDIST ) ),
	aBottomDist             ( this, CUI_RES( ED_BOTTOMDIST ) ),

    aLineDistFrm            ( this, CUI_RES( FL_LINEDIST ) ),
	aLineDist               ( this, CUI_RES( LB_LINEDIST ) ),
	aLineDistAtLabel        ( this, CUI_RES( FT_LINEDIST ) ),
	aLineDistAtPercentBox   ( this, CUI_RES( ED_LINEDISTPERCENT ) ),
	aLineDistAtMetricBox    ( this, CUI_RES( ED_LINEDISTMETRIC ) ),
    sAbsDist                ( CUI_RES(ST_LINEDIST_ABS) ),
    aExampleWin             ( this, CUI_RES( WN_EXAMPLE ) ),
    aRegisterFL             ( this, CUI_RES( FL_REGISTER ) ),
	aRegisterCB             ( this, CUI_RES( CB_REGISTER ) ),
    pActLineDistFld ( &aLineDistAtPercentBox ),
    nAbst           ( MAX_DURCH ),
    nWidth          ( 11905 /*567 * 50*/ ),
    nMinFixDist(0L),

    bRelativeMode   ( sal_False ),
    bNegativeIndents(sal_False)

{
	// diese Page braucht ExchangeSupport
	SetExchangeSupport();

	aLineDistAtMetricBox.Hide();
    FreeResource();
	Init_Impl();
    aFLineIndent.SetMin(-9999);    // wird default auf 0 gesetzt
	
	aExampleWin.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));
	
}


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

void SvxStdParagraphTabPage::EnableNegativeMode()
{
    aLeftIndent.SetMin(-9999);
    aRightIndent.SetMin(-9999);
    aRightIndent.EnableNegativeMode();
    aLeftIndent.EnableNegativeMode();
    bNegativeIndents = sal_True;
}

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

sal_uInt16* SvxStdParagraphTabPage::GetRanges()
{
	return pStdRanges;
}

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

void SvxStdParagraphTabPage::SetLineSpacing_Impl
(
	const SvxLineSpacingItem &rAttr
)
{
	SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );

	switch( rAttr.GetLineSpaceRule() )
	{
		case SVX_LINE_SPACE_AUTO:
		{
			SvxInterLineSpace eInter = rAttr.GetInterLineSpaceRule();

			switch( eInter )
			{
				// Default einzeilig
				case SVX_INTER_LINE_SPACE_OFF:
					aLineDist.SelectEntryPos( LLINESPACE_1 );
					break;

				// Default einzeilig
				case SVX_INTER_LINE_SPACE_PROP:
					if ( 100 == rAttr.GetPropLineSpace() )
					{
						aLineDist.SelectEntryPos( LLINESPACE_1 );
						break;
					}
					// 1.5zeilig
					if ( 150 == rAttr.GetPropLineSpace() )
					{
						aLineDist.SelectEntryPos( LLINESPACE_15 );
						break;
					}
					// 2zeilig
					if ( 200 == rAttr.GetPropLineSpace() )
					{
						aLineDist.SelectEntryPos( LLINESPACE_2 );
						break;
					}
					// eingestellter Prozentwert
					aLineDistAtPercentBox.
						SetValue( aLineDistAtPercentBox.Normalize(
										rAttr.GetPropLineSpace() ) );
					aLineDist.SelectEntryPos( LLINESPACE_PROP );
					break;

				case SVX_INTER_LINE_SPACE_FIX:
					SetMetricValue( aLineDistAtMetricBox,
									rAttr.GetInterLineSpace(), eUnit );
					aLineDist.SelectEntryPos( LLINESPACE_DURCH );
					break;
                default: ;//prevent warning
			}
		}
		break;
		case SVX_LINE_SPACE_FIX:
			SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
			aLineDist.SelectEntryPos( LLINESPACE_FIX );
		break;

		case SVX_LINE_SPACE_MIN:
			SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
			aLineDist.SelectEntryPos( LLINESPACE_MIN );
			break;
        default: ;//prevent warning
	}
	LineDistHdl_Impl( &aLineDist );
}

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

IMPL_LINK( SvxStdParagraphTabPage, LineDistHdl_Impl, ListBox *, pBox )
{
	switch( pBox->GetSelectEntryPos() )
	{
		case LLINESPACE_1:
		case LLINESPACE_15:
		case LLINESPACE_2:
			aLineDistAtLabel.Enable(sal_False);
			pActLineDistFld->Enable(sal_False);
			pActLineDistFld->SetText( String() );
			break;

		case LLINESPACE_DURCH:
			// Setzen eines sinnvollen Defaults?
			// MS Begrenzen min(10, aPageSize)
			aLineDistAtPercentBox.Hide();
			pActLineDistFld = &aLineDistAtMetricBox;
            aLineDistAtMetricBox.SetMin(0);


			if ( !aLineDistAtMetricBox.GetText().Len() )
				aLineDistAtMetricBox.SetValue(
					aLineDistAtMetricBox.Normalize( 1 ) );
			aLineDistAtPercentBox.Hide();
			pActLineDistFld->Show();
			pActLineDistFld->Enable();
			aLineDistAtLabel.Enable();
			break;

		case LLINESPACE_MIN:
			aLineDistAtPercentBox.Hide();
			pActLineDistFld = &aLineDistAtMetricBox;
            aLineDistAtMetricBox.SetMin(0);

			if ( !aLineDistAtMetricBox.GetText().Len() )
				aLineDistAtMetricBox.SetValue(
					aLineDistAtMetricBox.Normalize( 10 ), FUNIT_TWIP );
			aLineDistAtPercentBox.Hide();
			pActLineDistFld->Show();
			pActLineDistFld->Enable();
			aLineDistAtLabel.Enable();
			break;

		case LLINESPACE_PROP:
			aLineDistAtMetricBox.Hide();
			pActLineDistFld = &aLineDistAtPercentBox;

			if ( !aLineDistAtPercentBox.GetText().Len() )
				aLineDistAtPercentBox.SetValue(
					aLineDistAtPercentBox.Normalize( 100 ), FUNIT_TWIP );
			aLineDistAtMetricBox.Hide();
			pActLineDistFld->Show();
			pActLineDistFld->Enable();
			aLineDistAtLabel.Enable();
			break;
		case LLINESPACE_FIX:
		{
			aLineDistAtPercentBox.Hide();
			pActLineDistFld = &aLineDistAtMetricBox;
			sal_Int64 nTemp = aLineDistAtMetricBox.GetValue();
			aLineDistAtMetricBox.SetMin(aLineDistAtMetricBox.Normalize(nMinFixDist), FUNIT_TWIP);

			// wurde der Wert beim SetMin veraendert, dann ist es Zeit
			// fuer den default
			if ( aLineDistAtMetricBox.GetValue() != nTemp )
				SetMetricValue( aLineDistAtMetricBox,
									FIX_DIST_DEF, SFX_MAPUNIT_TWIP ); // fix gibt's nur im Writer
			aLineDistAtPercentBox.Hide();
			pActLineDistFld->Show();
			pActLineDistFld->Enable();
			aLineDistAtLabel.Enable();
		}
		break;
	}
	UpdateExample_Impl( sal_True );
	return 0;
}

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

IMPL_LINK_INLINE_START( SvxStdParagraphTabPage, ModifyHdl_Impl, SvxRelativeField *, EMPTYARG )
{
	UpdateExample_Impl();
	return 0;
}
IMPL_LINK_INLINE_END( SvxStdParagraphTabPage, ModifyHdl_Impl, SvxRelativeField *, EMPTYARG )

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

void SvxStdParagraphTabPage::Init_Impl()
{
	aLineDist.SetSelectHdl(
		LINK( this, SvxStdParagraphTabPage, LineDistHdl_Impl ) );

	Link aLink = LINK( this, SvxStdParagraphTabPage, ELRLoseFocusHdl );
	aFLineIndent.SetLoseFocusHdl( aLink );
	aLeftIndent.SetLoseFocusHdl( aLink );
	aRightIndent.SetLoseFocusHdl( aLink );

	aLink = LINK( this, SvxStdParagraphTabPage, ModifyHdl_Impl );
	aFLineIndent.SetModifyHdl( aLink );
	aLeftIndent.SetModifyHdl( aLink );
	aRightIndent.SetModifyHdl( aLink );
	aTopDist.SetModifyHdl( aLink );
	aBottomDist.SetModifyHdl( aLink );

	aAutoCB.SetClickHdl( LINK( this, SvxStdParagraphTabPage, AutoHdl_Impl ));
	SfxItemPool* pPool = GetItemSet().GetPool();
	DBG_ASSERT( pPool, "Wo ist der Pool" );
	FieldUnit eUnit =
		MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );

	aTopDist.SetMax( aTopDist.Normalize( nAbst ), eUnit );
	aBottomDist.SetMax( aBottomDist.Normalize( nAbst ), eUnit );
	aLineDistAtMetricBox.SetMax(
		aLineDistAtMetricBox.Normalize( nAbst ), eUnit );
}

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

void SvxStdParagraphTabPage::UpdateExample_Impl( sal_Bool bAll )
{
	aExampleWin.SetFirstLineOfst(
		(short)aFLineIndent.Denormalize( aFLineIndent.GetValue( FUNIT_TWIP ) ) );
	aExampleWin.SetLeftMargin(
		static_cast<long>(aLeftIndent.Denormalize( aLeftIndent.GetValue( FUNIT_TWIP ) ) ) );
	aExampleWin.SetRightMargin(
		static_cast<long>(aRightIndent.Denormalize( aRightIndent.GetValue( FUNIT_TWIP ) ) ) );
	aExampleWin.SetUpper(
		(sal_uInt16)aTopDist.Denormalize( aTopDist.GetValue( FUNIT_TWIP ) ) );
	aExampleWin.SetLower(
		(sal_uInt16)aBottomDist.Denormalize( aBottomDist.GetValue( FUNIT_TWIP ) ) );



	sal_uInt16 nPos = aLineDist.GetSelectEntryPos();

	switch ( nPos )
	{
		case LLINESPACE_1:
		case LLINESPACE_15:
		case LLINESPACE_2:
			aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos );
			break;

		case LLINESPACE_PROP:
			aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
				(sal_uInt16)aLineDistAtPercentBox.Denormalize(
				aLineDistAtPercentBox.GetValue() ) );
			break;

		case LLINESPACE_MIN:
		case LLINESPACE_DURCH:
		case LLINESPACE_FIX:
			aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
				(sal_uInt16)GetCoreValue( aLineDistAtMetricBox, SFX_MAPUNIT_TWIP ) );
			break;
	}
	aExampleWin.Draw( bAll );
}

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

void SvxStdParagraphTabPage::EnableRegisterMode()
{
	aRegisterCB.Show();
    aRegisterFL.Show();
}

/*-----------------16.01.97 19.54-------------------

--------------------------------------------------*/
IMPL_LINK( SvxStdParagraphTabPage, AutoHdl_Impl, CheckBox*, pBox )
{
	sal_Bool bEnable = !pBox->IsChecked();
	aFLineLabel .Enable(bEnable);
	aFLineIndent.Enable(bEnable);
	return 0;
}

/*-----------------16.01.97 18.00-------------------

--------------------------------------------------*/
void SvxStdParagraphTabPage::SetPageWidth( sal_uInt16 nPageWidth )
{
	nWidth = nPageWidth;
}

/*-----------------17.01.97 08.11-------------------

--------------------------------------------------*/
void SvxStdParagraphTabPage::EnableAutoFirstLine()
{
	aAutoCB.Show();
}

/*-----------------11.06.97 11.48-------------------
	absoluter Zeilenabstand
--------------------------------------------------*/
void	SvxStdParagraphTabPage::EnableAbsLineDist(long nMinTwip)
{
	aLineDist.InsertEntry(sAbsDist);
	nMinFixDist = nMinTwip;
}

//addd CHINA001 begin
void	SvxStdParagraphTabPage::PageCreated(SfxAllItemSet aSet)
{

/* CHINA001 different bit represent call to different method of SvxStdParagraphTabPage
						0x0001 --->EnableRelativeMode()
						0x0002 --->EnableRegisterMode()
						0x0004 --->EnableAutoFirstLine()
						0x0008 --->EnableNegativeMode()


			*/
	SFX_ITEMSET_ARG	(&aSet,pPageWidthItem,SfxUInt16Item,SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH,sal_False);
	SFX_ITEMSET_ARG	(&aSet,pFlagSetItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET,sal_False);
	SFX_ITEMSET_ARG	(&aSet,pLineDistItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST,sal_False);

	if (pPageWidthItem)
		SetPageWidth(pPageWidthItem->GetValue());

	if (pFlagSetItem )
		if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
			EnableRelativeMode();

	if (pFlagSetItem)
		if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
				EnableRegisterMode();

	if (pFlagSetItem)
		if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
			EnableAutoFirstLine();

	if(pLineDistItem)
		EnableAbsLineDist(pLineDistItem->GetValue());

	if (pFlagSetItem)
		if	(( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
				EnableNegativeMode();

}
//end of CHINA001

#define LASTLINEPOS_DEFAULT		0
#define LASTLINEPOS_LEFT		1

#define LASTLINECOUNT_OLD		3
#define LASTLINECOUNT_NEW		4

// class SvxParaAlignTabPage ------------------------------------------------

/*-----------------16.01.97 19.34-------------------

--------------------------------------------------*/
SvxParaAlignTabPage::SvxParaAlignTabPage( Window* pParent, const SfxItemSet& rSet )
	: SfxTabPage(pParent, CUI_RES( RID_SVXPAGE_ALIGN_PARAGRAPH ),rSet),
    aAlignFrm           ( this, CUI_RES( FL_ALIGN ) ),
    aLeft               ( this, CUI_RES( BTN_LEFTALIGN ) ),
	aRight				( this, CUI_RES( BTN_RIGHTALIGN ) ),
	aCenter				( this, CUI_RES( BTN_CENTERALIGN ) ),
	aJustify			( this, CUI_RES( BTN_JUSTIFYALIGN ) ),
    aLastLineFT         ( this, CUI_RES( FT_LASTLINE ) ),
	aLastLineLB			( this, CUI_RES( LB_LASTLINE ) ),
	aExpandCB			( this, CUI_RES( CB_EXPAND ) ),
	aSnapToGridCB		( this, CUI_RES( CB_SNAP ) ),
	aExampleWin			( this, CUI_RES( WN_EXAMPLE ) ),

	aVertAlignFL		( this, CUI_RES( FL_VERTALIGN ) ),
	aVertAlignFT		( this, CUI_RES( FT_VERTALIGN ) ),
	aVertAlignLB		( this, CUI_RES( LB_VERTALIGN ) ),

	aPropertiesFL		( this, CUI_RES( FL_PROPERTIES    )),
	aTextDirectionFT	( this, CUI_RES( FT_TEXTDIRECTION )),
	aTextDirectionLB	( this, CUI_RES( LB_TEXTDIRECTION ))
{
	SvtLanguageOptions aLangOptions;
	sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT;

    if ( aLangOptions.IsAsianTypographyEnabled() )
	{
		String sLeft(CUI_RES(ST_LEFTALIGN_ASIAN));
		aLeft.SetText(sLeft);
		aRight.SetText(String(CUI_RES(ST_RIGHTALIGN_ASIAN)));
		sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );

		if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_OLD )
		{
			aLastLineLB.RemoveEntry( 0 );
			aLastLineLB.InsertEntry( sLeft, 0 );
		}
		else
			nLastLinePos = LASTLINEPOS_LEFT;
	}
	// remove "Default" or "Left" entry, depends on CJKOptions
	if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_NEW )
		aLastLineLB.RemoveEntry( nLastLinePos );

	FreeResource();
	Link aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
	aLeft.SetClickHdl( aLink );
	aRight.SetClickHdl( aLink );
	aCenter.SetClickHdl( aLink );
	aJustify.SetClickHdl( aLink );
	aLastLineLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, LastLineHdl_Impl ) );
	aTextDirectionLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, TextDirectionHdl_Impl ) );

    sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
    if(!(nHtmlMode & HTMLMODE_ON) || (0 != (nHtmlMode & HTMLMODE_SOME_STYLES)) )
    {
        if( aLangOptions.IsCTLFontEnabled() )
        {
            aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_LTR ), FRMDIR_HORI_LEFT_TOP );
            aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_RTL ), FRMDIR_HORI_RIGHT_TOP );
            aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_SUPER ), FRMDIR_ENVIRONMENT );

            aPropertiesFL.Show();
            aTextDirectionFT.Show();
            aTextDirectionLB.Show();
        }
    }

	aExampleWin.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));
	
}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
SvxParaAlignTabPage::~SvxParaAlignTabPage()
{
}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
int SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
{
    if ( _pSet )
        FillItemSet( *_pSet );
	return LEAVE_PAGE;
}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
SfxTabPage*	SvxParaAlignTabPage::Create( Window* pParent, const SfxItemSet& rSet )
{
	return new SvxParaAlignTabPage(pParent, rSet);
}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
sal_uInt16*	SvxParaAlignTabPage::GetRanges()
{
	return pAlignRanges;

}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
sal_Bool SvxParaAlignTabPage::FillItemSet( SfxItemSet& rOutSet )
{
	sal_Bool bModified = sal_False;

	FASTBOOL bAdj = sal_False, bChecked = sal_False;
	SvxAdjust eAdjust = SVX_ADJUST_LEFT;

	if ( aLeft.IsChecked() )
	{
		eAdjust = SVX_ADJUST_LEFT;
		bAdj = !aLeft.GetSavedValue();
		bChecked = sal_True;
	}
	else if ( aRight.IsChecked() )
	{
		eAdjust = SVX_ADJUST_RIGHT;
		bAdj = !aRight.GetSavedValue();
		bChecked = sal_True;
	}
	else if ( aCenter.IsChecked() )
	{
		eAdjust = SVX_ADJUST_CENTER;
		bAdj = !aCenter.GetSavedValue();
		bChecked = sal_True;
	}
	else if ( aJustify.IsChecked() )
	{
		eAdjust = SVX_ADJUST_BLOCK;
		bAdj = !aJustify.GetSavedValue() ||
			aExpandCB.IsChecked() != aExpandCB.GetSavedValue() ||
			aLastLineLB.GetSelectEntryPos() != aLastLineLB.GetSavedValue();
		bChecked = sal_True;
	}
    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );

	if ( bAdj )
	{
		const SvxAdjustItem* pOld =
			(const SvxAdjustItem*)GetOldItem( rOutSet, SID_ATTR_PARA_ADJUST );
		SvxAdjust eOneWord = aExpandCB.IsChecked() ? SVX_ADJUST_BLOCK
												   : SVX_ADJUST_LEFT;
		sal_uInt16 nLBPos = aLastLineLB.GetSelectEntryPos();
		SvxAdjust eLastBlock = SVX_ADJUST_LEFT;

		if ( 1 == nLBPos )
			eLastBlock = SVX_ADJUST_CENTER;
		else if ( 2 == nLBPos )
			eLastBlock = SVX_ADJUST_BLOCK;

		FASTBOOL bNothingWasChecked =
			!aLeft.GetSavedValue() && !aRight.GetSavedValue() &&
			!aCenter.GetSavedValue() && !aJustify.GetSavedValue();

		if ( !pOld || pOld->GetAdjust() != eAdjust ||
			 pOld->GetOneWord() != eOneWord ||
			 pOld->GetLastBlock() != eLastBlock ||
			 ( bChecked && bNothingWasChecked ) )
		{
			bModified |= sal_True;
			SvxAdjustItem aAdj(
                (const SvxAdjustItem&)GetItemSet().Get( _nWhich ) );
			aAdj.SetAdjust( eAdjust );
			aAdj.SetOneWord( eOneWord );
			aAdj.SetLastBlock( eLastBlock );
			rOutSet.Put( aAdj );
		}
	}
    if(aSnapToGridCB.IsChecked() != aSnapToGridCB.GetSavedValue())
    {
        rOutSet.Put(SvxParaGridItem(aSnapToGridCB.IsChecked(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
        bModified = sal_True;
    }
    if(aVertAlignLB.GetSavedValue() != aVertAlignLB.GetSelectEntryPos())
    {
        rOutSet.Put(SvxParaVertAlignItem(aVertAlignLB.GetSelectEntryPos(), GetWhich( SID_PARA_VERTALIGN )));
        bModified = sal_True;
    }

    if( aTextDirectionLB.IsVisible() )
	{
        SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
        if( eDir != aTextDirectionLB.GetSavedValue() )
		{
            rOutSet.Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
			bModified = sal_True;
		}
	}

    return bModified;
}

/*-----------------16.01.97 19.33-------------------

--------------------------------------------------*/
void SvxParaAlignTabPage::Reset( const SfxItemSet& rSet )
{
    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
    SfxItemState eItemState = rSet.GetItemState( _nWhich );

	sal_uInt16 nLBSelect = 0;
	if ( eItemState >= SFX_ITEM_AVAILABLE )
	{
        const SvxAdjustItem& rAdj = (const SvxAdjustItem&)rSet.Get( _nWhich );

		switch ( rAdj.GetAdjust() /*!!! VB fragen rAdj.GetLastBlock()*/ )
		{
			case SVX_ADJUST_LEFT: aLeft.Check(); break;

			case SVX_ADJUST_RIGHT: aRight.Check(); break;

			case SVX_ADJUST_CENTER: aCenter.Check(); break;

			case SVX_ADJUST_BLOCK: aJustify.Check(); break;
            default: ; //prevent warning
		}
		sal_Bool bEnable = aJustify.IsChecked();
		aLastLineFT.Enable(bEnable);
		aLastLineLB.Enable(bEnable);
		aExpandCB  .Enable(bEnable);

		aExpandCB.Check(SVX_ADJUST_BLOCK == rAdj.GetOneWord());
		switch(rAdj.GetLastBlock())
		{
			case SVX_ADJUST_LEFT:  nLBSelect = 0; break;

			case SVX_ADJUST_CENTER: nLBSelect = 1;  break;

			case SVX_ADJUST_BLOCK: nLBSelect = 2;  break;
            default: ; //prevent warning
		}
	}
	else
	{
		aLeft.Check( sal_False );
		aRight.Check( sal_False );
		aCenter.Check( sal_False );
		aJustify.Check( sal_False );
	}
	aLastLineLB.SelectEntryPos(nLBSelect);

	sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
	if(nHtmlMode & HTMLMODE_ON)
	{
		aLastLineLB.Hide();
		aLastLineFT.Hide();
		aExpandCB.Hide();
		if(!(nHtmlMode & (HTMLMODE_FULL_STYLES|HTMLMODE_FIRSTLINE)) )
			aJustify.Disable();
        aSnapToGridCB.Show(sal_False);
	}
    _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
    eItemState = rSet.GetItemState( _nWhich );
    if ( eItemState >= SFX_ITEM_AVAILABLE )
    {
        const SvxParaGridItem& rSnap = (const SvxParaGridItem&)rSet.Get( _nWhich );
        aSnapToGridCB.Check(rSnap.GetValue());
    }

    _nWhich = GetWhich( SID_PARA_VERTALIGN );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
    {
        aVertAlignLB.Show();
        aVertAlignFL.Show();
        aVertAlignFT.Show();

        const SvxParaVertAlignItem& rAlign = (const SvxParaVertAlignItem&)rSet.Get( _nWhich );
        aVertAlignLB.SelectEntryPos(rAlign.GetValue());
    }

    _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
    //text direction
    if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( _nWhich ) )
	{
        const SvxFrameDirectionItem& rFrameDirItem = ( const SvxFrameDirectionItem& ) rSet.Get( _nWhich );
        aTextDirectionLB.SelectEntryValue( (SvxFrameDirection)rFrameDirItem.GetValue() );
        aTextDirectionLB.SaveValue();
	}

    aSnapToGridCB.SaveValue();
    aVertAlignLB.SaveValue();
    aLeft.SaveValue();
	aRight.SaveValue();
	aCenter.SaveValue();
	aJustify.SaveValue();
	aLastLineLB.SaveValue();
	aExpandCB.SaveValue();

	UpdateExample_Impl(sal_True);
}

/*-----------------17.01.97 08.06-------------------

--------------------------------------------------*/
IMPL_LINK( SvxParaAlignTabPage, AlignHdl_Impl, RadioButton*, EMPTYARG )
{
	sal_Bool bJustify = aJustify.IsChecked();
	aLastLineFT.Enable(bJustify);
	aLastLineLB.Enable(bJustify);
	aExpandCB.Enable(bJustify);
	UpdateExample_Impl(sal_False);
	return 0;
}

IMPL_LINK( SvxParaAlignTabPage, LastLineHdl_Impl, ListBox*, EMPTYARG )
{
	UpdateExample_Impl(sal_False);
	return 0;
}

IMPL_LINK( SvxParaAlignTabPage, TextDirectionHdl_Impl, ListBox*, EMPTYARG )
{
	SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
	switch ( eDir )
	{
		// check the default alignment for this text direction
		case FRMDIR_HORI_LEFT_TOP :		aLeft.Check( sal_True ); break;
		case FRMDIR_HORI_RIGHT_TOP :	aRight.Check( sal_True ); break;
		case FRMDIR_ENVIRONMENT :		/* do nothing */ break;
		default:
		{
			DBG_ERRORFILE( "SvxParaAlignTabPage::TextDirectionHdl_Impl(): other directions not supported" );
		}
	}

	return 0;
}

/*-----------------16.01.97 19.34-------------------

--------------------------------------------------*/
void	SvxParaAlignTabPage::UpdateExample_Impl( sal_Bool bAll )
{
	if ( aLeft.IsChecked() )
		aExampleWin.SetAdjust( SVX_ADJUST_LEFT );
	else if ( aRight.IsChecked() )
		aExampleWin.SetAdjust( SVX_ADJUST_RIGHT );
	else if ( aCenter.IsChecked() )
		aExampleWin.SetAdjust( SVX_ADJUST_CENTER );
	else if ( aJustify.IsChecked() )
	{
		aExampleWin.SetAdjust( SVX_ADJUST_BLOCK );
		SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
		sal_uInt16 nLBPos = aLastLineLB.GetSelectEntryPos();
		if(nLBPos == 1)
			eLastBlock = SVX_ADJUST_CENTER;
		else if(nLBPos == 2)
			eLastBlock = SVX_ADJUST_BLOCK;
		aExampleWin.SetLastLine( eLastBlock );
	}

	aExampleWin.Draw( bAll );
}
/*-----------------17.01.97 08.04-------------------
	Erweiterungen fuer den Blocksatz einschalten
--------------------------------------------------*/
void SvxParaAlignTabPage::EnableJustifyExt()
{
	aLastLineFT.Show();
	aLastLineLB.Show();
	aExpandCB  .Show();
    SvtLanguageOptions aCJKOptions;
    if(aCJKOptions.IsAsianTypographyEnabled())
        aSnapToGridCB.Show();

}
//add CHINA001 begin
void SvxParaAlignTabPage::PageCreated (SfxAllItemSet aSet)
{
	SFX_ITEMSET_ARG	(&aSet,pBoolItem,SfxBoolItem,SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT,sal_False);
	if (pBoolItem)
		if(pBoolItem->GetValue())
			EnableJustifyExt();
}
//end of CHINA001
// class SvxExtParagraphTabPage ------------------------------------------

SfxTabPage* SvxExtParagraphTabPage::Create( Window* pParent,
											const SfxItemSet& rSet )
{
	return new SvxExtParagraphTabPage( pParent, rSet );
}

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

sal_Bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
{
	sal_Bool bModified = sal_False;
    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
	const TriState eHyphenState = aHyphenBox.GetState();
	const SfxPoolItem* pOld = GetOldItem( rOutSet, SID_ATTR_PARA_HYPHENZONE );

	if ( eHyphenState != aHyphenBox.GetSavedValue() 	||
		 aExtHyphenBeforeBox.IsValueModified() 	   		||
		 aExtHyphenAfterBox.IsValueModified()			||
		 aMaxHyphenEdit.IsValueModified() )
	{
		SvxHyphenZoneItem aHyphen(
            (const SvxHyphenZoneItem&)GetItemSet().Get( _nWhich ) );
		aHyphen.SetHyphen( eHyphenState == STATE_CHECK );

		if ( eHyphenState == STATE_CHECK )
		{
			aHyphen.GetMinLead() = (sal_uInt8)aExtHyphenBeforeBox.GetValue();
			aHyphen.GetMinTrail() = (sal_uInt8)aExtHyphenAfterBox.GetValue();
		}
		aHyphen.GetMaxHyphens() = (sal_uInt8)aMaxHyphenEdit.GetValue();

		if ( !pOld ||
			!( *(SvxHyphenZoneItem*)pOld == aHyphen ) ||
				eHyphenState != aHyphenBox.GetSavedValue())
		{
			rOutSet.Put( aHyphen );
			bModified |= sal_True;
		}
	}

	if (aPagenumEdit.IsEnabled() && aPagenumEdit.IsValueModified())
	{
		SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM,
								(sal_uInt16)aPagenumEdit.GetValue() );

		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGENUM );

		if ( !pOld || ( (const SfxUInt16Item*)pOld )->GetValue() != aPageNum.GetValue() )
		{
			rOutSet.Put( aPageNum );
			bModified |= sal_True;
		}
	}

	// Seitenumbruch

	TriState eState = aApplyCollBtn.GetState();
	FASTBOOL bIsPageModel = sal_False;

    _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
	String sPage;
	if ( eState != aApplyCollBtn.GetSavedValue() ||
		 ( STATE_CHECK == eState &&
		   aApplyCollBox.GetSelectEntryPos() != aApplyCollBox.GetSavedValue() ) )
	{
		if ( eState == STATE_CHECK )
		{
			sPage = aApplyCollBox.GetSelectEntry();
			bIsPageModel = 0 != sPage.Len();
		}
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_MODEL );

		if ( !pOld || ( (const SvxPageModelItem*)pOld )->GetValue() != sPage )
		{
            rOutSet.Put( SvxPageModelItem( sPage, sal_False, _nWhich ) );
			bModified |= sal_True;
		}
		else
			bIsPageModel = sal_False;
	}
	else if(STATE_CHECK == eState && aApplyCollBtn.IsEnabled())
		bIsPageModel = sal_True;
	else
        rOutSet.Put( SvxPageModelItem( sPage, sal_False, _nWhich ) );

    _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );

	if ( bIsPageModel )
		// wird PageModel eingeschaltet, dann immer PageBreak ausschalten
        rOutSet.Put( SvxFmtBreakItem( SVX_BREAK_NONE, _nWhich ) );
	else
	{
		eState = aPageBreakBox.GetState();
		SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, sal_False);

		if ( (eModelState == SFX_ITEM_SET && STATE_CHECK == aPageBreakBox.GetState()) ||
			 eState != aPageBreakBox.GetSavedValue()				||
             aBreakTypeLB.GetSelectEntryPos() != aBreakTypeLB.GetSavedValue()   ||
             aBreakPositionLB.GetSelectEntryPos() != aBreakPositionLB.GetSavedValue() )
		{
			const SvxFmtBreakItem rOldBreak(
                    (const SvxFmtBreakItem&)GetItemSet().Get( _nWhich ));
			SvxFmtBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());

			switch ( eState )
			{
				case STATE_CHECK:
				{
                    sal_Bool bBefore = aBreakPositionLB.GetSelectEntryPos() == 0;

                    if ( aBreakTypeLB.GetSelectEntryPos() == 0 )
					{
						if ( bBefore )
							aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
						else
							aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
					}
					else
					{
						if ( bBefore )
							aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
						else
							aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
					}
					break;
				}

				case STATE_NOCHECK:
					aBreak.SetValue( SVX_BREAK_NONE );
					break;
                default: ; //prevent warning
			}
			pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGEBREAK );

			if ( eState != aPageBreakBox.GetSavedValue()				||
					!pOld || !( *(const SvxFmtBreakItem*)pOld == aBreak ) )
			{
				bModified |= sal_True;
				rOutSet.Put( aBreak );
			}
		}
	}


	// Absatztrennung
    _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
	eState = aKeepTogetherBox.GetState();

	if ( eState != aKeepTogetherBox.GetSavedValue() )
	{
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_SPLIT );

		if ( !pOld || ( (const SvxFmtSplitItem*)pOld )->GetValue() !=
					  ( eState == STATE_NOCHECK ) )
		{
            rOutSet.Put( SvxFmtSplitItem( eState == STATE_NOCHECK, _nWhich ) );
			bModified |= sal_True;
		}
	}

	// Absaetze zusammenhalten
    _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
	eState = aKeepParaBox.GetState();

	if ( eState != aKeepParaBox.GetSavedValue() )
	{
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_KEEP );

		// hat sich der Status geaendert, muss immer geputtet werden
        rOutSet.Put( SvxFmtKeepItem( eState == STATE_CHECK, _nWhich ) );
		bModified |= sal_True;
	}

	// Witwen und Waisen
    _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
	eState = aWidowBox.GetState();

	if ( eState != aWidowBox.GetSavedValue() ||
		 aWidowRowNo.IsValueModified() )
	{
		SvxWidowsItem rItem( eState == STATE_CHECK ?
                             (sal_uInt8)aWidowRowNo.GetValue() : 0, _nWhich );
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_WIDOWS );

		if ( eState != aWidowBox.GetSavedValue() || !pOld || !( *(const SvxWidowsItem*)pOld == rItem ) )
		{
			rOutSet.Put( rItem );
			bModified |= sal_True;
		}
	}

    _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
	eState = aOrphanBox.GetState();

	if ( eState != aOrphanBox.GetSavedValue() ||
		 aOrphanRowNo.IsValueModified() )
	{
		SvxOrphansItem rItem( eState == STATE_CHECK ?
                             (sal_uInt8)aOrphanRowNo.GetValue() : 0, _nWhich );
		pOld = GetOldItem( rOutSet, SID_ATTR_PARA_ORPHANS );

		if ( eState != aOrphanBox.GetSavedValue() ||
				!pOld ||
					!( *(const SvxOrphansItem*)pOld == rItem ) )
		{
			rOutSet.Put( rItem );
			bModified |= sal_True;
		}
	}

    return bModified;
}

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

void SvxExtParagraphTabPage::Reset( const SfxItemSet& rSet )
{
    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
    SfxItemState eItemState = rSet.GetItemState( _nWhich );

	sal_Bool bItemAvailable = eItemState >= SFX_ITEM_AVAILABLE;
	sal_Bool bIsHyphen = sal_False;
	if( !bHtmlMode && bItemAvailable )
	{
		const SvxHyphenZoneItem& rHyphen =
            (const SvxHyphenZoneItem&)rSet.Get( _nWhich );
		aHyphenBox.EnableTriState( sal_False );

		bIsHyphen = rHyphen.IsHyphen();
		aHyphenBox.SetState( bIsHyphen ? STATE_CHECK : STATE_NOCHECK );

		aExtHyphenBeforeBox.SetValue( rHyphen.GetMinLead() );
		aExtHyphenAfterBox.SetValue( rHyphen.GetMinTrail() );
		aMaxHyphenEdit.SetValue( rHyphen.GetMaxHyphens() );
	}
	else
	{
		aHyphenBox.SetState( STATE_DONTKNOW );
	}
	sal_Bool bEnable = bItemAvailable && bIsHyphen;
	aExtHyphenBeforeBox.Enable(bEnable);
	aExtHyphenAfterBox.Enable(bEnable);
	aBeforeText.Enable(bEnable);
	aAfterText.Enable(bEnable);
	aMaxHyphenLabel.Enable(bEnable);
	aMaxHyphenEdit.Enable(bEnable);

    _nWhich = GetWhich( SID_ATTR_PARA_PAGENUM );

    if ( rSet.GetItemState(_nWhich) >= SFX_ITEM_AVAILABLE )
	{
		const sal_uInt16 nPageNum =
            ( (const SfxUInt16Item&)rSet.Get( _nWhich ) ).GetValue();
		aPagenumEdit.SetValue( nPageNum );
	}

	if ( bPageBreak )
	{
		// zuerst PageModel behandeln
        _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
		sal_Bool bIsPageModel = sal_False;
        eItemState = rSet.GetItemState( _nWhich );

		if ( eItemState >= SFX_ITEM_SET )
		{
			aApplyCollBtn.EnableTriState( sal_False );

			const SvxPageModelItem& rModel =
                (const SvxPageModelItem&)rSet.Get( _nWhich );
			String aStr( rModel.GetValue() );

			if ( aStr.Len() &&
				 aApplyCollBox.GetEntryPos( aStr ) != LISTBOX_ENTRY_NOTFOUND )
			{
				aApplyCollBox.SelectEntry( aStr );
				aApplyCollBtn.SetState( STATE_CHECK );
				bIsPageModel = sal_True;

				aPageBreakBox.Enable();
				aPageBreakBox.EnableTriState( sal_False );
                aBreakTypeFT.Enable();
                aBreakTypeLB.Enable();
                aBreakPositionFT.Enable();
                aBreakPositionLB.Enable();
                aApplyCollBtn.Enable();
				aPageBreakBox.SetState( STATE_CHECK );

                //select page break
                aBreakTypeLB.SelectEntryPos(0);
                //select break before
                aBreakPositionLB.SelectEntryPos(0);
			}
			else
			{
				aApplyCollBox.SetNoSelection();
				aApplyCollBtn.SetState( STATE_NOCHECK );
			}
		}
		else if ( SFX_ITEM_DONTCARE == eItemState )
		{
			aApplyCollBtn.EnableTriState( sal_True );
			aApplyCollBtn.SetState( STATE_DONTKNOW );
			aApplyCollBox.SetNoSelection();
		}
		else
		{
			aApplyCollBtn.Enable(sal_False);
			aApplyCollBox.Enable(sal_False);
			aPagenumEdit.Enable(sal_False);
			aPagenumText.Enable(sal_False);
		}
//!!!	ApplyCollClickHdl_Impl( &aApplyCollBtn );

		if ( !bIsPageModel )
		{
            _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
            eItemState = rSet.GetItemState( _nWhich );

			if ( eItemState >= SFX_ITEM_AVAILABLE )
			{
				const SvxFmtBreakItem& rPageBreak =
                    (const SvxFmtBreakItem&)rSet.Get( _nWhich );

				SvxBreak eBreak = (SvxBreak)rPageBreak.GetValue();

				// PageBreak nicht ueber CTRL-RETURN,
				// dann kann CheckBox frei gegeben werden
				aPageBreakBox.Enable();
				aPageBreakBox.EnableTriState( sal_False );
                aBreakTypeFT.Enable();
                aBreakTypeLB.Enable();
                aBreakPositionFT.Enable();
                aBreakPositionLB.Enable();

				aPageBreakBox.SetState( STATE_CHECK );

                sal_Bool _bEnable =     eBreak != SVX_BREAK_NONE &&
								eBreak != SVX_BREAK_COLUMN_BEFORE &&
								eBreak != SVX_BREAK_COLUMN_AFTER;
                aApplyCollBtn.Enable(_bEnable);
                if(!_bEnable)
				{
                    aApplyCollBox.Enable(_bEnable);
                    aPagenumEdit.Enable(_bEnable);
				}

				if ( eBreak == SVX_BREAK_NONE )
					aPageBreakBox.SetState( STATE_NOCHECK );

                sal_uInt16 nType = 0; // selection position in break type ListBox : Page
                sal_uInt16 nPosition = 0; //  selection position in break position ListBox : Before
                switch ( eBreak )
				{
					case SVX_BREAK_PAGE_BEFORE:
						break;
					case SVX_BREAK_PAGE_AFTER:
                        nPosition = 1;
						break;
					case SVX_BREAK_COLUMN_BEFORE:
                        nType = 1;
						break;
					case SVX_BREAK_COLUMN_AFTER:
                        nType = 1;
                        nPosition = 1;
						break;
                    default: ;//prevent warning
				}
                aBreakTypeLB.SelectEntryPos(nType);
                aBreakPositionLB.SelectEntryPos(nPosition);
            }
			else if ( SFX_ITEM_DONTCARE == eItemState )
				aPageBreakBox.SetState( STATE_DONTKNOW );
			else
			{
                aPageBreakBox.Enable(sal_False);
                aBreakTypeFT.Enable(sal_False);
                aBreakTypeLB.Enable(sal_False);
                aBreakPositionFT.Enable(sal_False);
                aBreakPositionLB.Enable(sal_False);
			}
		}

        PageBreakPosHdl_Impl( &aBreakPositionLB );
		PageBreakHdl_Impl( &aPageBreakBox );
	}

    _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
	{
		aKeepParaBox.EnableTriState( sal_False );
		const SvxFmtKeepItem& rKeep =
            (const SvxFmtKeepItem&)rSet.Get( _nWhich );

		if ( rKeep.GetValue() )
			aKeepParaBox.SetState( STATE_CHECK );
		else
			aKeepParaBox.SetState( STATE_NOCHECK );
	}
	else if ( SFX_ITEM_DONTCARE == eItemState )
		aKeepParaBox.SetState( STATE_DONTKNOW );
	else
		aKeepParaBox.Enable(sal_False);

    _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
    eItemState = rSet.GetItemState( _nWhich );

	if ( eItemState >= SFX_ITEM_AVAILABLE )
	{
		const SvxFmtSplitItem& rSplit =
            (const SvxFmtSplitItem&)rSet.Get( _nWhich );
		aKeepTogetherBox.EnableTriState( sal_False );

		if ( !rSplit.GetValue() )
			aKeepTogetherBox.SetState( STATE_CHECK );
		else
		{
			aKeepTogetherBox.SetState( STATE_NOCHECK );

			// Witwen und Waisen
			aWidowBox.Enable();
            _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
            SfxItemState eTmpState = rSet.GetItemState( _nWhich );

			if ( eTmpState >= SFX_ITEM_AVAILABLE )
			{
				const SvxWidowsItem& rWidow =
                    (const SvxWidowsItem&)rSet.Get( _nWhich );
				aWidowBox.EnableTriState( sal_False );
				const sal_uInt16 nLines = rWidow.GetValue();

                sal_Bool _bEnable = nLines > 0;
				aWidowRowNo.SetValue( aWidowRowNo.Normalize( nLines ) );
                aWidowBox.SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
                aWidowRowNo.Enable(_bEnable);
                aWidowRowLabel.Enable(_bEnable);

			}
			else if ( SFX_ITEM_DONTCARE == eTmpState )
				aWidowBox.SetState( STATE_DONTKNOW );
			else
				aWidowBox.Enable(sal_False);

			aOrphanBox.Enable();
            _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
            eTmpState = rSet.GetItemState( _nWhich );

			if ( eTmpState >= SFX_ITEM_AVAILABLE )
			{
				const SvxOrphansItem& rOrphan =
                    (const SvxOrphansItem&)rSet.Get( _nWhich );
				const sal_uInt16 nLines = rOrphan.GetValue();
				aOrphanBox.EnableTriState( sal_False );

                sal_Bool _bEnable = nLines > 0;
                aOrphanBox.SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
				aOrphanRowNo.SetValue( aOrphanRowNo.Normalize( nLines ) );
                aOrphanRowNo.Enable(_bEnable);
                aOrphanRowLabel.Enable(_bEnable);

			}
			else if ( SFX_ITEM_DONTCARE == eTmpState )
				aOrphanBox.SetState( STATE_DONTKNOW );
			else
				aOrphanBox.Enable(sal_False);
		}
	}
	else if ( SFX_ITEM_DONTCARE == eItemState )
		aKeepTogetherBox.SetState( STATE_DONTKNOW );
	else
		aKeepTogetherBox.Enable(sal_False);

	// damit alles richt enabled wird
	KeepTogetherHdl_Impl( 0 );
	WidowHdl_Impl( 0 );
	OrphanHdl_Impl( 0 );

    aHyphenBox.SaveValue();
	aExtHyphenBeforeBox.SaveValue();
	aExtHyphenAfterBox.SaveValue();
	aMaxHyphenEdit.SaveValue();
	aPageBreakBox.SaveValue();
    aBreakPositionLB.SaveValue();
    aBreakTypeLB.SaveValue();
	aApplyCollBtn.SaveValue();
	aApplyCollBox.SaveValue();
	aPagenumEdit.SaveValue();
	aKeepTogetherBox.SaveValue();
	aKeepParaBox.SaveValue();
	aWidowBox.SaveValue();
	aOrphanBox.SaveValue();
}

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

int SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
{
    if ( _pSet )
        FillItemSet( *_pSet );
	return LEAVE_PAGE;
}

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

void SvxExtParagraphTabPage::DisablePageBreak()
{
	bPageBreak = sal_False;
	aPageBreakBox.Enable(sal_False);
    aBreakTypeLB.RemoveEntry(0);
    aBreakPositionFT.Enable(sal_False);
    aBreakPositionLB.Enable(sal_False);
	aApplyCollBtn.Enable(sal_False);
	aApplyCollBox.Enable(sal_False);
	aPagenumEdit.Enable(sal_False);
}

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

SvxExtParagraphTabPage::SvxExtParagraphTabPage( Window* pParent, const SfxItemSet& rAttr ) :

	SfxTabPage( pParent, CUI_RES( RID_SVXPAGE_EXT_PARAGRAPH ), rAttr ),

    aExtFL              ( this, CUI_RES( FL_HYPHEN ) ),
	aHyphenBox    		( this, CUI_RES( BTN_HYPHEN ) ),
	aBeforeText			( this, CUI_RES( FT_HYPHENBEFORE ) ),
	aExtHyphenBeforeBox ( this, CUI_RES( ED_HYPHENBEFORE ) ),
	aAfterText			( this, CUI_RES( FT_HYPHENAFTER ) ),
	aExtHyphenAfterBox  ( this, CUI_RES( ED_HYPHENAFTER ) ),
	aMaxHyphenLabel     ( this, CUI_RES( FT_MAXHYPH ) ),
	aMaxHyphenEdit		( this, CUI_RES( ED_MAXHYPH ) ),
    aBreaksFL           ( this, CUI_RES( FL_BREAKS ) ),
    aPageBreakBox       ( this, CUI_RES( BTN_PAGEBREAK ) ),
    aBreakTypeFT        ( this, CUI_RES( FT_BREAKTYPE     )),
    aBreakTypeLB        ( this, CUI_RES( LB_BREAKTYPE     )),
    aBreakPositionFT    ( this, CUI_RES( FT_BREAKPOSITION )),
    aBreakPositionLB    ( this, CUI_RES( LB_BREAKPOSITION )),
//    aPageBox            ( this, CUI_RES( BTN_BREAKPAGE ) ),
//    aColumnBox          ( this, CUI_RES( BTN_BREAKCOLUMN ) ),
//    aBeforeBox          ( this, CUI_RES( BTN_PAGEBREAKBEFORE ) ),
//    aAfterBox           ( this, CUI_RES( BTN_PAGEBREAKAFTER ) ),
	aApplyCollBtn       ( this, CUI_RES( BTN_PAGECOLL ) ),
	aApplyCollBox       ( this, CUI_RES( LB_PAGECOLL ) ),
	aPagenumText		( this, CUI_RES( FT_PAGENUM ) ),
	aPagenumEdit		( this, CUI_RES( ED_PAGENUM ) ),
    aExtendFL           ( this, CUI_RES( FL_OPTIONS ) ),
    aKeepTogetherBox    ( this, CUI_RES( BTN_KEEPTOGETHER ) ),
	aKeepParaBox		( this, CUI_RES( CB_KEEPTOGETHER ) ),
	aOrphanBox          ( this, CUI_RES( BTN_ORPHANS ) ),
	aOrphanRowNo        ( this, CUI_RES( ED_ORPHANS ) ),
	aOrphanRowLabel     ( this, CUI_RES( FT_ORPHANS ) ),
	aWidowBox           ( this, CUI_RES( BTN_WIDOWS ) ),
	aWidowRowNo         ( this, CUI_RES( ED_WIDOWS ) ),
	aWidowRowLabel      ( this, CUI_RES( FT_WIDOWS ) ),
    bPageBreak  ( sal_True ),
    bHtmlMode   ( sal_False ),
    nStdPos     ( 0 )
{
	FreeResource();

	aApplyCollBox.SetAccessibleRelationLabeledBy(&aApplyCollBtn);
	aApplyCollBox.SetAccessibleName(String(CUI_RES(STR_PAGE_STYLE)));
	aOrphanRowNo.SetAccessibleRelationLabeledBy(&aOrphanBox);
	aWidowRowNo.SetAccessibleRelationLabeledBy(&aWidowBox);

	// diese Page braucht ExchangeSupport
	SetExchangeSupport();

	aHyphenBox.SetClickHdl( 		LINK( this, SvxExtParagraphTabPage, HyphenClickHdl_Impl ) );
	aPageBreakBox.SetClickHdl( 		LINK( this, SvxExtParagraphTabPage, PageBreakHdl_Impl ) );
	aKeepTogetherBox.SetClickHdl( 	LINK( this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl ) );
	aWidowBox.SetClickHdl( 			LINK( this, SvxExtParagraphTabPage, WidowHdl_Impl ) );
	aOrphanBox.SetClickHdl( 		LINK( this, SvxExtParagraphTabPage, OrphanHdl_Impl ) );
	aApplyCollBtn.SetClickHdl( 		LINK( this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl ) );
    aBreakTypeLB.SetSelectHdl(      LINK( this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl ) );
    aBreakPositionLB.SetSelectHdl(  LINK( this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl ) );

	SfxObjectShell* pSh = SfxObjectShell::Current();
	if ( pSh )
	{
		SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
		pPool->SetSearchMask( SFX_STYLE_FAMILY_PAGE );
		SfxStyleSheetBase* pStyle = pPool->First();
		String aStdName;

		while( pStyle )
		{
			if ( aStdName.Len() == 0 )
				// first style == standard style
				aStdName = pStyle->GetName();
			aApplyCollBox.InsertEntry( pStyle->GetName() );
			pStyle = pPool->Next();
		}
		nStdPos = aApplyCollBox.GetEntryPos( aStdName );
	}

	sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr );
	if ( nHtmlMode & HTMLMODE_ON )
	{
		bHtmlMode = sal_True;
		aHyphenBox    		 .Enable(sal_False);
		aBeforeText			 .Enable(sal_False);
		aExtHyphenBeforeBox  .Enable(sal_False);
		aAfterText			 .Enable(sal_False);
		aExtHyphenAfterBox   .Enable(sal_False);
		aMaxHyphenLabel      .Enable(sal_False);
		aMaxHyphenEdit		 .Enable(sal_False);
        aExtFL               .Enable(sal_False);
		aPagenumText         .Enable(sal_False);
		aPagenumEdit         .Enable(sal_False);
        // no column break in HTML
        aBreakTypeLB.RemoveEntry(1);
	}
}

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

__EXPORT SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
{
}

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

sal_uInt16* SvxExtParagraphTabPage::GetRanges()
{
	return pExtRanges;
}

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

IMPL_LINK( SvxExtParagraphTabPage, PageBreakHdl_Impl, TriStateBox *, EMPTYARG )
{
	switch ( aPageBreakBox.GetState() )
	{
		case STATE_CHECK:
            aBreakTypeFT.Enable();
            aBreakTypeLB.Enable();
            aBreakPositionFT.Enable();
            aBreakPositionLB.Enable();

            if ( 0 == aBreakTypeLB.GetSelectEntryPos()&&
                0 == aBreakPositionLB.GetSelectEntryPos() )
			{
				aApplyCollBtn.Enable();

				sal_Bool bEnable = STATE_CHECK == aApplyCollBtn.GetState() &&
											aApplyCollBox.GetEntryCount();
				aApplyCollBox.Enable(bEnable);
				if(!bHtmlMode)
				{
					aPagenumText.Enable(bEnable);
					aPagenumEdit.Enable(bEnable);
				}
			}
			break;

		case STATE_NOCHECK:
		case STATE_DONTKNOW:
			aApplyCollBtn.SetState( STATE_NOCHECK );
			aApplyCollBtn.Enable(sal_False);
			aApplyCollBox.Enable(sal_False);
			aPagenumText.Enable(sal_False);
			aPagenumEdit.Enable(sal_False);
            aBreakTypeFT.Enable(sal_False);
            aBreakTypeLB.Enable(sal_False);
            aBreakPositionFT.Enable(sal_False);
            aBreakPositionLB.Enable(sal_False);
			break;
	}
	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, KeepTogetherHdl_Impl, TriStateBox *, EMPTYARG )
{
	sal_Bool bEnable = aKeepTogetherBox.GetState() == STATE_NOCHECK;
	aWidowBox.Enable(bEnable);
	aOrphanBox.Enable(bEnable);

	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, WidowHdl_Impl, TriStateBox *, EMPTYARG )
{
	switch ( aWidowBox.GetState() )
	{
		case STATE_CHECK:
			aWidowRowNo.Enable();
			aWidowRowLabel.Enable();
			aKeepTogetherBox.Enable(sal_False);
			break;

		case STATE_NOCHECK:
			if ( aOrphanBox.GetState() == STATE_NOCHECK )
				aKeepTogetherBox.Enable();

		// kein break
		case STATE_DONTKNOW:
			aWidowRowNo.Enable(sal_False);
			aWidowRowLabel.Enable(sal_False);
			break;
	}
	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, OrphanHdl_Impl, TriStateBox *, EMPTYARG )
{
	switch( aOrphanBox.GetState() )
	{
		case STATE_CHECK:
			aOrphanRowNo.Enable();
			aOrphanRowLabel.Enable();
			aKeepTogetherBox.Enable(sal_False);
			break;

		case STATE_NOCHECK:
			if ( aWidowBox.GetState() == STATE_NOCHECK )
				aKeepTogetherBox.Enable();

		// kein break
		case STATE_DONTKNOW:
			aOrphanRowNo.Enable(sal_False);
			aOrphanRowLabel.Enable(sal_False);
			break;
	}
	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, HyphenClickHdl_Impl, TriStateBox *, EMPTYARG )
{

	sal_Bool bEnable = aHyphenBox.GetState() == STATE_CHECK;
	aBeforeText.Enable(bEnable);
	aExtHyphenBeforeBox.Enable(bEnable);
	aAfterText.Enable(bEnable);
	aExtHyphenAfterBox.Enable(bEnable);
	aMaxHyphenLabel.Enable(bEnable);
	aMaxHyphenEdit.Enable(bEnable);
	aHyphenBox.SetState( bEnable ? STATE_CHECK : STATE_NOCHECK);

	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, ApplyCollClickHdl_Impl, TriStateBox *, EMPTYARG )
{
	sal_Bool bEnable = sal_False;
	if ( aApplyCollBtn.GetState() == STATE_CHECK &&
		 aApplyCollBox.GetEntryCount() )
	{
		bEnable = sal_True;
		aApplyCollBox.SelectEntryPos( nStdPos );
	}
	else
	{
		aApplyCollBox.SetNoSelection();
	}
	aApplyCollBox.Enable(bEnable);
	if(!bHtmlMode)
	{
		aPagenumText.Enable(bEnable);
		aPagenumEdit.Enable(bEnable);
	}
	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, PageBreakPosHdl_Impl, ListBox *, pListBox )
{
    if ( 0 == pListBox->GetSelectEntryPos() )
    {
        aApplyCollBtn.Enable();

        sal_Bool bEnable = aApplyCollBtn.GetState() == STATE_CHECK &&
                                    aApplyCollBox.GetEntryCount();

        aApplyCollBox.Enable(bEnable);
        if(!bHtmlMode)
        {
            aPagenumText.Enable(bEnable);
            aPagenumEdit.Enable(bEnable);
        }
    }
    else if ( 1 == pListBox->GetSelectEntryPos() )
    {
        aApplyCollBtn.SetState( STATE_NOCHECK );
        aApplyCollBtn.Enable(sal_False);
        aApplyCollBox.Enable(sal_False);
        aPagenumText.Enable(sal_False);
        aPagenumEdit.Enable(sal_False);
    }
	return 0;
}

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

IMPL_LINK( SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, ListBox *, pListBox )
{
    //column break or break break after
    sal_uInt16 nBreakPos = aBreakPositionLB.GetSelectEntryPos();
    if ( pListBox->GetSelectEntryPos() == 1 || 1 == nBreakPos)
	{
		aApplyCollBtn.SetState( STATE_NOCHECK );
		aApplyCollBtn.Enable(sal_False);
		aApplyCollBox.Enable(sal_False);
		aPagenumText.Enable(sal_False);
		aPagenumEdit.Enable(sal_False);
	}
    else
        PageBreakPosHdl_Impl( &aBreakPositionLB );
	return 0;
}
//Add CHINA001 begin
void SvxExtParagraphTabPage::PageCreated(SfxAllItemSet aSet)
{


	SFX_ITEMSET_ARG	(&aSet,pDisablePageBreakItem,SfxBoolItem,SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK,sal_False);

	if (pDisablePageBreakItem)
		if ( pDisablePageBreakItem->GetValue())
					DisablePageBreak();


}
//end of Add CHINA001
/*-- 29.11.00 11:36:24---------------------------------------------------

  -----------------------------------------------------------------------*/
SvxAsianTabPage::SvxAsianTabPage( Window* pParent, const SfxItemSet& rSet ) :
	SfxTabPage(pParent, CUI_RES( RID_SVXPAGE_PARA_ASIAN ), rSet),
    aOptionsFL(         this, CUI_RES(FL_AS_OPTIONS       )),
    aForbiddenRulesCB(  this, CUI_RES(CB_AS_FORBIDDEN     )),
    aHangingPunctCB(    this, CUI_RES(CB_AS_HANG_PUNC     )),
	aScriptSpaceCB(     this, CUI_RES(CB_AS_SCRIPT_SPACE	))//,

{
	FreeResource();

	Link aLink = LINK( this, SvxAsianTabPage, ClickHdl_Impl );
	aHangingPunctCB.SetClickHdl( aLink );
	aScriptSpaceCB.SetClickHdl( aLink );
	aForbiddenRulesCB.SetClickHdl( aLink );

}
/*-- 29.11.00 11:36:24---------------------------------------------------

  -----------------------------------------------------------------------*/
SvxAsianTabPage::~SvxAsianTabPage()
{
}
/*-- 29.11.00 11:36:24---------------------------------------------------

  -----------------------------------------------------------------------*/
SfxTabPage*	SvxAsianTabPage::Create(	Window* pParent, const SfxItemSet& rSet )
{
	return new SvxAsianTabPage(pParent, rSet);
}
/*-- 29.11.00 11:36:24---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_uInt16*		SvxAsianTabPage::GetRanges()
{
	static sal_uInt16 pRanges[] =
	{
		SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES,
		0
	};
	return pRanges;
}
/*-- 29.11.00 11:36:24---------------------------------------------------

  -----------------------------------------------------------------------*/
sal_Bool		SvxAsianTabPage::FillItemSet( SfxItemSet& rSet )
{
	sal_Bool bRet = sal_False;
	SfxItemPool* pPool = rSet.GetPool();
	if(aScriptSpaceCB.IsChecked() != aScriptSpaceCB.GetSavedValue())
	{
		SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
			pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone();
		pNewItem->SetValue(aScriptSpaceCB.IsChecked());
		rSet.Put(*pNewItem);
		delete pNewItem;
		bRet = sal_True;
	}
	if(aHangingPunctCB.IsChecked() != aHangingPunctCB.GetSavedValue())
	{
		SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
			pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone();
		pNewItem->SetValue(aHangingPunctCB.IsChecked());
		rSet.Put(*pNewItem);
		delete pNewItem;
		bRet = sal_True;
	}
	if(aForbiddenRulesCB.IsChecked() != aForbiddenRulesCB.GetSavedValue())
	{
		SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
			pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone();
		pNewItem->SetValue(aForbiddenRulesCB.IsChecked());
		rSet.Put(*pNewItem);
		delete pNewItem;
		bRet = sal_True;
	}
	return bRet;
}
/*-- 29.11.00 11:36:25---------------------------------------------------

  -----------------------------------------------------------------------*/
void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, TriStateBox& rBox)
{
    sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId);
    SfxItemState eState = rSet.GetItemState(_nWhich, sal_True);
	if(!eState || eState == SFX_ITEM_DISABLED )
		rBox.Enable(sal_False);
	else if(eState >= SFX_ITEM_AVAILABLE)
	{
		rBox.EnableTriState( sal_False );
        rBox.Check(((const SfxBoolItem&)rSet.Get(_nWhich)).GetValue());
	}
	else
		rBox.SetState( STATE_DONTKNOW );
	rBox.SaveValue();
}


void SvxAsianTabPage::Reset( const SfxItemSet& rSet )
{
	lcl_SetBox(rSet, SID_ATTR_PARA_FORBIDDEN_RULES, aForbiddenRulesCB );
//	lcl_SetBox(rSet, , aAllowWordBreakCB );
	lcl_SetBox(rSet, SID_ATTR_PARA_HANGPUNCTUATION, aHangingPunctCB );


	//character distance not yet available
//	lcl_SetBox(rSet, , aPuntuationCB    );
	lcl_SetBox(rSet, SID_ATTR_PARA_SCRIPTSPACE, aScriptSpaceCB );
//	lcl_SetBox(rSet, , aAdjustNumbersCB );
//	aAllowWordBreakCB	.Enable(sal_False);
//	aPuntuationCB		.Enable(sal_False);
//	aAdjustNumbersCB	.Enable(sal_False);
}
/* -----------------------------19.12.00 12:59--------------------------------

 ---------------------------------------------------------------------------*/
IMPL_LINK( SvxAsianTabPage, ClickHdl_Impl, TriStateBox*, pBox )
{
	pBox->EnableTriState( sal_False );
	return 0;
}