xref: /AOO41X/main/cui/source/tabpages/chardlg.cxx (revision 2ee96f1cdb99d49425d866b1ec4c5567f37285e6)

/**************************************************************
 *
 * 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 ---------------------------------------------------------------
#include <editeng/unolingu.hxx>
#include <vcl/svapp.hxx>
#include <unotools/pathoptions.hxx>
#include <svtools/ctrltool.hxx>
#include <svl/sfontitm.hxx>
#include <sfx2/printer.hxx>
#include <sfx2/objsh.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/viewfrm.hxx>
#include <vcl/msgbox.hxx>
#include <svx/dialmgr.hxx>
#include <svx/dialogs.hrc>
#include <svtools/unitconv.hxx>

#define _SVX_CHARDLG_CXX
#include <svl/languageoptions.hxx>

#include <cuires.hrc>
#include "chardlg.hrc"

#include <svx/xtable.hxx>		// XColorTable
#include "chardlg.hxx"
#include "editeng/fontitem.hxx"
#include <editeng/postitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/crsditem.hxx>
#include <editeng/cntritem.hxx>
#include <editeng/langitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/shdditem.hxx>
#include <editeng/escpitem.hxx>
#include <editeng/prszitem.hxx>
#include <editeng/wrlmitem.hxx>
#include <editeng/cmapitem.hxx>
#include <editeng/kernitem.hxx>
#include <editeng/blnkitem.hxx>
#include "editeng/flstitem.hxx"
#include <editeng/akrnitem.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/colritem.hxx>
#include "svx/drawitem.hxx"
#include "svx/dlgutil.hxx"
#include <dialmgr.hxx>
#include "svx/htmlmode.hxx"
#include "cuicharmap.hxx"
#include "chardlg.h"
#include <editeng/emphitem.hxx>
#include <editeng/charreliefitem.hxx>
#include <editeng/twolinesitem.hxx>
#include <editeng/charhiddenitem.hxx>
#include <svl/stritem.hxx>
#include <editeng/charscaleitem.hxx>
#include <editeng/charrotateitem.hxx>
#include <svx/svxdlg.hxx> //CHINA001
#include <cuires.hrc> //CHINA001
#include <svl/intitem.hxx> //CHINA001
#include <sfx2/request.hxx> //CHINA001
#include "svx/flagsdef.hxx" //CHINA001

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

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

#define ISITEMSET	rSet.GetItemState(nWhich)>=SFX_ITEM_DEFAULT

#define CLEARTITEM	rSet.InvalidateItem(nWhich)

#define LW_NORMAL	0
#define LW_GESPERRT 1
#define LW_SCHMAL	2

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

static sal_uInt16 pNameRanges[] =
{
	SID_ATTR_CHAR_FONT,
	SID_ATTR_CHAR_WEIGHT,
	SID_ATTR_CHAR_FONTHEIGHT,
	SID_ATTR_CHAR_FONTHEIGHT,
	SID_ATTR_CHAR_COLOR,
	SID_ATTR_CHAR_COLOR,
	SID_ATTR_CHAR_LANGUAGE,
	SID_ATTR_CHAR_LANGUAGE,
	SID_ATTR_CHAR_CJK_FONT,
	SID_ATTR_CHAR_CJK_WEIGHT,
	SID_ATTR_CHAR_CTL_FONT,
	SID_ATTR_CHAR_CTL_WEIGHT,
	0
};

static sal_uInt16 pEffectsRanges[] =
{
	SID_ATTR_CHAR_SHADOWED,
	SID_ATTR_CHAR_UNDERLINE,
	SID_ATTR_CHAR_COLOR,
	SID_ATTR_CHAR_COLOR,
	SID_ATTR_CHAR_CASEMAP,
	SID_ATTR_CHAR_CASEMAP,
	SID_ATTR_FLASH,
	SID_ATTR_FLASH,
	SID_ATTR_CHAR_EMPHASISMARK,
	SID_ATTR_CHAR_EMPHASISMARK,
	SID_ATTR_CHAR_RELIEF,
	SID_ATTR_CHAR_RELIEF,
	SID_ATTR_CHAR_HIDDEN,
	SID_ATTR_CHAR_HIDDEN,
	SID_ATTR_CHAR_OVERLINE,
	SID_ATTR_CHAR_OVERLINE,
	0
};

static sal_uInt16 pPositionRanges[] =
{
	SID_ATTR_CHAR_KERNING,
	SID_ATTR_CHAR_KERNING,
	SID_ATTR_CHAR_ESCAPEMENT,
	SID_ATTR_CHAR_ESCAPEMENT,
	SID_ATTR_CHAR_AUTOKERN,
	SID_ATTR_CHAR_AUTOKERN,
	SID_ATTR_CHAR_ROTATED,
	SID_ATTR_CHAR_SCALEWIDTH,
	SID_ATTR_CHAR_WIDTH_FIT_TO_LINE,
	SID_ATTR_CHAR_WIDTH_FIT_TO_LINE,
	0
};

static sal_uInt16 pTwoLinesRanges[] =
{
	SID_ATTR_CHAR_TWO_LINES,
	SID_ATTR_CHAR_TWO_LINES,
	0
};

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

inline sal_Bool StateToAttr( TriState aState )
{
	return ( STATE_CHECK == aState );
}

// class SvxCharBasePage -------------------------------------------------

inline SvxFont& SvxCharBasePage::GetPreviewFont()
{
	return m_aPreviewWin.GetFont();
}

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

inline SvxFont& SvxCharBasePage::GetPreviewCJKFont()
{
	return m_aPreviewWin.GetCJKFont();
}
// -----------------------------------------------------------------------

inline SvxFont& SvxCharBasePage::GetPreviewCTLFont()
{
	return m_aPreviewWin.GetCTLFont();
}

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

SvxCharBasePage::SvxCharBasePage( Window* pParent, const ResId& rResId, const SfxItemSet& rItemset,
								 sal_uInt16 nResIdPrewievWin, sal_uInt16 nResIdFontTypeFT ):
	SfxTabPage( pParent, rResId, rItemset ),
    m_aPreviewWin( this, ResId( nResIdPrewievWin, *rResId.GetResMgr() ) ),
    m_aFontTypeFT( this, ResId( nResIdFontTypeFT, *rResId.GetResMgr() ) ),
	m_bPreviewBackgroundToCharacter( sal_False )
{
}

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

SvxCharBasePage::~SvxCharBasePage()
{
}

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

//void SvxCharBasePage::SetPrevFontAttributes( const SfxItemSet& rSet )
void SvxCharBasePage::ActivatePage( const SfxItemSet& rSet )
{
	SvxFont&		rFont = GetPreviewFont();
    SvxFont&		rCJKFont = GetPreviewCJKFont();
	SvxFont&		rCTLFont = GetPreviewCTLFont();
	sal_uInt16			nWhich;

    nWhich = GetWhich( SID_CHAR_DLG_PREVIEW_STRING );
    if( ISITEMSET )
    {
        const SfxStringItem& rItem = ( SfxStringItem& ) rSet.Get( nWhich );
        ::rtl::OUString aString = rItem.GetValue();
        if( aString.getLength() != 0 )
            m_aPreviewWin.SetPreviewText( aString );
        else
            m_aPreviewWin.SetFontNameAsPreviewText();
    }

	// Underline
	FontUnderline eUnderline;
	nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
	if( ISITEMSET )
	{
		const SvxUnderlineItem& rItem = ( SvxUnderlineItem& ) rSet.Get( nWhich );
		eUnderline = ( FontUnderline ) rItem.GetValue();
		m_aPreviewWin.SetTextLineColor( rItem.GetColor() );
	}
	else
		eUnderline = UNDERLINE_NONE;

	rFont.SetUnderline( eUnderline );
    rCJKFont.SetUnderline( eUnderline );
	rCTLFont.SetUnderline( eUnderline );

	// Overline
	FontUnderline eOverline;
	nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
	if( ISITEMSET )
	{
		const SvxOverlineItem& rItem = ( SvxOverlineItem& ) rSet.Get( nWhich );
		eOverline = ( FontUnderline ) rItem.GetValue();
		m_aPreviewWin.SetOverlineColor( rItem.GetColor() );
	}
	else
		eOverline = UNDERLINE_NONE;

	rFont.SetOverline( eOverline );
    rCJKFont.SetOverline( eOverline );
	rCTLFont.SetOverline( eOverline );

	//	Strikeout
	FontStrikeout eStrikeout;
	nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
	if( ISITEMSET )
	{
		const SvxCrossedOutItem& rItem = ( SvxCrossedOutItem& ) rSet.Get( nWhich );
		eStrikeout = ( FontStrikeout ) rItem.GetValue();
	}
	else
		eStrikeout = STRIKEOUT_NONE;

	rFont.SetStrikeout( eStrikeout );
    rCJKFont.SetStrikeout( eStrikeout );
	rCTLFont.SetStrikeout( eStrikeout );

	// WordLineMode
	nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
	if( ISITEMSET )
	{
		const SvxWordLineModeItem& rItem = ( SvxWordLineModeItem& ) rSet.Get( nWhich );
		rFont.SetWordLineMode( rItem.GetValue() );
        rCJKFont.SetWordLineMode( rItem.GetValue() );
		rCTLFont.SetWordLineMode( rItem.GetValue() );
	}

	// Emphasis
	nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
	if( ISITEMSET )
	{
		const SvxEmphasisMarkItem& rItem = ( SvxEmphasisMarkItem& ) rSet.Get( nWhich );
		FontEmphasisMark eMark = rItem.GetEmphasisMark();
		rFont.SetEmphasisMark( eMark );
        rCJKFont.SetEmphasisMark( eMark );
		rCTLFont.SetEmphasisMark( eMark );
	}

    // Relief
    nWhich = GetWhich( SID_ATTR_CHAR_RELIEF );
    if( ISITEMSET )
	{
        const SvxCharReliefItem& rItem = ( SvxCharReliefItem& ) rSet.Get( nWhich );
		FontRelief eFontRelief = ( FontRelief ) rItem.GetValue();
        rFont.SetRelief( eFontRelief );
        rCJKFont.SetRelief( eFontRelief );
		rCTLFont.SetRelief( eFontRelief );
    }

	// Effects
	nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
	if( ISITEMSET )
	{
		const SvxCaseMapItem& rItem = ( SvxCaseMapItem& ) rSet.Get( nWhich );
		SvxCaseMap eCaseMap = ( SvxCaseMap ) rItem.GetValue();
		rFont.SetCaseMap( eCaseMap );
        rCJKFont.SetCaseMap( eCaseMap );
        // #i78474# small caps do not exist in CTL fonts
        rCTLFont.SetCaseMap( eCaseMap == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : eCaseMap );
	}

	// Outline
	nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
	if( ISITEMSET )
	{
		const SvxContourItem& rItem = ( SvxContourItem& ) rSet.Get( nWhich );
		sal_Bool bOutline = rItem.GetValue();
		rFont.SetOutline( bOutline );
        rCJKFont.SetOutline( bOutline );
		rCTLFont.SetOutline( bOutline );
	}

	// Shadow
	nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
	if( ISITEMSET )
	{
		const SvxShadowedItem& rItem = ( SvxShadowedItem& ) rSet.Get( nWhich );
		sal_Bool bShadow = rItem.GetValue();
		rFont.SetShadow( bShadow );
        rCJKFont.SetShadow( bShadow );
		rCTLFont.SetShadow( bShadow );
	}

	// Background
	sal_Bool bTransparent;
    nWhich = GetWhich( m_bPreviewBackgroundToCharacter ? SID_ATTR_BRUSH : SID_ATTR_BRUSH_CHAR );
    if( ISITEMSET )
    {
         const SvxBrushItem& rBrush = ( SvxBrushItem& ) rSet.Get( nWhich );
         const Color& rColor = rBrush.GetColor();
		 bTransparent = rColor.GetTransparency() > 0;
         rFont.SetFillColor( rColor );
         rCJKFont.SetFillColor( rColor );
		 rCTLFont.SetFillColor( rColor );
    }
    else
        bTransparent = sal_True;

    rFont.SetTransparent( bTransparent );
    rCJKFont.SetTransparent( bTransparent );
	rCTLFont.SetTransparent( bTransparent );

	Color aBackCol( COL_TRANSPARENT );
	if( !m_bPreviewBackgroundToCharacter )
	{
		nWhich = GetWhich( SID_ATTR_BRUSH );
		if( ISITEMSET )
		{
			const SvxBrushItem& rBrush = ( SvxBrushItem& ) rSet.Get( nWhich );
			if( GPOS_NONE == rBrush.GetGraphicPos() )
				aBackCol = rBrush.GetColor();
		}
	}
	m_aPreviewWin.SetBackColor( aBackCol );

	// Font
	SetPrevFont( rSet, SID_ATTR_CHAR_FONT, rFont );
	SetPrevFont( rSet, SID_ATTR_CHAR_CJK_FONT, rCJKFont );
	SetPrevFont( rSet, SID_ATTR_CHAR_CTL_FONT, rCTLFont );

	// Style
	SetPrevFontStyle( rSet, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, rFont );
	SetPrevFontStyle( rSet, SID_ATTR_CHAR_CJK_POSTURE, SID_ATTR_CHAR_CJK_WEIGHT, rCJKFont );
	SetPrevFontStyle( rSet, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT, rCTLFont );

	// Size
	SetPrevFontSize( rSet, SID_ATTR_CHAR_FONTHEIGHT, rFont );
	SetPrevFontSize( rSet, SID_ATTR_CHAR_CJK_FONTHEIGHT, rCJKFont );
	SetPrevFontSize( rSet, SID_ATTR_CHAR_CTL_FONTHEIGHT, rCTLFont );

	// Color
	nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
	if( ISITEMSET )
	{
		const SvxColorItem& rItem = ( SvxColorItem& ) rSet.Get( nWhich );
		Color aCol( rItem.GetValue() );
		rFont.SetColor( aCol );
        rCJKFont.SetColor( aCol );
		rCTLFont.SetColor( aCol );

		m_aPreviewWin.AutoCorrectFontColor();	// handle color COL_AUTO
	}

	// Kerning
	nWhich = GetWhich( SID_ATTR_CHAR_KERNING );
	if( ISITEMSET )
	{
		const SvxKerningItem& rItem = ( SvxKerningItem& ) rSet.Get( nWhich );
		short nKern = ( short )
						LogicToLogic( rItem.GetValue(), ( MapUnit ) rSet.GetPool()->GetMetric( nWhich ), MAP_TWIP );
		rFont.SetFixKerning( nKern );
        rCJKFont.SetFixKerning( nKern );
		rCTLFont.SetFixKerning( nKern );
	}

	// Escapement
	nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
	const sal_uInt8 nProp = 100;
	short nEsc;
	sal_uInt8 nEscProp;
	if( ISITEMSET )
	{
		const SvxEscapementItem& rItem = ( SvxEscapementItem& ) rSet.Get( nWhich );
		nEsc = rItem.GetEsc();
		nEscProp = rItem.GetProp();

		if( nEsc == DFLT_ESC_AUTO_SUPER )
			nEsc = DFLT_ESC_SUPER;
		else if( nEsc == DFLT_ESC_AUTO_SUB )
			nEsc = DFLT_ESC_SUB;
	}
	else
	{
		nEsc  = 0;
		nEscProp = 100;
	}

	SetPrevFontEscapement( nProp, nEscProp, nEsc );

	// Font width scale
	SetPrevFontWidthScale( rSet );

    m_aPreviewWin.Invalidate();
}

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

void SvxCharBasePage::SetPrevFontSize( const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont )
{
	sal_uInt16 nWhich = GetWhich( nSlot );
	long nH;
	if( rSet.GetItemState( nWhich ) >= SFX_ITEM_SET )
	{
		nH = LogicToLogic(	( ( SvxFontHeightItem& ) rSet.Get( nWhich ) ).GetHeight(),
							( MapUnit ) rSet.GetPool()->GetMetric( nWhich ),
							MAP_TWIP );
	}
	else
		nH = 240;	// as default 12pt

	rFont.SetSize( Size( 0, nH ) );
}

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

void SvxCharBasePage::SetPrevFont( const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont )
{
	sal_uInt16 nWhich = GetWhich( nSlot );
	if( ISITEMSET )
	{
		const SvxFontItem& rFontItem = ( SvxFontItem& ) rSet.Get( nWhich );
		rFont.SetFamily( rFontItem.GetFamily() );
		rFont.SetName( rFontItem.GetFamilyName() );
		rFont.SetPitch( rFontItem.GetPitch() );
		rFont.SetCharSet( rFontItem.GetCharSet() );
		rFont.SetStyleName( rFontItem.GetStyleName() );
	}
}

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

void SvxCharBasePage::SetPrevFontStyle( const SfxItemSet& rSet, sal_uInt16 nPosture, sal_uInt16 nWeight, SvxFont& rFont )
{
	sal_uInt16 nWhich = GetWhich( nPosture );
	if( ISITEMSET )
	{
		const SvxPostureItem& rItem = ( SvxPostureItem& ) rSet.Get( nWhich );
		rFont.SetItalic( ( FontItalic ) rItem.GetValue() != ITALIC_NONE ? ITALIC_NORMAL : ITALIC_NONE );
	}

    nWhich = GetWhich( nWeight );
	if( ISITEMSET )
	{
		SvxWeightItem& rItem = ( SvxWeightItem& ) rSet.Get( nWhich );
		rFont.SetWeight( ( FontWeight ) rItem.GetValue() != WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL );
	}
}

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

void SvxCharBasePage::SetPrevFontWidthScale( const SfxItemSet& rSet )
{
	sal_uInt16	nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
	if( ISITEMSET )
	{
		const SvxCharScaleWidthItem&	rItem = ( SvxCharScaleWidthItem& ) rSet.Get( nWhich );

		m_aPreviewWin.SetFontWidthScale( rItem.GetValue() );
	}
}

// -----------------------------------------------------------------------
namespace
{
	// -----------------------------------------------------------------------
	void setPrevFontEscapement(SvxFont& _rFont,sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc )
	{
		_rFont.SetPropr( nProp );
		_rFont.SetProprRel( nEscProp );
		_rFont.SetEscapement( nEsc );
	}
	// -----------------------------------------------------------------------
	// -----------------------------------------------------------------------
}
// -----------------------------------------------------------------------

void SvxCharBasePage::SetPrevFontEscapement( sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc )
{
	setPrevFontEscapement(GetPreviewFont(),nProp,nEscProp,nEsc);
	setPrevFontEscapement(GetPreviewCJKFont(),nProp,nEscProp,nEsc);
	setPrevFontEscapement(GetPreviewCTLFont(),nProp,nEscProp,nEsc);
    m_aPreviewWin.Invalidate();
}

// SvxCharNamePage_Impl --------------------------------------------------

struct SvxCharNamePage_Impl
{
	Timer			m_aUpdateTimer;
	String			m_aNoStyleText;
	String			m_aTransparentText;
	const FontList*	m_pFontList;
	sal_uInt16			m_nExtraEntryPos;
	sal_Bool			m_bMustDelete;
	sal_Bool			m_bInSearchMode;

	SvxCharNamePage_Impl() :

		m_pFontList		( NULL ),
		m_nExtraEntryPos( LISTBOX_ENTRY_NOTFOUND ),
		m_bMustDelete	( sal_False ),
        m_bInSearchMode ( sal_False )

	{
		m_aUpdateTimer.SetTimeout( 350 );
	}

	~SvxCharNamePage_Impl()
	{
		if ( m_bMustDelete )
			delete m_pFontList;
	}
};

// class SvxCharNamePage -------------------------------------------------

SvxCharNamePage::SvxCharNamePage( Window* pParent, const SfxItemSet& rInSet ) :

	SvxCharBasePage( pParent, CUI_RES( RID_SVXPAGE_CHAR_NAME ), rInSet, WIN_CHAR_PREVIEW, FT_CHAR_FONTTYPE ),
    m_pImpl                 ( new SvxCharNamePage_Impl )
{
	m_pImpl->m_aNoStyleText = String( CUI_RES( STR_CHARNAME_NOSTYLE ) );
	m_pImpl->m_aTransparentText = String( CUI_RES( STR_CHARNAME_TRANSPARENT ) );

	SvtLanguageOptions aLanguageOptions;
    sal_Bool bCJK = ( aLanguageOptions.IsCJKFontEnabled() || aLanguageOptions.IsCTLFontEnabled() );

    m_pWestLine         = new FixedLine( this, CUI_RES( FL_WEST ) );
    m_pWestFontNameFT   = new FixedText( this, CUI_RES( bCJK ? FT_WEST_NAME : FT_WEST_NAME_NOCJK ) );
    m_pWestFontNameLB   = new FontNameBox( this, CUI_RES( bCJK ? LB_WEST_NAME : LB_WEST_NAME_NOCJK ) );
    m_pWestFontStyleFT  = new FixedText( this, CUI_RES( bCJK ? FT_WEST_STYLE : FT_WEST_STYLE_NOCJK ) );
    m_pWestFontStyleLB  = new FontStyleBox( this, CUI_RES( bCJK ? LB_WEST_STYLE : LB_WEST_STYLE_NOCJK ) );
    m_pWestFontSizeFT   = new FixedText( this, CUI_RES( bCJK ? FT_WEST_SIZE : FT_WEST_SIZE_NOCJK ) );
    m_pWestFontSizeLB   = new FontSizeBox( this, CUI_RES( bCJK ? LB_WEST_SIZE : LB_WEST_SIZE_NOCJK ) );

    if( !bCJK )
    {
        m_pColorFL  = new FixedLine( this, CUI_RES( FL_COLOR2 ) );
        m_pColorFT  = new FixedText( this, CUI_RES( FT_COLOR2 ) );
        m_pColorLB  = new ColorListBox( this, CUI_RES( LB_COLOR2 ) );
    }

    m_pWestFontLanguageFT   = new FixedText( this, CUI_RES( bCJK ? FT_WEST_LANG : FT_WEST_LANG_NOCJK ) );
    m_pWestFontLanguageLB   = new SvxLanguageBox( this, CUI_RES( bCJK ? LB_WEST_LANG : LB_WEST_LANG_NOCJK ) );

    m_pEastLine             = new FixedLine( this, CUI_RES( FL_EAST ) );
    m_pEastFontNameFT       = new FixedText( this, CUI_RES( FT_EAST_NAME ) );
    m_pEastFontNameLB       = new FontNameBox( this, CUI_RES( LB_EAST_NAME ) );
    m_pEastFontStyleFT      = new FixedText( this, CUI_RES( FT_EAST_STYLE ) );
    m_pEastFontStyleLB      = new FontStyleBox( this, CUI_RES( LB_EAST_STYLE ) );
    m_pEastFontSizeFT       = new FixedText( this, CUI_RES( FT_EAST_SIZE ) );
    m_pEastFontSizeLB       = new FontSizeBox( this, CUI_RES( LB_EAST_SIZE ) );
    m_pEastFontLanguageFT   = new FixedText( this, CUI_RES( FT_EAST_LANG ) );
    m_pEastFontLanguageLB   = new SvxLanguageBox( this, CUI_RES( LB_EAST_LANG ) );

    m_pCTLLine              = new FixedLine( this, CUI_RES( FL_CTL ) );
    m_pCTLFontNameFT        = new FixedText( this, CUI_RES( FT_CTL_NAME ) );
    m_pCTLFontNameLB        = new FontNameBox( this, CUI_RES( LB_CTL_NAME ) );
    m_pCTLFontStyleFT		= new FixedText( this, CUI_RES( FT_CTL_STYLE ) );
    m_pCTLFontStyleLB		= new FontStyleBox( this, CUI_RES( LB_CTL_STYLE ) );
    m_pCTLFontSizeFT		= new FixedText( this, CUI_RES( FT_CTL_SIZE ) );
    m_pCTLFontSizeLB		= new FontSizeBox( this, CUI_RES( LB_CTL_SIZE ) );
    m_pCTLFontLanguageFT	= new FixedText( this, CUI_RES( FT_CTL_LANG ) );
    m_pCTLFontLanguageLB	= new SvxLanguageBox( this, CUI_RES( LB_CTL_LANG ) );

    if( bCJK )
    {
        m_pColorFL  = new FixedLine( this, CUI_RES( FL_COLOR2 ) );
        m_pColorFT  = new FixedText( this, CUI_RES( FT_COLOR2 ) );
        m_pColorLB  = new ColorListBox( this, CUI_RES( LB_COLOR2 ) );
    }

    m_pWestLine             ->Show( bCJK );
    m_pColorFL              ->Show( bCJK );

	bCJK = aLanguageOptions.IsCJKFontEnabled();
	m_pEastLine             ->Show( bCJK );
    m_pEastFontNameFT       ->Show( bCJK );
    m_pEastFontNameLB       ->Show( bCJK );
    m_pEastFontStyleFT      ->Show( bCJK );
    m_pEastFontStyleLB      ->Show( bCJK );
    m_pEastFontSizeFT       ->Show( bCJK );
    m_pEastFontSizeLB       ->Show( bCJK );
    m_pEastFontLanguageFT   ->Show( bCJK );
    m_pEastFontLanguageLB   ->Show( bCJK );

	sal_Bool bShowCTL = aLanguageOptions.IsCTLFontEnabled();
	if ( bShowCTL && !bCJK )
	{
		// move CTL controls to the places of the CJK controls, if these controls aren't visible
		m_pCTLLine             ->SetPosPixel( m_pEastLine->GetPosPixel() );
    	m_pCTLFontNameFT       ->SetPosPixel( m_pEastFontNameFT->GetPosPixel() );
    	m_pCTLFontNameLB       ->SetPosPixel( m_pEastFontNameLB->GetPosPixel() );
    	m_pCTLFontStyleFT      ->SetPosPixel( m_pEastFontStyleFT->GetPosPixel() );
    	m_pCTLFontStyleLB      ->SetPosPixel( m_pEastFontStyleLB->GetPosPixel() );
    	m_pCTLFontSizeFT       ->SetPosPixel( m_pEastFontSizeFT->GetPosPixel() );
    	m_pCTLFontSizeLB       ->SetPosPixel( m_pEastFontSizeLB->GetPosPixel() );
    	m_pCTLFontLanguageFT   ->SetPosPixel( m_pEastFontLanguageFT->GetPosPixel() );
    	m_pCTLFontLanguageLB   ->SetPosPixel( m_pEastFontLanguageLB->GetPosPixel() );
	}
	m_pCTLLine             ->Show( bShowCTL );
    m_pCTLFontNameFT       ->Show( bShowCTL );
    m_pCTLFontNameLB       ->Show( bShowCTL );
    m_pCTLFontStyleFT      ->Show( bShowCTL );
    m_pCTLFontStyleLB      ->Show( bShowCTL );
    m_pCTLFontSizeFT       ->Show( bShowCTL );
    m_pCTLFontSizeLB       ->Show( bShowCTL );
    m_pCTLFontLanguageFT   ->Show( bShowCTL );
    m_pCTLFontLanguageLB   ->Show( bShowCTL );

    FreeResource();

    m_pWestFontLanguageLB->SetLanguageList( LANG_LIST_WESTERN,	sal_True, sal_False, sal_True );
    m_pEastFontLanguageLB->SetLanguageList( LANG_LIST_CJK,		sal_True, sal_False, sal_True );
    m_pCTLFontLanguageLB->SetLanguageList( LANG_LIST_CTL,		sal_True, sal_False, sal_True );

	Initialize();
}

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

SvxCharNamePage::~SvxCharNamePage()
{
	delete m_pImpl;

    delete m_pWestLine;
    delete m_pWestFontNameFT;
    delete m_pWestFontNameLB;
    delete m_pWestFontStyleFT;
    delete m_pWestFontStyleLB;
    delete m_pWestFontSizeFT;
    delete m_pWestFontSizeLB;
    delete m_pWestFontLanguageFT;
    delete m_pWestFontLanguageLB;

    delete m_pEastLine;
    delete m_pEastFontNameFT;
    delete m_pEastFontNameLB;
    delete m_pEastFontStyleFT;
    delete m_pEastFontStyleLB;
    delete m_pEastFontSizeFT;
    delete m_pEastFontSizeLB;
    delete m_pEastFontLanguageFT;
    delete m_pEastFontLanguageLB;

    delete m_pCTLLine;
    delete m_pCTLFontNameFT;
    delete m_pCTLFontNameLB;
    delete m_pCTLFontStyleFT;
    delete m_pCTLFontStyleLB;
    delete m_pCTLFontSizeFT;
    delete m_pCTLFontSizeLB;
    delete m_pCTLFontLanguageFT;
    delete m_pCTLFontLanguageLB;

    delete m_pColorFL;
    delete m_pColorFT;
    delete m_pColorLB;
}

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

void SvxCharNamePage::Initialize()
{
	// to handle the changes of the other pages
	SetExchangeSupport();

	// fill the color box
	SfxObjectShell* pDocSh = SfxObjectShell::Current();
	//DBG_ASSERT( pDocSh, "DocShell not found!" );
	XColorTable* pColorTable = NULL;
	FASTBOOL bKillTable = sal_False;
	const SfxPoolItem* pItem = NULL;

	if ( pDocSh )
    {
        pItem = pDocSh->GetItem( SID_COLOR_TABLE );
        if ( pItem != NULL )
            pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
    }

	if ( !pColorTable )
	{
		pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
		bKillTable = sal_True;
	}

    m_pColorLB->SetUpdateMode( sal_False );

	{
		SfxPoolItem* pDummy;
		SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocSh );
		if( !pFrame || SFX_ITEM_DEFAULT > pFrame->GetBindings().QueryState(
									SID_ATTR_AUTO_COLOR_INVALID, pDummy ))
	    	m_pColorLB->InsertEntry( Color( COL_AUTO ),
								 	SVX_RESSTR( RID_SVXSTR_AUTOMATIC ));
	}
    for ( long i = 0; i < pColorTable->Count(); i++ )
	{
        XColorEntry* pEntry = pColorTable->GetColor(i);
        m_pColorLB->InsertEntry( pEntry->GetColor(), pEntry->GetName() );
	}

    m_pColorLB->SetUpdateMode( sal_True );

	if ( bKillTable )
		delete pColorTable;

    m_pColorLB->SetSelectHdl( LINK( this, SvxCharNamePage, ColorBoxSelectHdl_Impl ) );

	Link aLink = LINK( this, SvxCharNamePage, FontModifyHdl_Impl );
    m_pWestFontNameLB->SetModifyHdl( aLink );
    m_pWestFontStyleLB->SetModifyHdl( aLink );
    m_pWestFontSizeLB->SetModifyHdl( aLink );
    m_pEastFontNameLB->SetModifyHdl( aLink );
    m_pEastFontStyleLB->SetModifyHdl( aLink );
    m_pEastFontSizeLB->SetModifyHdl( aLink );
    m_pCTLFontNameLB->SetModifyHdl( aLink );
    m_pCTLFontStyleLB->SetModifyHdl( aLink );
    m_pCTLFontSizeLB->SetModifyHdl( aLink );

	m_pImpl->m_aUpdateTimer.SetTimeoutHdl( LINK( this, SvxCharNamePage, UpdateHdl_Impl ) );

    m_pColorFL->Hide();
    m_pColorFT->Hide();
    m_pColorLB->Hide();
}

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

const FontList* SvxCharNamePage::GetFontList() const
{
    if ( !m_pImpl->m_pFontList )
    {
        SfxObjectShell* pDocSh = SfxObjectShell::Current();
        const SfxPoolItem* pItem;

        /* #110771# SvxFontListItem::GetFontList can return NULL */
        if ( pDocSh )
        {
            pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST );
            if ( pItem != NULL )
            {
                DBG_ASSERT(NULL != ( (SvxFontListItem*)pItem )->GetFontList(),
                           "Where is the font list?");
                    m_pImpl->m_pFontList =  static_cast<const SvxFontListItem*>(pItem )->GetFontList()->Clone();
                m_pImpl->m_bMustDelete = sal_True;
            }
        }
        if(!m_pImpl->m_pFontList)
        {
            m_pImpl->m_pFontList =
                new FontList( Application::GetDefaultDevice() );
            m_pImpl->m_bMustDelete = sal_True;
        }
    }

    return m_pImpl->m_pFontList;
}

// -----------------------------------------------------------------------------
namespace
{
	FontInfo calcFontInfo(	SvxFont& _rFont,
					SvxCharNamePage* _pPage,
					const FontNameBox* _pFontNameLB,
					const FontStyleBox* _pFontStyleLB,
					const FontSizeBox* _pFontSizeLB,
					const FontList* _pFontList,
					sal_uInt16 _nFontWhich,
					sal_uInt16 _nFontHeightWhich)
	{
		Size aSize = _rFont.GetSize();
		aSize.Width() = 0;
		FontInfo aFontInfo;
		String sFontName(_pFontNameLB->GetText());
		sal_Bool bFontAvailable = _pFontList->IsAvailable( sFontName );
		if(bFontAvailable  || _pFontNameLB->GetSavedValue() != sFontName)
			aFontInfo = _pFontList->Get( sFontName, _pFontStyleLB->GetText() );
		else
		{
			//get the font from itemset
			SfxItemState eState = _pPage->GetItemSet().GetItemState( _nFontWhich );
			if ( eState >= SFX_ITEM_DEFAULT )
			{
				const SvxFontItem* pFontItem = (const SvxFontItem*)&( _pPage->GetItemSet().Get( _nFontWhich ) );
				aFontInfo.SetName(pFontItem->GetFamilyName());
				aFontInfo.SetStyleName(pFontItem->GetStyleName());
				aFontInfo.SetFamily(pFontItem->GetFamily());
				aFontInfo.SetPitch(pFontItem->GetPitch());
				aFontInfo.SetCharSet(pFontItem->GetCharSet());
			}
		}
		if ( _pFontSizeLB->IsRelative() )
		{
			DBG_ASSERT( _pPage->GetItemSet().GetParent(), "No parent set" );
			const SvxFontHeightItem& rOldItem = (SvxFontHeightItem&)_pPage->GetItemSet().GetParent()->Get( _nFontHeightWhich );

			// alter Wert, skaliert
			long nHeight;
			if ( _pFontSizeLB->IsPtRelative() )
				nHeight = rOldItem.GetHeight() + PointToTwips( static_cast<long>(_pFontSizeLB->GetValue() / 10) );
			else
				nHeight = static_cast<long>(rOldItem.GetHeight() * _pFontSizeLB->GetValue() / 100);

			// Umrechnung in twips fuer das Beispiel-Window
			aSize.Height() =
				ItemToControl( nHeight, _pPage->GetItemSet().GetPool()->GetMetric( _nFontHeightWhich ), SFX_FUNIT_TWIP );
		}
		else if ( _pFontSizeLB->GetText().Len() )
			aSize.Height() = PointToTwips( static_cast<long>(_pFontSizeLB->GetValue() / 10) );
		else
			aSize.Height() = 200;	// default 10pt
		aFontInfo.SetSize( aSize );

		_rFont.SetFamily( aFontInfo.GetFamily() );
		_rFont.SetName( aFontInfo.GetName() );
		_rFont.SetStyleName( aFontInfo.GetStyleName() );
		_rFont.SetPitch( aFontInfo.GetPitch() );
		_rFont.SetCharSet( aFontInfo.GetCharSet() );
		_rFont.SetWeight( aFontInfo.GetWeight() );
		_rFont.SetItalic( aFontInfo.GetItalic() );
		_rFont.SetSize( aFontInfo.GetSize() );

		return aFontInfo;
	}
}

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

void SvxCharNamePage::UpdatePreview_Impl()
{
	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();
	// Size
	Size aSize = rFont.GetSize();
	aSize.Width() = 0;
    Size aCJKSize = rCJKFont.GetSize();
    aCJKSize.Width() = 0;
	Size aCTLSize = rCTLFont.GetSize();
    aCTLSize.Width() = 0;
	// Font
	const FontList* pFontList = GetFontList();
	FontInfo aFontInfo =
		calcFontInfo(rFont,this,m_pWestFontNameLB,m_pWestFontStyleLB,m_pWestFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_FONT ),GetWhich( SID_ATTR_CHAR_FONTHEIGHT ));

	calcFontInfo(rCJKFont,this,m_pEastFontNameLB,m_pEastFontStyleLB,m_pEastFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_CJK_FONT ),GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ));

	calcFontInfo(rCTLFont,this,m_pCTLFontNameLB,m_pCTLFontStyleLB,m_pCTLFontSizeLB,pFontList,GetWhich( SID_ATTR_CHAR_CTL_FONT ),GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ));

    m_aPreviewWin.Invalidate();
    m_aFontTypeFT.SetText( pFontList->GetFontMapText( aFontInfo ) );
}

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

void SvxCharNamePage::FillStyleBox_Impl( const FontNameBox* pNameBox )
{
	const FontList* pFontList = GetFontList();
	DBG_ASSERT( pFontList, "no fontlist" );

	FontStyleBox* pStyleBox = NULL;

    if ( m_pWestFontNameLB == pNameBox )
		pStyleBox = m_pWestFontStyleLB;
    else if ( m_pEastFontNameLB == pNameBox )
		pStyleBox = m_pEastFontStyleLB;
    else if ( m_pCTLFontNameLB == pNameBox )
        pStyleBox = m_pCTLFontStyleLB;
	else
	{
		DBG_ERRORFILE( "invalid font name box" );
	}

	pStyleBox->Fill( pNameBox->GetText(), pFontList );

	if ( m_pImpl->m_bInSearchMode )
	{
		// Bei der Suche zus"atzliche Eintr"age:
		// "Nicht Fett" und "Nicht Kursiv"
		String aEntry = m_pImpl->m_aNoStyleText;
		const sal_Char sS[] = "%1";
		aEntry.SearchAndReplaceAscii( sS, pFontList->GetBoldStr() );
        m_pImpl->m_nExtraEntryPos = pStyleBox->InsertEntry( aEntry );
		aEntry = m_pImpl->m_aNoStyleText;
		aEntry.SearchAndReplaceAscii( sS, pFontList->GetItalicStr() );
        pStyleBox->InsertEntry( aEntry );
	}
}

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

void SvxCharNamePage::FillSizeBox_Impl( const FontNameBox* pNameBox )
{
	const FontList* pFontList = GetFontList();
	DBG_ASSERT( pFontList, "no fontlist" );

	FontStyleBox* pStyleBox = NULL;
	FontSizeBox* pSizeBox = NULL;

    if ( m_pWestFontNameLB == pNameBox )
	{
		pStyleBox = m_pWestFontStyleLB;
		pSizeBox = m_pWestFontSizeLB;
	}
    else if ( m_pEastFontNameLB == pNameBox )
	{
		pStyleBox = m_pEastFontStyleLB;
		pSizeBox = m_pEastFontSizeLB;
	}
    else if ( m_pCTLFontNameLB == pNameBox )
	{
        pStyleBox = m_pCTLFontStyleLB;
		pSizeBox = m_pCTLFontSizeLB;
	}
	else
	{
		DBG_ERRORFILE( "invalid font name box" );
	}

	FontInfo _aFontInfo( pFontList->Get( pNameBox->GetText(), pStyleBox->GetText() ) );
	pSizeBox->Fill( &_aFontInfo, pFontList );
}

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

void SvxCharNamePage::Reset_Impl( const SfxItemSet& rSet, LanguageGroup eLangGrp )
{
    FixedText* pNameLabel = NULL;
    FontNameBox* pNameBox = NULL;
    FixedText* pStyleLabel = NULL;
    FontStyleBox* pStyleBox = NULL;
    FixedText* pSizeLabel = NULL;
    FontSizeBox* pSizeBox = NULL;
    FixedText* pLangFT = NULL;
    SvxLanguageBox* pLangBox = NULL;
	sal_uInt16 nWhich = 0;

	switch ( eLangGrp )
	{
		case Western :
			pNameLabel = m_pWestFontNameFT;
			pNameBox = m_pWestFontNameLB;
			pStyleLabel = m_pWestFontStyleFT;
			pStyleBox = m_pWestFontStyleLB;
			pSizeLabel = m_pWestFontSizeFT;
			pSizeBox = m_pWestFontSizeLB;
			pLangFT = m_pWestFontLanguageFT;
			pLangBox = m_pWestFontLanguageLB;
			nWhich = GetWhich( SID_ATTR_CHAR_FONT );
			break;

		case Asian :
			pNameLabel = m_pEastFontNameFT;
			pNameBox = m_pEastFontNameLB;
			pStyleLabel = m_pEastFontStyleFT;
			pStyleBox = m_pEastFontStyleLB;
			pSizeLabel = m_pEastFontSizeFT;
			pSizeBox = m_pEastFontSizeLB;
			pLangFT = m_pEastFontLanguageFT;
			pLangBox = m_pEastFontLanguageLB;
			nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONT );
			break;

		case Ctl :
			pNameLabel = m_pCTLFontNameFT;
			pNameBox = m_pCTLFontNameLB;
			pStyleLabel = m_pCTLFontStyleFT;
			pStyleBox = m_pCTLFontStyleLB;
			pSizeLabel = m_pCTLFontSizeFT;
			pSizeBox = m_pCTLFontSizeLB;
			pLangFT = m_pCTLFontLanguageFT;
			pLangBox = m_pCTLFontLanguageLB;
			nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONT );
			break;
	}

	// die FontListBox fuellen
	const FontList* pFontList = GetFontList();
	pNameBox->Fill( pFontList );

	// Font ermitteln
	const SvxFontItem* pFontItem = NULL;
	SfxItemState eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DEFAULT )
	{
		pFontItem = (const SvxFontItem*)&( rSet.Get( nWhich ) );
		pNameBox->SetText( pFontItem->GetFamilyName() );
	}
	else
	{
		pNameBox->SetText( String() );
	}

	FillStyleBox_Impl( pNameBox );

	FASTBOOL bStyle = sal_False;
	FASTBOOL bStyleAvailable = sal_True;
	FontItalic eItalic = ITALIC_NONE;
	FontWeight eWeight = WEIGHT_NORMAL;
	switch ( eLangGrp )
	{
		case Western : nWhich = GetWhich( SID_ATTR_CHAR_POSTURE ); break;
		case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_POSTURE ); break;
		case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_POSTURE ); break;
	}
	eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DEFAULT )
	{
		const SvxPostureItem& rItem = (SvxPostureItem&)rSet.Get( nWhich );
		eItalic = (FontItalic)rItem.GetValue();
		bStyle = sal_True;
	}
	bStyleAvailable = bStyleAvailable && (eState >= SFX_ITEM_DONTCARE);

	switch ( eLangGrp )
	{
		case Western : nWhich = GetWhich( SID_ATTR_CHAR_WEIGHT ); break;
		case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_WEIGHT ); break;
		case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_WEIGHT ); break;
	}
	eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DEFAULT )
	{
		SvxWeightItem& rItem = (SvxWeightItem&)rSet.Get( nWhich );
		eWeight = (FontWeight)rItem.GetValue();
	}
	else
		bStyle = sal_False;
	bStyleAvailable = bStyleAvailable && (eState >= SFX_ITEM_DONTCARE);

	// Aktuell eingestellter Font
	if ( bStyle && pFontItem )
	{
		FontInfo aInfo = pFontList->Get( pFontItem->GetFamilyName(), eWeight, eItalic );
		pStyleBox->SetText( pFontList->GetStyleName( aInfo ) );
	}
	else if ( !m_pImpl->m_bInSearchMode || !bStyle )
	{
		pStyleBox->SetText( String() );
	}
	else if ( bStyle )
	{
		FontInfo aInfo = pFontList->Get( String(), eWeight, eItalic );
		pStyleBox->SetText( pFontList->GetStyleName( aInfo ) );
	}
	if (!bStyleAvailable)
	{
		pStyleBox->Disable( );
		pStyleLabel->Disable( );
	}

	// SizeBox fuellen
	FillSizeBox_Impl( pNameBox );
	switch ( eLangGrp )
	{
		case Western : nWhich = GetWhich( SID_ATTR_CHAR_FONTHEIGHT ); break;
		case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ); break;
		case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ); break;
	}
	eState = rSet.GetItemState( nWhich );

	if ( pSizeBox->IsRelativeMode() )
	{
		SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
		const SvxFontHeightItem& rItem = (SvxFontHeightItem&)rSet.Get( nWhich );

		if( rItem.GetProp() != 100 || SFX_MAPUNIT_RELATIVE != rItem.GetPropUnit() )
		{
			sal_Bool bPtRel = SFX_MAPUNIT_POINT == rItem.GetPropUnit();
			pSizeBox->SetPtRelative( bPtRel );
			pSizeBox->SetValue( bPtRel ? ((short)rItem.GetProp()) * 10 : rItem.GetProp() );
		}
		else
		{
			pSizeBox->SetRelative();
			pSizeBox->SetValue( (long)CalcToPoint( rItem.GetHeight(), eUnit, 10 ) );
		}
	}
	else if ( eState >= SFX_ITEM_DEFAULT )
	{
		SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
		const SvxFontHeightItem& rItem = (SvxFontHeightItem&)rSet.Get( nWhich );
		pSizeBox->SetValue( (long)CalcToPoint( rItem.GetHeight(), eUnit, 10 ) );
	}
	else
	{
		pSizeBox->SetText( String() );
		if ( eState <= SFX_ITEM_READONLY )
		{
			pSizeBox->Disable( );
			pSizeLabel->Disable( );
		}
	}

	switch ( eLangGrp )
	{
		case Western : nWhich = GetWhich( SID_ATTR_CHAR_LANGUAGE ); break;
		case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_LANGUAGE ); break;
		case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_LANGUAGE ); break;
	}
	pLangBox->SetNoSelection();
	eState = rSet.GetItemState( nWhich );

	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			pLangFT->Hide();
			pLangBox->Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			pLangFT->Disable();
			pLangBox->Disable();
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxLanguageItem& rItem = (SvxLanguageItem&)rSet.Get( nWhich );
			LanguageType eLangType = (LanguageType)rItem.GetValue();
			DBG_ASSERT( eLangType != LANGUAGE_SYSTEM, "LANGUAGE_SYSTEM not allowed" );
			if ( eLangType != LANGUAGE_DONTKNOW )
                pLangBox->SelectLanguage( eLangType );
			break;
		}
	}

	if ( Western == eLangGrp )
        m_aFontTypeFT.SetText( pFontList->GetFontMapText(
			pFontList->Get( pNameBox->GetText(), pStyleBox->GetText() ) ) );

	// save these settings
	pNameBox->SaveValue();
	pStyleBox->SaveValue();
	pSizeBox->SaveValue();
	pLangBox->SaveValue();
}

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

sal_Bool SvxCharNamePage::FillItemSet_Impl( SfxItemSet& rSet, LanguageGroup eLangGrp )
{
	sal_Bool bModified = sal_False;

    FontNameBox* pNameBox = NULL;
    FontStyleBox* pStyleBox = NULL;
    FontSizeBox* pSizeBox = NULL;
    SvxLanguageBox* pLangBox = NULL;
	sal_uInt16 nWhich = 0;
	sal_uInt16 nSlot = 0;

	switch ( eLangGrp )
	{
		case Western :
			pNameBox = m_pWestFontNameLB;
			pStyleBox = m_pWestFontStyleLB;
			pSizeBox = m_pWestFontSizeLB;
			pLangBox = m_pWestFontLanguageLB;
			nSlot = SID_ATTR_CHAR_FONT;
			break;

		case Asian :
			pNameBox = m_pEastFontNameLB;
			pStyleBox = m_pEastFontStyleLB;
			pSizeBox = m_pEastFontSizeLB;
			pLangBox = m_pEastFontLanguageLB;
			nSlot = SID_ATTR_CHAR_CJK_FONT;
			break;

		case Ctl :
			pNameBox = m_pCTLFontNameLB;
			pStyleBox = m_pCTLFontStyleLB;
			pSizeBox = m_pCTLFontSizeLB;
			pLangBox = m_pCTLFontLanguageLB;
			nSlot = SID_ATTR_CHAR_CTL_FONT;
			break;
	}

	nWhich = GetWhich( nSlot );
	const SfxPoolItem* pItem = NULL;
	const SfxItemSet& rOldSet = GetItemSet();
	const SfxPoolItem* pOld = NULL;

	const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;

	FASTBOOL bChanged = sal_True;
	const String& rFontName  = pNameBox->GetText();
	const FontList* pFontList = GetFontList();
	String aStyleBoxText =pStyleBox->GetText();
	sal_uInt16 nEntryPos = pStyleBox->GetEntryPos( aStyleBoxText );
	if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
		aStyleBoxText.Erase();
	FontInfo aInfo( pFontList->Get( rFontName, aStyleBoxText ) );
	SvxFontItem aFontItem( aInfo.GetFamily(), aInfo.GetName(), aInfo.GetStyleName(),
						   aInfo.GetPitch(), aInfo.GetCharSet(), nWhich );
	pOld = GetOldItem( rSet, nSlot );

	if ( pOld )
	{
		const SvxFontItem& rItem = *( (const SvxFontItem*)pOld );

		if ( rItem.GetFamilyName() == aFontItem.GetFamilyName() )
			bChanged = sal_False;
	}

	if ( !bChanged )
		bChanged = !pNameBox->GetSavedValue().Len();

	if ( !bChanged && pExampleSet &&
		 pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 ( (SvxFontItem*)pItem )->GetFamilyName() != aFontItem.GetFamilyName() )
		bChanged = sal_True;

	if ( bChanged && rFontName.Len() )
	{
		rSet.Put( aFontItem );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		rSet.ClearItem( nWhich );


	bChanged = sal_True;
	switch ( eLangGrp )
	{
		case Western : nSlot = SID_ATTR_CHAR_WEIGHT; break;
		case Asian : nSlot = SID_ATTR_CHAR_CJK_WEIGHT; break;
		case Ctl : nSlot = SID_ATTR_CHAR_CTL_WEIGHT; break;
	}
	nWhich = GetWhich( nSlot );
	FontWeight eWeight = aInfo.GetWeight();
	if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
		eWeight = WEIGHT_NORMAL;
	SvxWeightItem aWeightItem( eWeight, nWhich );
	pOld = GetOldItem( rSet, nSlot );

	if ( pOld )
	{
		const SvxWeightItem& rItem = *( (const SvxWeightItem*)pOld );

		if ( rItem.GetValue() == aWeightItem.GetValue() )
			bChanged = sal_False;
	}

	if ( !bChanged )
	{
		bChanged = !pStyleBox->GetSavedValue().Len();

		if ( m_pImpl->m_bInSearchMode && bChanged &&
			 aInfo.GetWeight() == WEIGHT_NORMAL && aInfo.GetItalic() != ITALIC_NONE )
			bChanged = sal_False;
	}

	if ( !bChanged && pExampleSet &&
		 pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 ( (SvxWeightItem*)pItem )->GetValue() != aWeightItem.GetValue() )
		bChanged = sal_True;

	if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
		bChanged = ( nEntryPos == m_pImpl->m_nExtraEntryPos );

	String aText( pStyleBox->GetText() ); // Tristate, dann Text leer

	if ( bChanged && aText.Len() )
	{
		rSet.Put( aWeightItem );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;
	switch ( eLangGrp )
	{
		case Western : nSlot = SID_ATTR_CHAR_POSTURE; break;
		case Asian : nSlot = SID_ATTR_CHAR_CJK_POSTURE; break;
		case Ctl : nSlot = SID_ATTR_CHAR_CTL_POSTURE; break;
	}
	nWhich = GetWhich( nSlot );
	FontItalic eItalic = aInfo.GetItalic();
	if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
		eItalic = ITALIC_NONE;
	SvxPostureItem aPostureItem( eItalic, nWhich );
	pOld = GetOldItem( rSet, nSlot );

	if ( pOld )
	{
		const SvxPostureItem& rItem = *( (const SvxPostureItem*)pOld );

		if ( rItem.GetValue() == aPostureItem.GetValue() )
			bChanged = sal_False;
	}

	if ( !bChanged )
	{
		bChanged = !pStyleBox->GetSavedValue().Len();

		if ( m_pImpl->m_bInSearchMode && bChanged &&
			 aInfo.GetItalic() == ITALIC_NONE && aInfo.GetWeight() != WEIGHT_NORMAL )
			bChanged = sal_False;
	}

	if ( !bChanged && pExampleSet &&
		 pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 ( (SvxPostureItem*)pItem )->GetValue() != aPostureItem.GetValue() )
		bChanged = sal_True;

	if ( nEntryPos >= m_pImpl->m_nExtraEntryPos )
		bChanged = ( nEntryPos == ( m_pImpl->m_nExtraEntryPos + 1 ) );

	if ( bChanged && aText.Len() )
	{
		rSet.Put( aPostureItem );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	// FontSize
	long nSize = static_cast<long>(pSizeBox->GetValue());

	if ( !pSizeBox->GetText().Len() )	// GetValue() gibt dann Min-Wert zurueck
		nSize = 0;
	long nSavedSize = pSizeBox->GetSavedValue().ToInt32();
	FASTBOOL bRel = sal_True;

	if ( !pSizeBox->IsRelative() )
	{
		nSavedSize *= 10;
		bRel = sal_False;
	}

	switch ( eLangGrp )
	{
		case Western : nSlot = SID_ATTR_CHAR_FONTHEIGHT; break;
		case Asian : nSlot = SID_ATTR_CHAR_CJK_FONTHEIGHT; break;
		case Ctl : nSlot = SID_ATTR_CHAR_CTL_FONTHEIGHT; break;
	}
	nWhich = GetWhich( nSlot );
	const SvxFontHeightItem* pOldHeight = (const SvxFontHeightItem*)GetOldItem( rSet, nSlot );
	bChanged = ( nSize != nSavedSize );

	if ( !bChanged && pExampleSet &&
		 pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET )
	{
		float fSize = (float)nSize / 10;
		long nVal = CalcToUnit( fSize, rSet.GetPool()->GetMetric( nWhich ) );
		if ( ( (SvxFontHeightItem*)pItem )->GetHeight() != (sal_uInt32)nVal )
			bChanged = sal_True;
	}

	if ( bChanged || !pOldHeight ||
		 bRel != ( SFX_MAPUNIT_RELATIVE != pOldHeight->GetPropUnit() || 100 != pOldHeight->GetProp() ) )
	{
		SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
		if ( pSizeBox->IsRelative() )
		{
			DBG_ASSERT( GetItemSet().GetParent(), "No parent set" );
			const SvxFontHeightItem& rOldItem =
				(const SvxFontHeightItem&)GetItemSet().GetParent()->Get( nWhich );

			SvxFontHeightItem aHeight( 240, 100, nWhich );
			if ( pSizeBox->IsPtRelative() )
				aHeight.SetHeight( rOldItem.GetHeight(), (sal_uInt16)( nSize / 10 ), SFX_MAPUNIT_POINT, eUnit );
			else
				aHeight.SetHeight( rOldItem.GetHeight(), (sal_uInt16)nSize, SFX_MAPUNIT_RELATIVE );
			rSet.Put( aHeight );
		}
		else
		{
			float fSize = (float)nSize / 10;
			rSet.Put( SvxFontHeightItem( CalcToUnit( fSize, eUnit ), 100, nWhich ) );
		}
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;
	switch ( eLangGrp )
	{
		case Western : nSlot = SID_ATTR_CHAR_LANGUAGE; break;
		case Asian : nSlot = SID_ATTR_CHAR_CJK_LANGUAGE; break;
		case Ctl : nSlot = SID_ATTR_CHAR_CTL_LANGUAGE; break;
	}
	nWhich = GetWhich( nSlot );
	pOld = GetOldItem( rSet, nSlot );
	sal_uInt16 nLangPos = pLangBox->GetSelectEntryPos();
	LanguageType eLangType = (LanguageType)(sal_uLong)pLangBox->GetEntryData( nLangPos );

	if ( pOld )
	{
		const SvxLanguageItem& rItem = *( (const SvxLanguageItem*)pOld );

		if ( nLangPos == LISTBOX_ENTRY_NOTFOUND || eLangType == (LanguageType)rItem.GetValue() )
			bChanged = sal_False;
	}

	if ( !bChanged )
		bChanged = ( pLangBox->GetSavedValue() == LISTBOX_ENTRY_NOTFOUND );

	if ( bChanged && nLangPos != LISTBOX_ENTRY_NOTFOUND )
	{
		rSet.Put( SvxLanguageItem( eLangType, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	return bModified;
}

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

void SvxCharNamePage::ResetColor_Impl( const SfxItemSet& rSet )
{
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
	SfxItemState eState = rSet.GetItemState( nWhich );

	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
            m_pColorLB->Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
            m_pColorLB->Disable();
			break;

		case SFX_ITEM_DONTCARE:
            m_pColorLB->SetNoSelection();
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			SvxFont& rFont = GetPreviewFont();
            SvxFont& rCJKFont = GetPreviewCJKFont();
			SvxFont& rCTLFont = GetPreviewCTLFont();
			const SvxColorItem& rItem = (SvxColorItem&)rSet.Get( nWhich );
			Color aColor = rItem.GetValue();
            rFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
            rCJKFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
			rCTLFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
			m_aPreviewWin.Invalidate();
            sal_uInt16 nSelPos = m_pColorLB->GetEntryPos( aColor );
			if ( nSelPos == LISTBOX_ENTRY_NOTFOUND && aColor == Color( COL_TRANSPARENT ) )
                nSelPos = m_pColorLB->GetEntryPos( m_pImpl->m_aTransparentText );

			if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
                m_pColorLB->SelectEntryPos( nSelPos );
			else
			{
                nSelPos = m_pColorLB->GetEntryPos( aColor );
				if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
                    m_pColorLB->SelectEntryPos( nSelPos );
				else
                    m_pColorLB->SelectEntryPos(
                        m_pColorLB->InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
			}
			break;
		}
	}
}

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

IMPL_LINK( SvxCharNamePage, UpdateHdl_Impl, Timer*, EMPTYARG )
{
	UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharNamePage, FontModifyHdl_Impl, void*, pNameBox )
{
	m_pImpl->m_aUpdateTimer.Start();

    if ( m_pWestFontNameLB == pNameBox || m_pEastFontNameLB == pNameBox || m_pCTLFontNameLB == pNameBox )
	{
		FillStyleBox_Impl( (FontNameBox*)pNameBox );
		FillSizeBox_Impl( (FontNameBox*)pNameBox );
	}
	return 0;
}

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

IMPL_LINK( SvxCharNamePage, ColorBoxSelectHdl_Impl, ColorListBox*, pBox )
{
	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();
	Color aSelectedColor;
	if ( pBox->GetSelectEntry() == m_pImpl->m_aTransparentText )
		aSelectedColor = Color( COL_TRANSPARENT );
	else
		aSelectedColor = pBox->GetSelectEntryColor();
    rFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
    rCJKFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
	rCTLFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
    m_aPreviewWin.Invalidate();
	return 0;
}

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

void SvxCharNamePage::ActivatePage( const SfxItemSet& rSet )
{
	SvxCharBasePage::ActivatePage( rSet );

	UpdatePreview_Impl();		// instead of asynchronous calling in ctor
}

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

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

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

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

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

sal_uInt16* SvxCharNamePage::GetRanges()
{
	return pNameRanges;
}

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

void SvxCharNamePage::Reset( const SfxItemSet& rSet )
{
	Reset_Impl( rSet, Western );
	Reset_Impl( rSet, Asian );
	Reset_Impl( rSet, Ctl );
	ResetColor_Impl( rSet );
    m_pColorLB->SaveValue();

	SetPrevFontWidthScale( rSet );
	UpdatePreview_Impl();
}

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

sal_Bool SvxCharNamePage::FillItemSet( SfxItemSet& rSet )
{
	sal_Bool bModified = FillItemSet_Impl( rSet, Western );
	bModified |= FillItemSet_Impl( rSet, Asian );
	bModified |= FillItemSet_Impl( rSet, Ctl );
	return bModified;
}

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

void SvxCharNamePage::SetFontList( const SvxFontListItem& rItem )
{
	if ( m_pImpl->m_bMustDelete )
	{
		delete m_pImpl->m_pFontList;
	}
    m_pImpl->m_pFontList = rItem.GetFontList()->Clone();
    m_pImpl->m_bMustDelete = sal_True;
}

// -----------------------------------------------------------------------
namespace
{
	void enableRelativeMode( SvxCharNamePage* _pPage, FontSizeBox* _pFontSizeLB, sal_uInt16 _nHeightWhich )
	{
		_pFontSizeLB->EnableRelativeMode( 5, 995, 5 ); // min 5%, max 995%, step 5

		const SvxFontHeightItem& rHeightItem =
			(SvxFontHeightItem&)_pPage->GetItemSet().GetParent()->Get( _nHeightWhich );
		SfxMapUnit eUnit = _pPage->GetItemSet().GetPool()->GetMetric( _nHeightWhich );
		short nCurHeight =
			static_cast< short >( CalcToPoint( rHeightItem.GetHeight(), eUnit, 1 ) * 10 );

		// ausgehend von der akt. Hoehe:
		//		- negativ bis minimal 2 pt
		//		- positiv bis maximal 999 pt
		_pFontSizeLB->EnablePtRelativeMode( sal::static_int_cast< short >(-(nCurHeight - 20)), (9999 - nCurHeight), 10 );
	}
}
// -----------------------------------------------------------------------------

void SvxCharNamePage::EnableRelativeMode()
{
	DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no ParentSet!" );
	enableRelativeMode(this,m_pWestFontSizeLB,GetWhich( SID_ATTR_CHAR_FONTHEIGHT ));
	enableRelativeMode(this,m_pEastFontSizeLB,GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ));
	enableRelativeMode(this,m_pCTLFontSizeLB,GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ));
}

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

void SvxCharNamePage::EnableSearchMode()
{
	m_pImpl->m_bInSearchMode = sal_True;
}
// -----------------------------------------------------------------------
void SvxCharNamePage::DisableControls( sal_uInt16 nDisable )
{
	if ( DISABLE_LANGUAGE & nDisable )
	{
		if ( m_pWestFontLanguageFT ) m_pWestFontLanguageFT->Disable();
		if ( m_pWestFontLanguageLB ) m_pWestFontLanguageLB->Disable();
		if ( m_pEastFontLanguageFT ) m_pEastFontLanguageFT->Disable();
		if ( m_pEastFontLanguageLB ) m_pEastFontLanguageLB->Disable();
		if ( m_pCTLFontLanguageFT ) m_pCTLFontLanguageFT->Disable();
		if ( m_pCTLFontLanguageLB ) m_pCTLFontLanguageLB->Disable();
	}

	if ( DISABLE_HIDE_LANGUAGE & nDisable )
	{
		if ( m_pWestFontLanguageFT ) m_pWestFontLanguageFT->Hide();
		if ( m_pWestFontLanguageLB ) m_pWestFontLanguageLB->Hide();
		if ( m_pEastFontLanguageFT ) m_pEastFontLanguageFT->Hide();
		if ( m_pEastFontLanguageLB ) m_pEastFontLanguageLB->Hide();
		if ( m_pCTLFontLanguageFT ) m_pCTLFontLanguageFT->Hide();
		if ( m_pCTLFontLanguageLB ) m_pCTLFontLanguageLB->Hide();
	}
}

// -----------------------------------------------------------------------
void SvxCharNamePage::SetPreviewBackgroundToCharacter()
{
    m_bPreviewBackgroundToCharacter = sal_True;
}

// -----------------------------------------------------------------------
void SvxCharNamePage::PageCreated (SfxAllItemSet aSet) //add CHINA001
{
	SFX_ITEMSET_ARG (&aSet,pFontListItem,SvxFontListItem,SID_ATTR_CHAR_FONTLIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
	SFX_ITEMSET_ARG (&aSet,pDisalbeItem,SfxUInt16Item,SID_DISABLE_CTL,sal_False);
	if (pFontListItem)
		SetFontList(*pFontListItem);
		//CHINA001 SetFontList(pFontListItem->GetFontList());

	if (pFlagItem)
	{
		sal_uInt32 nFlags=pFlagItem->GetValue();
		if ( ( nFlags & SVX_RELATIVE_MODE ) == SVX_RELATIVE_MODE )
			EnableRelativeMode();
		if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
			SetPreviewBackgroundToCharacter();
	}
	if (pDisalbeItem)
		DisableControls(pDisalbeItem->GetValue());
}
// class SvxCharEffectsPage ----------------------------------------------

SvxCharEffectsPage::SvxCharEffectsPage( Window* pParent, const SfxItemSet& rInSet ) :

	SvxCharBasePage( pParent, CUI_RES( RID_SVXPAGE_CHAR_EFFECTS ), rInSet, WIN_EFFECTS_PREVIEW, FT_EFFECTS_FONTTYPE ),

    m_aFontColorFT          ( this, CUI_RES( FT_FONTCOLOR ) ),
    m_aFontColorLB          ( this, CUI_RES( LB_FONTCOLOR ) ),

	m_aEffectsFT			( this, CUI_RES( FT_EFFECTS ) ),
	m_aEffectsLB			( this, 0 ),

	m_aEffects2LB			( this, CUI_RES( LB_EFFECTS2 ) ),

    m_aReliefFT             ( this, CUI_RES( FT_RELIEF ) ),
    m_aReliefLB             ( this, CUI_RES( LB_RELIEF ) ),

	m_aOutlineBtn			( this, CUI_RES( CB_OUTLINE ) ),
	m_aShadowBtn			( this, CUI_RES( CB_SHADOW ) ),
	m_aBlinkingBtn			( this, CUI_RES( CB_BLINKING ) ),
    m_aHiddenBtn            ( this, CUI_RES( CB_CHARHIDDEN ) ),

	m_aVerticalLine			( this, CUI_RES( FL_EFFECTS_VERTICAL ) ),

	m_aOverlineFT			( this, CUI_RES( FT_OVERLINE ) ),
	m_aOverlineLB			( this, CUI_RES( LB_OVERLINE ) ),
	m_aOverlineColorFT		( this, CUI_RES( FT_OVERLINE_COLOR ) ),
	m_aOverlineColorLB		( this, CUI_RES( LB_OVERLINE_COLOR ) ),
	m_aStrikeoutFT			( this, CUI_RES( FT_STRIKEOUT ) ),
	m_aStrikeoutLB			( this, CUI_RES( LB_STRIKEOUT ) ),
	m_aUnderlineFT			( this, CUI_RES( FT_UNDERLINE ) ),
	m_aUnderlineLB			( this, CUI_RES( LB_UNDERLINE ) ),
	m_aUnderlineColorFT		( this, CUI_RES( FT_UNDERLINE_COLOR ) ),
	m_aUnderlineColorLB		( this, CUI_RES( LB_UNDERLINE_COLOR ) ),
	m_aIndividualWordsBtn	( this, CUI_RES( CB_INDIVIDUALWORDS ) ),

	m_aAsianLine			( this, CUI_RES( FL_EFFECTS_ASIAN ) ),

	m_aEmphasisFT			( this, CUI_RES( FT_EMPHASIS ) ),
	m_aEmphasisLB			( this, CUI_RES( LB_EMPHASIS ) ),
	m_aPositionFT			( this, CUI_RES( FT_POSITION ) ),
	m_aPositionLB			( this, CUI_RES( LB_POSITION ) ),

	m_aTransparentColorName	( CUI_RES( STR_CHARNAME_TRANSPARENT ) )

{
	m_aEffectsLB.Hide();
	FreeResource();
	Initialize();
}

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

void SvxCharEffectsPage::Initialize()
{
	// to handle the changes of the other pages
	SetExchangeSupport();

	// HTML-Mode
	const SfxPoolItem* pItem;
	SfxObjectShell* pShell;
	if ( SFX_ITEM_SET == GetItemSet().GetItemState( SID_HTML_MODE, sal_False, &pItem ) ||
		 ( NULL != ( pShell = SfxObjectShell::Current() ) &&
		   NULL != ( pItem = pShell->GetItem( SID_HTML_MODE ) ) ) )
	{
		m_nHtmlMode = ( (const SfxUInt16Item*)pItem )->GetValue();
		if ( ( m_nHtmlMode & HTMLMODE_ON ) == HTMLMODE_ON )
		{
			//!!! hide some controls please
		}
	}

	// fill the color box
	SfxObjectShell* pDocSh = SfxObjectShell::Current();
	DBG_ASSERT( pDocSh, "DocShell not found!" );
	XColorTable* pColorTable = NULL;
	FASTBOOL bKillTable = sal_False;

	if ( pDocSh )
    {
        pItem = pDocSh->GetItem( SID_COLOR_TABLE );
        if ( pItem != NULL )
            pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
    }

	if ( !pColorTable )
	{
		pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
		bKillTable = sal_True;
	}

	m_aUnderlineColorLB.SetUpdateMode( sal_False );
	m_aOverlineColorLB.SetUpdateMode( sal_False );
	m_aFontColorLB.SetUpdateMode( sal_False );

	{
		SfxPoolItem* pDummy;
		SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pDocSh );
		if ( !pFrame ||
			 SFX_ITEM_DEFAULT > pFrame->GetBindings().QueryState( SID_ATTR_AUTO_COLOR_INVALID, pDummy ) )
		{
			m_aUnderlineColorLB.InsertAutomaticEntry();
			m_aOverlineColorLB.InsertAutomaticEntry();
			m_aFontColorLB.InsertAutomaticEntry();
		}
	}
	for ( long i = 0; i < pColorTable->Count(); i++ )
	{
        XColorEntry* pEntry = pColorTable->GetColor(i);
		m_aUnderlineColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
		m_aOverlineColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
		m_aFontColorLB.InsertEntry( pEntry->GetColor(), pEntry->GetName() );
	}

	m_aUnderlineColorLB.SetUpdateMode( sal_True );
	m_aOverlineColorLB.SetUpdateMode( sal_True );
	m_aFontColorLB.SetUpdateMode( sal_True );
    m_aFontColorLB.SetSelectHdl( LINK( this, SvxCharEffectsPage, ColorBoxSelectHdl_Impl ) );

	if ( bKillTable )
		delete pColorTable;

	// handler
	Link aLink = LINK( this, SvxCharEffectsPage, SelectHdl_Impl );
	m_aUnderlineLB.SetSelectHdl( aLink );
    m_aUnderlineColorLB.SetSelectHdl( aLink );
	m_aOverlineLB.SetSelectHdl( aLink );
    m_aOverlineColorLB.SetSelectHdl( aLink );
	m_aStrikeoutLB.SetSelectHdl( aLink );
	m_aEmphasisLB.SetSelectHdl( aLink );
	m_aPositionLB.SetSelectHdl( aLink );
	m_aEffects2LB.SetSelectHdl( aLink );
    m_aReliefLB.SetSelectHdl( aLink );

	m_aUnderlineLB.SelectEntryPos( 0 );
	m_aUnderlineColorLB.SelectEntryPos( 0 );
	m_aOverlineLB.SelectEntryPos( 0 );
	m_aOverlineColorLB.SelectEntryPos( 0 );
	m_aStrikeoutLB.SelectEntryPos( 0 );
	m_aEmphasisLB.SelectEntryPos( 0 );
	m_aPositionLB.SelectEntryPos( 0 );
	SelectHdl_Impl( NULL );
	SelectHdl_Impl( &m_aEmphasisLB );

	m_aEffects2LB.SelectEntryPos( 0 );

    m_aIndividualWordsBtn.SetClickHdl( LINK( this, SvxCharEffectsPage, CbClickHdl_Impl ) );
    aLink = LINK( this, SvxCharEffectsPage, TristClickHdl_Impl );
	m_aOutlineBtn.SetClickHdl( aLink );
	m_aShadowBtn.SetClickHdl( aLink );

    if ( !SvtLanguageOptions().IsAsianTypographyEnabled() )
    {
		m_aAsianLine.Hide();
        m_aEmphasisFT.Hide();
        m_aEmphasisLB.Hide();
        m_aPositionFT.Hide();
        m_aPositionLB.Hide();
	}
}
// -----------------------------------------------------------------------

void SvxCharEffectsPage::UpdatePreview_Impl()
{
	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();

	sal_uInt16 nPos = m_aUnderlineLB.GetSelectEntryPos();
	FontUnderline eUnderline = (FontUnderline)(sal_uLong)m_aUnderlineLB.GetEntryData( nPos );
	nPos = m_aOverlineLB.GetSelectEntryPos();
	FontUnderline eOverline = (FontUnderline)(sal_uLong)m_aOverlineLB.GetEntryData( nPos );
	nPos = m_aStrikeoutLB.GetSelectEntryPos();
	FontStrikeout eStrikeout = (FontStrikeout)(sal_uLong)m_aStrikeoutLB.GetEntryData( nPos );
	rFont.SetUnderline( eUnderline );
    rCJKFont.SetUnderline( eUnderline );
	rCTLFont.SetUnderline( eUnderline );
	m_aPreviewWin.SetTextLineColor( m_aUnderlineColorLB.GetSelectEntryColor() );
	rFont.SetOverline( eOverline );
    rCJKFont.SetOverline( eOverline );
	rCTLFont.SetOverline( eOverline );
	m_aPreviewWin.SetOverlineColor( m_aOverlineColorLB.GetSelectEntryColor() );
	rFont.SetStrikeout( eStrikeout );
    rCJKFont.SetStrikeout( eStrikeout );
	rCTLFont.SetStrikeout( eStrikeout );

	nPos = m_aPositionLB.GetSelectEntryPos();
	sal_Bool bUnder = ( CHRDLG_POSITION_UNDER == (sal_uLong)m_aPositionLB.GetEntryData( nPos ) );
	FontEmphasisMark eMark = (FontEmphasisMark)m_aEmphasisLB.GetSelectEntryPos();
	eMark |= bUnder ? EMPHASISMARK_POS_BELOW : EMPHASISMARK_POS_ABOVE;
	rFont.SetEmphasisMark( eMark );
    rCJKFont.SetEmphasisMark( eMark );
	rCTLFont.SetEmphasisMark( eMark );

    sal_uInt16 nRelief = m_aReliefLB.GetSelectEntryPos();
    if(LISTBOX_ENTRY_NOTFOUND != nRelief)
    {
        rFont.SetRelief( (FontRelief)nRelief );
        rCJKFont.SetRelief( (FontRelief)nRelief );
		rCTLFont.SetRelief( (FontRelief)nRelief );
    }

    rFont.SetOutline( StateToAttr( m_aOutlineBtn.GetState() ) );
    rCJKFont.SetOutline( rFont.IsOutline() );
	rCTLFont.SetOutline( rFont.IsOutline() );

    rFont.SetShadow( StateToAttr( m_aShadowBtn.GetState() ) );
    rCJKFont.SetShadow( rFont.IsShadow() );
	rCTLFont.SetShadow( rFont.IsShadow() );

	sal_uInt16 nCapsPos = m_aEffects2LB.GetSelectEntryPos();
	if ( nCapsPos != LISTBOX_ENTRY_NOTFOUND )
    {
		rFont.SetCaseMap( (SvxCaseMap)nCapsPos );
        rCJKFont.SetCaseMap( (SvxCaseMap)nCapsPos );
        // #i78474# small caps do not exist in CTL fonts
        rCTLFont.SetCaseMap( static_cast<SvxCaseMap>( nCapsPos == SVX_CASEMAP_KAPITAELCHEN ? SVX_CASEMAP_NOT_MAPPED : (SvxCaseMap)nCapsPos) );
    }

    sal_Bool bWordLine = m_aIndividualWordsBtn.IsChecked();
    rFont.SetWordLineMode( bWordLine );
    rCJKFont.SetWordLineMode( bWordLine );
	rCTLFont.SetWordLineMode( bWordLine );

    m_aPreviewWin.Invalidate();
}

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

void SvxCharEffectsPage::SetCaseMap_Impl( SvxCaseMap eCaseMap )
{
	if ( SVX_CASEMAP_END > eCaseMap )
		m_aEffects2LB.SelectEntryPos(
            sal::static_int_cast< sal_uInt16 >( eCaseMap ) );
	else
	{
		m_aEffects2LB.SetNoSelection();
		eCaseMap = SVX_CASEMAP_NOT_MAPPED;
	}

	UpdatePreview_Impl();
}

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

void SvxCharEffectsPage::ResetColor_Impl( const SfxItemSet& rSet )
{
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
	SfxItemState eState = rSet.GetItemState( nWhich );

	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
            m_aFontColorFT.Hide();
            m_aFontColorLB.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
            m_aFontColorFT.Disable();
            m_aFontColorLB.Disable();
			break;

		case SFX_ITEM_DONTCARE:
            m_aFontColorLB.SetNoSelection();
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			SvxFont& rFont = GetPreviewFont();
            SvxFont& rCJKFont = GetPreviewCJKFont();
			SvxFont& rCTLFont = GetPreviewCTLFont();

			const SvxColorItem& rItem = (SvxColorItem&)rSet.Get( nWhich );
			Color aColor = rItem.GetValue();
            rFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
            rCJKFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );
			rCTLFont.SetColor( aColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aColor );

			m_aPreviewWin.Invalidate();
            sal_uInt16 nSelPos = m_aFontColorLB.GetEntryPos( aColor );
			if ( nSelPos == LISTBOX_ENTRY_NOTFOUND && aColor == Color( COL_TRANSPARENT ) )
				nSelPos = m_aFontColorLB.GetEntryPos( m_aTransparentColorName );

			if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
                m_aFontColorLB.SelectEntryPos( nSelPos );
			else
			{
                nSelPos = m_aFontColorLB.GetEntryPos( aColor );
				if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
                    m_aFontColorLB.SelectEntryPos( nSelPos );
				else
                    m_aFontColorLB.SelectEntryPos(
                        m_aFontColorLB.InsertEntry( aColor, String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
			}
			break;
		}
	}
}

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

sal_Bool SvxCharEffectsPage::FillItemSetColor_Impl( SfxItemSet& rSet )
{
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_COLOR );
	const SvxColorItem* pOld = (const SvxColorItem*)GetOldItem( rSet, SID_ATTR_CHAR_COLOR );
	const SvxColorItem* pItem = NULL;
	sal_Bool bChanged = sal_True;
	const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
	const SfxItemSet& rOldSet = GetItemSet();

	Color aSelectedColor;
    if ( m_aFontColorLB.GetSelectEntry() == m_aTransparentColorName )
		aSelectedColor = Color( COL_TRANSPARENT );
	else
        aSelectedColor = m_aFontColorLB.GetSelectEntryColor();

	if ( pOld && pOld->GetValue() == aSelectedColor )
		bChanged = sal_False;

	if ( !bChanged )
        bChanged = ( m_aFontColorLB.GetSavedValue() == LISTBOX_ENTRY_NOTFOUND );

	if ( !bChanged && pExampleSet &&
		 pExampleSet->GetItemState( nWhich, sal_False, (const SfxPoolItem**)&pItem ) == SFX_ITEM_SET &&
		 ( (SvxColorItem*)pItem )->GetValue() != aSelectedColor )
		bChanged = sal_True;

	sal_Bool bModified = sal_False;

    if ( bChanged && m_aFontColorLB.GetSelectEntryPos() != LISTBOX_ENTRY_NOTFOUND )
	{
		rSet.Put( SvxColorItem( aSelectedColor, nWhich ) );
		bModified = sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	return bModified;
}

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

IMPL_LINK( SvxCharEffectsPage, SelectHdl_Impl, ListBox*, pBox )
{
	if ( &m_aEmphasisLB == pBox )
	{
		sal_uInt16 nEPos = m_aEmphasisLB.GetSelectEntryPos();
		sal_Bool bEnable = ( nEPos > 0 && nEPos != LISTBOX_ENTRY_NOTFOUND );
		m_aPositionFT.Enable( bEnable );
		m_aPositionLB.Enable( bEnable );
	}
    else if( &m_aReliefLB == pBox)
    {
        sal_Bool bEnable = ( pBox->GetSelectEntryPos() == 0 );
        m_aOutlineBtn.Enable( bEnable );
        m_aShadowBtn.Enable( bEnable );
    }
    else if ( &m_aPositionLB != pBox )
	{
		sal_uInt16 nUPos = m_aUnderlineLB.GetSelectEntryPos(),
               nOPos = m_aOverlineLB.GetSelectEntryPos(),
               nSPos = m_aStrikeoutLB.GetSelectEntryPos();
        sal_Bool bUEnable = ( nUPos > 0 && nUPos != LISTBOX_ENTRY_NOTFOUND );
        sal_Bool bOEnable = ( nOPos > 0 && nOPos != LISTBOX_ENTRY_NOTFOUND );
		m_aUnderlineColorFT.Enable( bUEnable );
		m_aUnderlineColorLB.Enable( bUEnable );
		m_aOverlineColorFT.Enable( bOEnable );
		m_aOverlineColorLB.Enable( bOEnable );
        m_aIndividualWordsBtn.Enable( bUEnable || bOEnable || ( nSPos > 0 && nSPos != LISTBOX_ENTRY_NOTFOUND ) );
	}
    UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharEffectsPage, UpdatePreview_Impl, ListBox*, EMPTYARG )
{
	bool bEnable = ( ( m_aUnderlineLB.GetSelectEntryPos() > 0 ) ||
					 ( m_aOverlineLB.GetSelectEntryPos()  > 0 ) ||
					 ( m_aStrikeoutLB.GetSelectEntryPos() > 0 ) );
	m_aIndividualWordsBtn.Enable( bEnable );

    UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharEffectsPage, CbClickHdl_Impl, CheckBox*, EMPTYARG )
{
	UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharEffectsPage, TristClickHdl_Impl, TriStateBox*, EMPTYARG )
{
	UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharEffectsPage, ColorBoxSelectHdl_Impl, ColorListBox*, pBox )
{
	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();

	Color aSelectedColor;
	if ( pBox->GetSelectEntry() == m_aTransparentColorName )
		aSelectedColor = Color( COL_TRANSPARENT );
	else
		aSelectedColor = pBox->GetSelectEntryColor();
    rFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
    rCJKFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );
	rCTLFont.SetColor( aSelectedColor.GetColor() == COL_AUTO ? Color(COL_BLACK) : aSelectedColor );

    m_aPreviewWin.Invalidate();
	return 0;
}
// -----------------------------------------------------------------------

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

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

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

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

sal_uInt16* SvxCharEffectsPage::GetRanges()
{
	return pEffectsRanges;
}

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

void SvxCharEffectsPage::Reset( const SfxItemSet& rSet )
{
	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();

	sal_Bool bEnable = sal_False;

	// Underline
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
	rFont.SetUnderline( UNDERLINE_NONE );
    rCJKFont.SetUnderline( UNDERLINE_NONE );
	rCTLFont.SetUnderline( UNDERLINE_NONE );

	m_aUnderlineLB.SelectEntryPos( 0 );
	SfxItemState eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DONTCARE )
	{
		if ( eState == SFX_ITEM_DONTCARE )
			m_aUnderlineLB.SetNoSelection();
		else
		{
			const SvxUnderlineItem& rItem = (SvxUnderlineItem&)rSet.Get( nWhich );
			FontUnderline eUnderline = (FontUnderline)rItem.GetValue();
			rFont.SetUnderline( eUnderline );
            rCJKFont.SetUnderline( eUnderline );
			rCTLFont.SetUnderline( eUnderline );

			if ( eUnderline != UNDERLINE_NONE )
			{
				for ( sal_uInt16 i = 0; i < m_aUnderlineLB.GetEntryCount(); ++i )
				{
					if ( (FontUnderline)(sal_uLong)m_aUnderlineLB.GetEntryData(i) == eUnderline )
					{
						m_aUnderlineLB.SelectEntryPos(i);
						bEnable |= sal_True;
						break;
					}
				}

				Color aColor = rItem.GetColor();
				sal_uInt16 nPos = m_aUnderlineColorLB.GetEntryPos( aColor );

				if ( LISTBOX_ENTRY_NOTFOUND != nPos )
					m_aUnderlineColorLB.SelectEntryPos( nPos );
				else
				{
					nPos = m_aUnderlineColorLB.GetEntryPos( aColor );
					if ( LISTBOX_ENTRY_NOTFOUND != nPos )
						m_aUnderlineColorLB.SelectEntryPos( nPos );
					else
						m_aUnderlineColorLB.SelectEntryPos(
							m_aUnderlineColorLB.InsertEntry( aColor,
								String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
				}
			}
			else
			{
				m_aUnderlineColorLB.SelectEntry( Color( COL_AUTO ));
				m_aUnderlineColorLB.Disable();
			}
		}
	}

	// Overline
	nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
	rFont.SetOverline( UNDERLINE_NONE );
    rCJKFont.SetOverline( UNDERLINE_NONE );
	rCTLFont.SetOverline( UNDERLINE_NONE );

	m_aOverlineLB.SelectEntryPos( 0 );
	eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DONTCARE )
	{
		if ( eState == SFX_ITEM_DONTCARE )
			m_aOverlineLB.SetNoSelection();
		else
		{
			const SvxOverlineItem& rItem = (SvxOverlineItem&)rSet.Get( nWhich );
			FontUnderline eOverline = (FontUnderline)rItem.GetValue();
			rFont.SetOverline( eOverline );
            rCJKFont.SetOverline( eOverline );
			rCTLFont.SetOverline( eOverline );

			if ( eOverline != UNDERLINE_NONE )
			{
				for ( sal_uInt16 i = 0; i < m_aOverlineLB.GetEntryCount(); ++i )
				{
					if ( (FontUnderline)(sal_uLong)m_aOverlineLB.GetEntryData(i) == eOverline )
					{
						m_aOverlineLB.SelectEntryPos(i);
						bEnable |= sal_True;
						break;
					}
				}

				Color aColor = rItem.GetColor();
				sal_uInt16 nPos = m_aOverlineColorLB.GetEntryPos( aColor );

				if ( LISTBOX_ENTRY_NOTFOUND != nPos )
					m_aOverlineColorLB.SelectEntryPos( nPos );
				else
				{
					nPos = m_aOverlineColorLB.GetEntryPos( aColor );
					if ( LISTBOX_ENTRY_NOTFOUND != nPos )
						m_aOverlineColorLB.SelectEntryPos( nPos );
					else
						m_aOverlineColorLB.SelectEntryPos(
							m_aOverlineColorLB.InsertEntry( aColor,
								String( SVX_RES( RID_SVXSTR_COLOR_USER ) ) ) );
				}
			}
			else
			{
				m_aOverlineColorLB.SelectEntry( Color( COL_AUTO ));
				m_aOverlineColorLB.Disable();
			}
		}
	}

	//	Strikeout
	nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
	rFont.SetStrikeout( STRIKEOUT_NONE );
    rCJKFont.SetStrikeout( STRIKEOUT_NONE );
	rCTLFont.SetStrikeout( STRIKEOUT_NONE );

	m_aStrikeoutLB.SelectEntryPos( 0 );
	eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DONTCARE )
	{
		if ( eState == SFX_ITEM_DONTCARE )
			m_aStrikeoutLB.SetNoSelection();
		else
		{
			const SvxCrossedOutItem& rItem = (SvxCrossedOutItem&)rSet.Get( nWhich );
			FontStrikeout eStrikeout = (FontStrikeout)rItem.GetValue();
			rFont.SetStrikeout( eStrikeout );
            rCJKFont.SetStrikeout( eStrikeout );
			rCTLFont.SetStrikeout( eStrikeout );

			if ( eStrikeout != STRIKEOUT_NONE )
			{
				for ( sal_uInt16 i = 0; i < m_aStrikeoutLB.GetEntryCount(); ++i )
				{
					if ( (FontStrikeout)(sal_uLong)m_aStrikeoutLB.GetEntryData(i) == eStrikeout )
					{
						m_aStrikeoutLB.SelectEntryPos(i);
						bEnable |= sal_True;
						break;
					}
				}
			}
		}
	}

	// WordLineMode
	nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aIndividualWordsBtn.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aIndividualWordsBtn.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aIndividualWordsBtn.SetState( STATE_DONTKNOW );
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxWordLineModeItem& rItem = (SvxWordLineModeItem&)rSet.Get( nWhich );
			rFont.SetWordLineMode( rItem.GetValue() );
        	rCJKFont.SetWordLineMode( rItem.GetValue() );
			rCTLFont.SetWordLineMode( rItem.GetValue() );

			m_aIndividualWordsBtn.Check( rItem.GetValue() );
			m_aIndividualWordsBtn.Enable( bEnable );
			break;
		}
	}

	// Emphasis
	nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
	eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DEFAULT )
	{
		const SvxEmphasisMarkItem& rItem = (SvxEmphasisMarkItem&)rSet.Get( nWhich );
		FontEmphasisMark eMark = rItem.GetEmphasisMark();
		rFont.SetEmphasisMark( eMark );
        rCJKFont.SetEmphasisMark( eMark );
		rCTLFont.SetEmphasisMark( eMark );

		m_aEmphasisLB.SelectEntryPos( (sal_uInt16)( eMark & EMPHASISMARK_STYLE ) );
        eMark &= ~EMPHASISMARK_STYLE;
        sal_uLong nEntryData = ( eMark == EMPHASISMARK_POS_ABOVE )
			? CHRDLG_POSITION_OVER
			: ( eMark == EMPHASISMARK_POS_BELOW ) ? CHRDLG_POSITION_UNDER : 0;

        for ( sal_uInt16 i = 0; i < m_aPositionLB.GetEntryCount(); i++ )
        {
            if ( nEntryData == (sal_uLong)m_aPositionLB.GetEntryData(i) )
            {
                m_aPositionLB.SelectEntryPos(i);
                break;
            }
        }
	}
	else if ( eState == SFX_ITEM_DONTCARE )
		m_aEmphasisLB.SetNoSelection( );
	else if ( eState == SFX_ITEM_UNKNOWN )
	{
		m_aEmphasisFT.Hide();
		m_aEmphasisLB.Hide();
	}
	else // SFX_ITEM_DISABLED or SFX_ITEM_READONLY
	{
		m_aEmphasisFT.Disable();
		m_aEmphasisLB.Disable();
	}

	// the select handler for the underline/overline/strikeout list boxes
//	SelectHdl_Impl( NULL );
	DBG_ASSERT(m_aUnderlineLB.GetSelectHdl() == m_aOverlineLB.GetSelectHdl(),
		"SvxCharEffectsPage::Reset: inconsistence (1)!");
	DBG_ASSERT(m_aUnderlineLB.GetSelectHdl() == m_aStrikeoutLB.GetSelectHdl(),
		"SvxCharEffectsPage::Reset: inconsistence (1)!");
	m_aUnderlineLB.GetSelectHdl().Call(NULL);
		// don't call SelectHdl_Impl directly!
		// in DisableControls, we may have re-reouted the select handler
		// 30.05.2001 - 86262 - frank.schoenheit@germany.sun.com

	// the select handler for the emphasis listbox
//	SelectHdl_Impl( &m_aEmphasisLB );
	DBG_ASSERT(m_aEmphasisLB.GetSelectHdl() == LINK(this, SvxCharEffectsPage, SelectHdl_Impl),
		"SvxCharEffectsPage::Reset: inconsistence (2)!");
	m_aEmphasisLB.GetSelectHdl().Call( &m_aEmphasisLB );
		// this is for consistency only. Here it would be allowed to call SelectHdl_Impl directly ...

	// Effects
	SvxCaseMap eCaseMap = SVX_CASEMAP_END;
	nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
	eState = rSet.GetItemState( nWhich );
	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aEffectsFT.Hide();
			m_aEffects2LB.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aEffectsFT.Disable();
			m_aEffects2LB.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aEffects2LB.SetNoSelection();
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxCaseMapItem& rItem = (const SvxCaseMapItem&)rSet.Get( nWhich );
			eCaseMap = (SvxCaseMap)rItem.GetValue();
			break;
		}
	}
	SetCaseMap_Impl( eCaseMap );

    //Relief
    nWhich = GetWhich(SID_ATTR_CHAR_RELIEF);
	eState = rSet.GetItemState( nWhich );
	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aReliefFT.Hide();
			m_aReliefLB.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aReliefFT.Disable();
			m_aReliefLB.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aReliefLB.SetNoSelection();
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
        	const SvxCharReliefItem& rItem = (const SvxCharReliefItem&)rSet.Get( nWhich );
        	m_aReliefLB.SelectEntryPos(rItem.GetValue());
        	SelectHdl_Impl(&m_aReliefLB);
			break;
		}
	}

    // Outline
	nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
	eState = rSet.GetItemState( nWhich );
	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aOutlineBtn.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aOutlineBtn.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aOutlineBtn.SetState( STATE_DONTKNOW );
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxContourItem& rItem = (SvxContourItem&)rSet.Get( nWhich );
			m_aOutlineBtn.SetState( (TriState)rItem.GetValue() );
			m_aOutlineBtn.EnableTriState( sal_False );
			break;
		}
	}

	// Shadow
	nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
	eState = rSet.GetItemState( nWhich );

	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aShadowBtn.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aShadowBtn.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aShadowBtn.SetState( STATE_DONTKNOW );
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxShadowedItem& rItem = (SvxShadowedItem&)rSet.Get( nWhich );
			m_aShadowBtn.SetState( (TriState)rItem.GetValue() );
			m_aShadowBtn.EnableTriState( sal_False );
			break;
		}
	}

	// Blinking
	nWhich = GetWhich( SID_ATTR_FLASH );
	eState = rSet.GetItemState( nWhich );

	switch ( eState )
	{
		case SFX_ITEM_UNKNOWN:
			m_aBlinkingBtn.Hide();
			break;

		case SFX_ITEM_DISABLED:
		case SFX_ITEM_READONLY:
			m_aBlinkingBtn.Disable();
			break;

		case SFX_ITEM_DONTCARE:
			m_aBlinkingBtn.SetState( STATE_DONTKNOW );
			break;

		case SFX_ITEM_DEFAULT:
		case SFX_ITEM_SET:
		{
			const SvxBlinkItem& rItem = (SvxBlinkItem&)rSet.Get( nWhich );
			m_aBlinkingBtn.SetState( (TriState)rItem.GetValue() );
			m_aBlinkingBtn.EnableTriState( sal_False );
			break;
		}
	}
    // Hidden
    nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN );
    eState = rSet.GetItemState( nWhich );

    switch ( eState )
    {
        case SFX_ITEM_UNKNOWN:
            m_aHiddenBtn.Hide();
            break;

        case SFX_ITEM_DISABLED:
        case SFX_ITEM_READONLY:
            m_aHiddenBtn.Disable();
            break;

        case SFX_ITEM_DONTCARE:
            m_aHiddenBtn.SetState( STATE_DONTKNOW );
            break;

        case SFX_ITEM_DEFAULT:
        case SFX_ITEM_SET:
        {
            const SvxCharHiddenItem& rItem = (SvxCharHiddenItem&)rSet.Get( nWhich );
            m_aHiddenBtn.SetState( (TriState)rItem.GetValue() );
            m_aHiddenBtn.EnableTriState( sal_False );
            break;
        }
    }

	SetPrevFontWidthScale( rSet );
	ResetColor_Impl( rSet );

	// preview update
	m_aPreviewWin.Invalidate();

	// save this settings
	m_aUnderlineLB.SaveValue();
	m_aUnderlineColorLB.SaveValue();
	m_aOverlineLB.SaveValue();
	m_aOverlineColorLB.SaveValue();
	m_aStrikeoutLB.SaveValue();
	m_aIndividualWordsBtn.SaveValue();
	m_aEmphasisLB.SaveValue();
	m_aPositionLB.SaveValue();
	m_aEffects2LB.SaveValue();
    m_aReliefLB.SaveValue();
    m_aOutlineBtn.SaveValue();
	m_aShadowBtn.SaveValue();
	m_aBlinkingBtn.SaveValue();
    m_aHiddenBtn.SaveValue();
	m_aFontColorLB.SaveValue();
}

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

sal_Bool SvxCharEffectsPage::FillItemSet( SfxItemSet& rSet )
{
	const SfxPoolItem* pOld = 0;
	const SfxItemSet& rOldSet = GetItemSet();
	sal_Bool bModified = sal_False;
	FASTBOOL bChanged = sal_True;

	// Underline
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_UNDERLINE );
	sal_uInt16 nPos = m_aUnderlineLB.GetSelectEntryPos();
	FontUnderline eUnder = (FontUnderline)(sal_uLong)m_aUnderlineLB.GetEntryData( nPos );

	if ( pOld )
	{
        //! if there are different underline styles in the selection the
        //! item-state in the 'rOldSet' will be invalid. In this case
        //! changing the underline style will be allowed if a style is
        //! selected in the listbox.
        sal_Bool bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
                         SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, sal_True );

		const SvxUnderlineItem& rItem = *( (const SvxUnderlineItem*)pOld );
		if ( (FontUnderline)rItem.GetValue() == eUnder &&
             ( UNDERLINE_NONE == eUnder || rItem.GetColor() == m_aUnderlineColorLB.GetSelectEntryColor() ) &&
             ! bAllowChg )
			bChanged = sal_False;
	}

	if ( bChanged )
	{
		SvxUnderlineItem aNewItem( eUnder, nWhich );
		aNewItem.SetColor( m_aUnderlineColorLB.GetSelectEntryColor() );
		rSet.Put( aNewItem );
		bModified |= sal_True;
	}
 	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Overline
	nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_OVERLINE );
	nPos = m_aOverlineLB.GetSelectEntryPos();
	FontUnderline eOver = (FontUnderline)(sal_uLong)m_aOverlineLB.GetEntryData( nPos );

	if ( pOld )
	{
        //! if there are different underline styles in the selection the
        //! item-state in the 'rOldSet' will be invalid. In this case
        //! changing the underline style will be allowed if a style is
        //! selected in the listbox.
        sal_Bool bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
                         SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, sal_True );

		const SvxOverlineItem& rItem = *( (const SvxOverlineItem*)pOld );
		if ( (FontUnderline)rItem.GetValue() == eOver &&
             ( UNDERLINE_NONE == eOver || rItem.GetColor() == m_aOverlineColorLB.GetSelectEntryColor() ) &&
             ! bAllowChg )
			bChanged = sal_False;
	}

	if ( bChanged )
	{
		SvxOverlineItem aNewItem( eOver, nWhich );
		aNewItem.SetColor( m_aOverlineColorLB.GetSelectEntryColor() );
		rSet.Put( aNewItem );
		bModified |= sal_True;
	}
 	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Strikeout
	nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_STRIKEOUT );
	nPos = m_aStrikeoutLB.GetSelectEntryPos();
	FontStrikeout eStrike = (FontStrikeout)(sal_uLong)m_aStrikeoutLB.GetEntryData( nPos );

	if ( pOld )
	{
        //! if there are different strikeout styles in the selection the
        //! item-state in the 'rOldSet' will be invalid. In this case
        //! changing the strikeout style will be allowed if a style is
        //! selected in the listbox.
        sal_Bool bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
                         SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, sal_True );

		const SvxCrossedOutItem& rItem = *( (const SvxCrossedOutItem*)pOld );
        if ( !m_aStrikeoutLB.IsEnabled()
            || ((FontStrikeout)rItem.GetValue() == eStrike  && !bAllowChg) )
			bChanged = sal_False;
	}

	if ( bChanged )
	{
		rSet.Put( SvxCrossedOutItem( eStrike, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Individual words
	nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_WORDLINEMODE );

	if ( pOld )
	{
		const SvxWordLineModeItem& rItem = *( (const SvxWordLineModeItem*)pOld );
		if ( rItem.GetValue() == m_aIndividualWordsBtn.IsChecked() )
			bChanged = sal_False;
	}

	if ( rOldSet.GetItemState( nWhich ) == SFX_ITEM_DONTCARE &&
		 m_aIndividualWordsBtn.IsChecked() == m_aIndividualWordsBtn.GetSavedValue() )
		bChanged = sal_False;

	if ( bChanged )
	{
		rSet.Put( SvxWordLineModeItem( m_aIndividualWordsBtn.IsChecked(), nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Emphasis
	nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_EMPHASISMARK );
	sal_uInt16 nMarkPos = m_aEmphasisLB.GetSelectEntryPos();
	sal_uInt16 nPosPos = m_aPositionLB.GetSelectEntryPos();
	FontEmphasisMark eMark = (FontEmphasisMark)nMarkPos;
	if ( m_aPositionLB.IsEnabled() )
	{
		eMark |= ( CHRDLG_POSITION_UNDER == (sal_uLong)m_aPositionLB.GetEntryData( nPosPos ) )
			? EMPHASISMARK_POS_BELOW : EMPHASISMARK_POS_ABOVE;
	}

	if ( pOld )
	{
    	if( rOldSet.GetItemState( nWhich ) != SFX_ITEM_DONTCARE )
        {
		    const SvxEmphasisMarkItem& rItem = *( (const SvxEmphasisMarkItem*)pOld );
		    if ( rItem.GetEmphasisMark() == eMark )
			    bChanged = sal_False;
        }
	}

	if ( rOldSet.GetItemState( nWhich ) == SFX_ITEM_DONTCARE &&
		 m_aEmphasisLB.GetSavedValue() == nMarkPos && m_aPositionLB.GetSavedValue() == nPosPos )
		bChanged = sal_False;

	if ( bChanged )
	{
		rSet.Put( SvxEmphasisMarkItem( eMark, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Effects
	nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_CASEMAP );
	SvxCaseMap eCaseMap = SVX_CASEMAP_NOT_MAPPED;
	FASTBOOL bChecked = sal_False;
	sal_uInt16 nCapsPos = m_aEffects2LB.GetSelectEntryPos();
	if ( nCapsPos != LISTBOX_ENTRY_NOTFOUND )
	{
		eCaseMap = (SvxCaseMap)nCapsPos;
		bChecked = sal_True;
	}

	if ( pOld )
	{
        //! if there are different effect styles in the selection the
        //! item-state in the 'rOldSet' will be invalid. In this case
        //! changing the effect style will be allowed if a style is
        //! selected in the listbox.
        sal_Bool bAllowChg = LISTBOX_ENTRY_NOTFOUND != nPos  &&
                         SFX_ITEM_DEFAULT > rOldSet.GetItemState( nWhich, sal_True );

        const SvxCaseMapItem& rItem = *( (const SvxCaseMapItem*)pOld );
        if ( (SvxCaseMap)rItem.GetValue() == eCaseMap  &&  !bAllowChg )
			bChanged = sal_False;
	}

	if ( bChanged && bChecked )
	{
		rSet.Put( SvxCaseMapItem( eCaseMap, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

    //Relief
    nWhich = GetWhich(SID_ATTR_CHAR_RELIEF);
    if(m_aReliefLB.GetSelectEntryPos() != m_aReliefLB.GetSavedValue())
    {
        m_aReliefLB.SaveValue();
        SvxCharReliefItem aRelief((FontRelief)m_aReliefLB.GetSelectEntryPos(), nWhich);
        rSet.Put(aRelief);
    }

    // Outline
	const SfxItemSet* pExampleSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
	nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_CONTOUR );
	TriState eState = m_aOutlineBtn.GetState();
	const SfxPoolItem* pItem;

	if ( pOld )
	{
		const SvxContourItem& rItem = *( (const SvxContourItem*)pOld );
		if ( rItem.GetValue() == StateToAttr( eState ) && m_aOutlineBtn.GetSavedValue() == eState )
			bChanged = sal_False;
	}

	if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 !StateToAttr( eState ) && ( (SvxContourItem*)pItem )->GetValue() )
		bChanged = sal_True;

	if ( bChanged && eState != STATE_DONTKNOW )
	{
		rSet.Put( SvxContourItem( StateToAttr( eState ), nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Shadow
	nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_SHADOWED );
	eState = m_aShadowBtn.GetState();

	if ( pOld )
	{
		const SvxShadowedItem& rItem = *( (const SvxShadowedItem*)pOld );
		if ( rItem.GetValue() == StateToAttr( eState ) && m_aShadowBtn.GetSavedValue() == eState )
			bChanged = sal_False;
	}

	if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 !StateToAttr( eState ) && ( (SvxShadowedItem*)pItem )->GetValue() )
		bChanged = sal_True;

	if ( bChanged && eState != STATE_DONTKNOW )
	{
		rSet.Put( SvxShadowedItem( StateToAttr( eState ), nWhich ) );
		bModified = sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Blinking
	nWhich = GetWhich( SID_ATTR_FLASH );
	pOld = GetOldItem( rSet, SID_ATTR_FLASH );
	eState = m_aBlinkingBtn.GetState();

	if ( pOld )
	{
		const SvxBlinkItem& rItem = *( (const SvxBlinkItem*)pOld );
		if ( rItem.GetValue() == StateToAttr( eState ) && m_aBlinkingBtn.GetSavedValue() == eState )
			bChanged = sal_False;
	}

	if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
		 !StateToAttr( eState ) && ( (SvxBlinkItem*)pItem )->GetValue() )
		bChanged = sal_True;

	if ( bChanged && eState != STATE_DONTKNOW )
	{
		rSet.Put( SvxBlinkItem( StateToAttr( eState ), nWhich ) );
		bModified = sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

    // Hidden
    nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN );
    pOld = GetOldItem( rSet, SID_ATTR_CHAR_HIDDEN );
    eState = m_aHiddenBtn.GetState();
	bChanged = sal_True;

    if ( pOld )
    {
        const SvxCharHiddenItem& rItem = *( (const SvxCharHiddenItem*)pOld );
        if ( rItem.GetValue() == StateToAttr( eState ) && m_aHiddenBtn.GetSavedValue() == eState )
            bChanged = sal_False;
    }

    if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, sal_False, &pItem ) == SFX_ITEM_SET &&
         !StateToAttr( eState ) && ( (SvxCharHiddenItem*)pItem )->GetValue() )
        bChanged = sal_True;

    if ( bChanged && eState != STATE_DONTKNOW )
    {
        rSet.Put( SvxCharHiddenItem( StateToAttr( eState ), nWhich ) );
        bModified = sal_True;
    }
    else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
        CLEARTITEM;

	bModified |= FillItemSetColor_Impl( rSet );

	return bModified;
}

void SvxCharEffectsPage::DisableControls( sal_uInt16 nDisable )
{
	if ( ( DISABLE_CASEMAP & nDisable ) == DISABLE_CASEMAP )
	{
		m_aEffectsFT.Disable();
		m_aEffects2LB.Disable();
	}

	if ( ( DISABLE_WORDLINE & nDisable ) == DISABLE_WORDLINE )
		m_aIndividualWordsBtn.Disable();

	if ( ( DISABLE_BLINK & nDisable ) == DISABLE_BLINK )
		m_aBlinkingBtn.Disable();

	if ( ( DISABLE_UNDERLINE_COLOR & nDisable ) == DISABLE_UNDERLINE_COLOR )
	{
		// disable the controls
		m_aUnderlineColorFT.Disable( );
		m_aUnderlineColorLB.Disable( );
		// and reroute the selection handler of the controls which normally would affect the color box dis-/enabling
		m_aUnderlineLB.SetSelectHdl(LINK(this, SvxCharEffectsPage, UpdatePreview_Impl));
		m_aStrikeoutLB.SetSelectHdl(LINK(this, SvxCharEffectsPage, UpdatePreview_Impl));
    }
}

void SvxCharEffectsPage::EnableFlash()
{
	if ( !( ( m_nHtmlMode & HTMLMODE_ON ) && !( m_nHtmlMode & HTMLMODE_BLINK ) ) )
		m_aBlinkingBtn.Show();
}

// -----------------------------------------------------------------------
void SvxCharEffectsPage::SetPreviewBackgroundToCharacter()
{
    m_bPreviewBackgroundToCharacter = sal_True;
}

// -----------------------------------------------------------------------
void SvxCharEffectsPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
{
	SFX_ITEMSET_ARG (&aSet,pDisableCtlItem,SfxUInt16Item,SID_DISABLE_CTL,sal_False);
	SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
	if (pDisableCtlItem)
		DisableControls(pDisableCtlItem->GetValue());

	if (pFlagItem)
	{
		sal_uInt32 nFlags=pFlagItem->GetValue();
		if ( ( nFlags & SVX_ENABLE_FLASH ) == SVX_ENABLE_FLASH )
			EnableFlash();
		if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
			SetPreviewBackgroundToCharacter();
	}
}

// class SvxCharPositionPage ---------------------------------------------

SvxCharPositionPage::SvxCharPositionPage( Window* pParent, const SfxItemSet& rInSet ) :

	SvxCharBasePage( pParent, CUI_RES( RID_SVXPAGE_CHAR_POSITION ), rInSet, WIN_POS_PREVIEW, FT_POS_FONTTYPE ),

	m_aPositionLine		( this, CUI_RES( FL_POSITION ) ),
	m_aHighPosBtn		( this, CUI_RES( RB_HIGHPOS ) ),
	m_aNormalPosBtn		( this, CUI_RES( RB_NORMALPOS ) ),
	m_aLowPosBtn		( this, CUI_RES( RB_LOWPOS ) ),
	m_aHighLowFT		( this, CUI_RES( FT_HIGHLOW ) ),
	m_aHighLowEdit		( this, CUI_RES( ED_HIGHLOW ) ),
	m_aHighLowRB		( this, CUI_RES( CB_HIGHLOW ) ),
	m_aFontSizeFT		( this, CUI_RES( FT_FONTSIZE ) ),
	m_aFontSizeEdit		( this, CUI_RES( ED_FONTSIZE ) ),
	m_aRotationScalingFL( this, CUI_RES( FL_ROTATION_SCALING ) ),
	m_aScalingFL		( this, CUI_RES( FL_SCALING ) ),
	m_a0degRB			( this, CUI_RES( RB_0_DEG ) ),
	m_a90degRB			( this, CUI_RES( RB_90_DEG ) ),
	m_a270degRB			( this, CUI_RES( RB_270_DEG ) ),
	m_aFitToLineCB		( this, CUI_RES( CB_FIT_TO_LINE ) ),
	m_aScaleWidthFT		( this, CUI_RES( FT_SCALE_WIDTH ) ),
	m_aScaleWidthMF		( this, CUI_RES( MF_SCALE_WIDTH ) ),

	m_aKerningLine		( this, CUI_RES( FL_KERNING2 ) ),
	m_aKerningLB		( this, CUI_RES( LB_KERNING2 ) ),
	m_aKerningFT		( this, CUI_RES( FT_KERNING2 ) ),
	m_aKerningEdit		( this, CUI_RES( ED_KERNING2 ) ),
	m_aPairKerningBtn	( this, CUI_RES( CB_PAIRKERNING ) ),

	m_nSuperEsc			( (short)DFLT_ESC_SUPER ),
	m_nSubEsc			( (short)DFLT_ESC_SUB ),
	m_nScaleWidthItemSetVal	( 100 ),
	m_nScaleWidthInitialVal	( 100 ),
	m_nSuperProp		( (sal_uInt8)DFLT_ESC_PROP ),
    m_nSubProp          ( (sal_uInt8)DFLT_ESC_PROP )
{
	FreeResource();
	Initialize();
}

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

void SvxCharPositionPage::Initialize()
{
	// to handle the changes of the other pages
	SetExchangeSupport();

	GetPreviewFont().SetSize( Size( 0, 240 ) );
    GetPreviewCJKFont().SetSize( Size( 0, 240 ) );
	GetPreviewCTLFont().SetSize( Size( 0, 240 ) );

	m_aNormalPosBtn.Check();
	PositionHdl_Impl( &m_aNormalPosBtn );
	m_aKerningLB.SelectEntryPos( 0 );
	KerningSelectHdl_Impl( NULL );

	Link aLink = LINK( this, SvxCharPositionPage, PositionHdl_Impl );
	m_aHighPosBtn.SetClickHdl( aLink );
	m_aNormalPosBtn.SetClickHdl( aLink );
	m_aLowPosBtn.SetClickHdl( aLink );

	aLink = LINK( this, SvxCharPositionPage, RotationHdl_Impl );
	m_a0degRB  .SetClickHdl( aLink );
	m_a90degRB .SetClickHdl( aLink );
	m_a270degRB.SetClickHdl( aLink );

	aLink = LINK( this, SvxCharPositionPage, FontModifyHdl_Impl );
	m_aHighLowEdit.SetModifyHdl( aLink );
	m_aFontSizeEdit.SetModifyHdl( aLink );

	aLink = LINK( this, SvxCharPositionPage, LoseFocusHdl_Impl );
	m_aHighLowEdit.SetLoseFocusHdl( aLink );
	m_aFontSizeEdit.SetLoseFocusHdl( aLink );

	m_aHighLowRB.SetClickHdl( LINK( this, SvxCharPositionPage, AutoPositionHdl_Impl ) );
	m_aFitToLineCB.SetClickHdl( LINK( this, SvxCharPositionPage, FitToLineHdl_Impl ) );
	m_aKerningLB.SetSelectHdl( LINK( this, SvxCharPositionPage, KerningSelectHdl_Impl ) );
	m_aKerningEdit.SetModifyHdl( LINK( this, SvxCharPositionPage, KerningModifyHdl_Impl ) );
	m_aPairKerningBtn.SetClickHdl( LINK( this, SvxCharPositionPage, PairKerningHdl_Impl ) );
	m_aScaleWidthMF.SetModifyHdl( LINK( this, SvxCharPositionPage, ScaleWidthModifyHdl_Impl ) );
}

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

void SvxCharPositionPage::UpdatePreview_Impl( sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc )
{
	SetPrevFontEscapement( nProp, nEscProp, nEsc );
}

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

void SvxCharPositionPage::SetEscapement_Impl( sal_uInt16 nEsc )
{
    SvxEscapementItem aEscItm( (SvxEscapement)nEsc, SID_ATTR_CHAR_ESCAPEMENT );

	if ( SVX_ESCAPEMENT_SUPERSCRIPT == nEsc )
	{
		aEscItm.GetEsc() = m_nSuperEsc;
		aEscItm.GetProp() = m_nSuperProp;
	}
	else if ( SVX_ESCAPEMENT_SUBSCRIPT == nEsc )
	{
		aEscItm.GetEsc() = m_nSubEsc;
		aEscItm.GetProp() = m_nSubProp;
	}

	short nFac = aEscItm.GetEsc() < 0 ? -1 : 1;

	m_aHighLowEdit.SetValue( aEscItm.GetEsc() * nFac );
	m_aFontSizeEdit.SetValue( aEscItm.GetProp() );

	if ( SVX_ESCAPEMENT_OFF == nEsc )
	{
		m_aHighLowFT.Disable();
		m_aHighLowEdit.Disable();
		m_aFontSizeFT.Disable();
		m_aFontSizeEdit.Disable();
		m_aHighLowRB.Disable();
	}
	else
	{
		m_aFontSizeFT.Enable();
		m_aFontSizeEdit.Enable();
		m_aHighLowRB.Enable();

		if ( !m_aHighLowRB.IsChecked() )
		{
			m_aHighLowFT.Enable();
			m_aHighLowEdit.Enable();
		}
		else
			AutoPositionHdl_Impl( &m_aHighLowRB );
	}

	UpdatePreview_Impl( 100, aEscItm.GetProp(), aEscItm.GetEsc() );
}

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

IMPL_LINK( SvxCharPositionPage, PositionHdl_Impl, RadioButton*, pBtn )
{
	sal_uInt16 nEsc = SVX_ESCAPEMENT_OFF;	// also when pBtn == NULL

	if ( &m_aHighPosBtn == pBtn )
		nEsc = SVX_ESCAPEMENT_SUPERSCRIPT;
	else if ( &m_aLowPosBtn == pBtn )
		nEsc = SVX_ESCAPEMENT_SUBSCRIPT;

	SetEscapement_Impl( nEsc );
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, RotationHdl_Impl, RadioButton*, pBtn )
{
	sal_Bool bEnable = sal_False;
	if (&m_a90degRB == pBtn  ||  &m_a270degRB == pBtn)
		bEnable = sal_True;
	else
		OSL_ENSURE( &m_a0degRB == pBtn, "unexpected button" );
	m_aFitToLineCB.Enable( bEnable );
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, FontModifyHdl_Impl, MetricField*, EMPTYARG )
{
	sal_uInt8 nEscProp = (sal_uInt8)m_aFontSizeEdit.GetValue();
	short nEsc	= (short)m_aHighLowEdit.GetValue();
	nEsc *= m_aLowPosBtn.IsChecked() ? -1 : 1;
	UpdatePreview_Impl( 100, nEscProp, nEsc );
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, AutoPositionHdl_Impl, CheckBox*, pBox )
{
	if ( pBox->IsChecked() )
	{
		m_aHighLowFT.Disable();
		m_aHighLowEdit.Disable();
	}
	else
		PositionHdl_Impl( m_aHighPosBtn.IsChecked() ? &m_aHighPosBtn
													  : m_aLowPosBtn.IsChecked() ? &m_aLowPosBtn
													  							 : &m_aNormalPosBtn );
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, FitToLineHdl_Impl, CheckBox*, pBox )
{
	if ( &m_aFitToLineCB == pBox)
	{
		sal_uInt16 nVal = m_nScaleWidthInitialVal;
		if (m_aFitToLineCB.IsChecked())
			nVal = m_nScaleWidthItemSetVal;
		m_aScaleWidthMF.SetValue( nVal );

		m_aPreviewWin.SetFontWidthScale( nVal );
	}
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, KerningSelectHdl_Impl, ListBox*, EMPTYARG )
{
	if ( m_aKerningLB.GetSelectEntryPos() > 0 )
	{
		m_aKerningFT.Enable();
		m_aKerningEdit.Enable();

		if ( m_aKerningLB.GetSelectEntryPos() == 2 )
		{
			// Condensed -> max value == 1/6 of the current font height
			SvxFont& rFont = GetPreviewFont();
			long nMax = rFont.GetSize().Height() / 6;
			m_aKerningEdit.SetMax( m_aKerningEdit.Normalize( nMax ), FUNIT_TWIP );
			m_aKerningEdit.SetLast( m_aKerningEdit.GetMax( m_aKerningEdit.GetUnit() ) );
		}
		else
		{
            m_aKerningEdit.SetMax( 9999 );
			m_aKerningEdit.SetLast( 9999 );
		}
	}
	else
	{
		m_aKerningEdit.SetValue( 0 );
		m_aKerningFT.Disable();
		m_aKerningEdit.Disable();
	}

	KerningModifyHdl_Impl( NULL );

	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, KerningModifyHdl_Impl, MetricField*, EMPTYARG )
{
	long nVal = static_cast<long>(m_aKerningEdit.GetValue());
	nVal = LogicToLogic( nVal, MAP_POINT, MAP_TWIP );
	long nKern = (short)m_aKerningEdit.Denormalize( nVal );

	// Condensed? -> then negative
	if ( m_aKerningLB.GetSelectEntryPos() == 2 )
		nKern *= -1;

	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();

	rFont.SetFixKerning( (short)nKern );
    rCJKFont.SetFixKerning( (short)nKern );
	rCTLFont.SetFixKerning( (short)nKern );
	m_aPreviewWin.Invalidate();
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, PairKerningHdl_Impl, CheckBox*, EMPTYARG )
{
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, LoseFocusHdl_Impl, MetricField*, pField )
{
#ifdef DBG_UTIL
	sal_Bool bHigh = m_aHighPosBtn.IsChecked();
#endif
	sal_Bool bLow = m_aLowPosBtn.IsChecked();
	DBG_ASSERT( bHigh || bLow, "normal position is not valid" );

	if ( &m_aHighLowEdit == pField )
	{
		if ( bLow )
			m_nSubEsc = (short)m_aHighLowEdit.GetValue() * -1;
		else
			m_nSuperEsc = (short)m_aHighLowEdit.GetValue();
	}
	else if ( &m_aFontSizeEdit == pField )
	{
		if ( bLow )
			m_nSubProp = (sal_uInt8)m_aFontSizeEdit.GetValue();
		else
			m_nSuperProp = (sal_uInt8)m_aFontSizeEdit.GetValue();
	}
	return 0;
}

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

IMPL_LINK( SvxCharPositionPage, ScaleWidthModifyHdl_Impl, MetricField*, EMPTYARG )
{
	m_aPreviewWin.SetFontWidthScale( sal_uInt16( m_aScaleWidthMF.GetValue() ) );

	return 0;
}

/* -----------------28.08.2003 12:12-----------------

 --------------------------------------------------*/
void  SvxCharPositionPage::ActivatePage( const SfxItemSet& rSet )
{
    //update the preview
    SvxCharBasePage::ActivatePage( rSet );

    //the only thing that has to be checked is the max. allowed value for the
    //condense edit field
    if ( m_aKerningLB.GetSelectEntryPos() == 2 )
    {
        // Condensed -> max value == 1/6 of the current font height
        SvxFont& rFont = GetPreviewFont();
        long nMax = rFont.GetSize().Height() / 6;
        long nKern = (short)m_aKerningEdit.Denormalize( LogicToLogic( static_cast<long>(m_aKerningEdit.GetValue()), MAP_POINT, MAP_TWIP ) );
        m_aKerningEdit.SetMax( m_aKerningEdit.Normalize( nKern > nMax ? nKern : nMax ), FUNIT_TWIP );
        m_aKerningEdit.SetLast( m_aKerningEdit.GetMax( m_aKerningEdit.GetUnit() ) );
    }
}

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

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

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

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

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

sal_uInt16* SvxCharPositionPage::GetRanges()
{
	return pPositionRanges;
}

// -----------------------------------------------------------------------
void SvxCharPositionPage::Reset( const SfxItemSet& rSet )
{
	String sUser = GetUserData();

	if ( sUser.Len() )
	{
		m_nSuperEsc = (short)sUser.GetToken( 0 ).ToInt32();
		m_nSubEsc = (short)sUser.GetToken( 1 ).ToInt32();
		m_nSuperProp = (sal_uInt8)sUser.GetToken( 2 ).ToInt32();
		m_nSubProp = (sal_uInt8)sUser.GetToken( 3 ).ToInt32();
	}

	short nEsc = 0;
	sal_uInt8 nEscProp = 100;
	sal_uInt8 nProp = 100;

	m_aHighLowFT.Disable();
	m_aHighLowEdit.Disable();
	m_aFontSizeFT.Disable();
	m_aFontSizeEdit.Disable();

	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );

	if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
	{
		const SvxEscapementItem& rItem = (SvxEscapementItem&)rSet.Get( nWhich );
		nEsc = rItem.GetEsc();
		nEscProp = rItem.GetProp();

		if ( nEsc != 0 )
		{
			m_aHighLowFT.Enable();
			m_aHighLowEdit.Enable();
			m_aFontSizeFT.Enable();
			m_aFontSizeEdit.Enable();

			short nFac;
            sal_Bool bAutomatic(sal_False);

			if ( nEsc > 0 )
			{
				nFac = 1;
				m_aHighPosBtn.Check( sal_True );
				if ( nEsc == DFLT_ESC_AUTO_SUPER )
				{
					nEsc = DFLT_ESC_SUPER;
                    bAutomatic = sal_True;
				}
			}
			else
			{
				nFac = -1;
				m_aLowPosBtn.Check( sal_True );
				if ( nEsc == DFLT_ESC_AUTO_SUB )
				{
					nEsc = DFLT_ESC_SUB;
                    bAutomatic = sal_True;
				}
			}
            if (!m_aHighLowRB.IsEnabled())
            {
                m_aHighLowRB.Enable();
            }
            m_aHighLowRB.Check(bAutomatic);

			if ( m_aHighLowRB.IsChecked() )
			{
				m_aHighLowFT.Disable();
				m_aHighLowEdit.Disable();
			}
			m_aHighLowEdit.SetValue( m_aHighLowEdit.Normalize( nFac * nEsc ) );
		}
		else
		{
			m_aNormalPosBtn.Check( sal_True );
			m_aHighLowRB.Check( sal_True );
			PositionHdl_Impl( NULL );
		}
	    //the height has to be set after the handler is called to keep the value also if the escapement is zero
        m_aFontSizeEdit.SetValue( m_aFontSizeEdit.Normalize( nEscProp ) );
	}
	else
	{
		m_aHighPosBtn.Check( sal_False );
		m_aNormalPosBtn.Check( sal_False );
		m_aLowPosBtn.Check( sal_False );
	}

	// BspFont setzen
	SetPrevFontEscapement( nProp, nEscProp, nEsc );

	// Kerning
	nWhich = GetWhich( SID_ATTR_CHAR_KERNING );

	if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
	{
		const SvxKerningItem& rItem = (SvxKerningItem&)rSet.Get( nWhich );
		SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );
		MapUnit eOrgUnit = (MapUnit)eUnit;
		MapUnit ePntUnit( MAP_POINT );
		long nBig = static_cast<long>(m_aKerningEdit.Normalize( static_cast<long>(rItem.GetValue()) ));
		long nKerning = LogicToLogic( nBig, eOrgUnit, ePntUnit );

		// Kerning am Font setzen, vorher in Twips umrechnen
		long nKern = LogicToLogic( rItem.GetValue(), (MapUnit)eUnit, MAP_TWIP );
		rFont.SetFixKerning( (short)nKern );
        rCJKFont.SetFixKerning( (short)nKern );
		rCTLFont.SetFixKerning( (short)nKern );

		if ( nKerning > 0 )
		{
			m_aKerningLB.SelectEntryPos( LW_GESPERRT );
		}
		else if ( nKerning < 0 )
		{
			m_aKerningLB.SelectEntryPos( LW_SCHMAL );
			nKerning = -nKerning;
		}
		else
		{
			nKerning = 0;
			m_aKerningLB.SelectEntryPos( LW_NORMAL );
		}
        //enable/disable and set min/max of the Edit
        KerningSelectHdl_Impl(&m_aKerningLB);
        //the attribute value must be displayed also if it's above the maximum allowed value
        long nVal = static_cast<long>(m_aKerningEdit.GetMax());
        if(nVal < nKerning)
            m_aKerningEdit.SetMax( nKerning );
        m_aKerningEdit.SetValue( nKerning );
	}
	else
		m_aKerningEdit.SetText( String() );

	// Pair kerning
	nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN );

	if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
	{
		const SvxAutoKernItem& rItem = (SvxAutoKernItem&)rSet.Get( nWhich );
		m_aPairKerningBtn.Check( rItem.GetValue() );
	}
	else
		m_aPairKerningBtn.Check( sal_False );

	// Scale Width
	nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
	if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
	{
		const SvxCharScaleWidthItem& rItem = ( SvxCharScaleWidthItem& ) rSet.Get( nWhich );
		m_nScaleWidthInitialVal = rItem.GetValue();
		m_aScaleWidthMF.SetValue( m_nScaleWidthInitialVal );
	}
	else
		m_aScaleWidthMF.SetValue( 100 );

    nWhich = GetWhich( SID_ATTR_CHAR_WIDTH_FIT_TO_LINE );
	if ( rSet.GetItemState( nWhich ) >= SFX_ITEM_DEFAULT )
		m_nScaleWidthItemSetVal = ((SfxUInt16Item&) rSet.Get( nWhich )).GetValue();

	// Rotation
	nWhich = GetWhich( SID_ATTR_CHAR_ROTATED );
	SfxItemState eState = rSet.GetItemState( nWhich );
	if( SFX_ITEM_UNKNOWN == eState )
	{
		m_aRotationScalingFL.Hide();
		m_aScalingFL.Show();
		m_a0degRB.Hide();
		m_a90degRB.Hide();
		m_a270degRB.Hide();
		m_aFitToLineCB.Hide();
        m_aFitToLineCB .Hide();


        // move the following controls upwards
		Window* aCntrlArr[] = {
			&m_aScaleWidthFT, &m_aScaleWidthMF, &m_aKerningLine,
			&m_aKerningLB, &m_aKerningFT, &m_aKerningEdit, &m_aPairKerningBtn,
			0 };

        long nDiff = m_aScaleWidthMF.GetPosPixel().Y() -
                        m_a0degRB.GetPosPixel().Y();

		for( Window** ppW = aCntrlArr; *ppW; ++ppW )
		{
			Point aPnt( (*ppW)->GetPosPixel() );
			aPnt.Y() -= nDiff;
			(*ppW)->SetPosPixel( aPnt );
		}
	}
	else
	{
		m_aScalingFL.Hide();

		Link aOldLink( m_aFitToLineCB.GetClickHdl() );
		m_aFitToLineCB.SetClickHdl( Link() );
		if( eState >= SFX_ITEM_DEFAULT )
		{
			const SvxCharRotateItem& rItem =
					(SvxCharRotateItem&) rSet.Get( nWhich );
			if (rItem.IsBottomToTop())
				m_a90degRB.Check( sal_True );
			else if (rItem.IsTopToBotton())
				m_a270degRB.Check( sal_True );
			else
			{
				DBG_ASSERT( 0 == rItem.GetValue(), "incorrect value" );
				m_a0degRB.Check( sal_True );
			}
			m_aFitToLineCB.Check( rItem.IsFitToLine() );
		}
		else
		{
			if( eState == SFX_ITEM_DONTCARE )
			{
				m_a0degRB.Check( sal_False );
				m_a90degRB.Check( sal_False );
				m_a270degRB.Check( sal_False );
			}
			else
				m_a0degRB.Check( sal_True );

			m_aFitToLineCB.Check( sal_False );
		}
		m_aFitToLineCB.SetClickHdl( aOldLink );
		m_aFitToLineCB.Enable( !m_a0degRB.IsChecked() );

		// is this value set?
		if( SFX_ITEM_UNKNOWN == rSet.GetItemState( GetWhich(
										SID_ATTR_CHAR_WIDTH_FIT_TO_LINE ) ))
			m_aFitToLineCB.Hide();
	}

	m_aHighPosBtn.SaveValue();
	m_aNormalPosBtn.SaveValue();
	m_aLowPosBtn.SaveValue();
	m_a0degRB.SaveValue();
	m_a90degRB.SaveValue();
	m_a270degRB.SaveValue();
	m_aFitToLineCB.SaveValue();
	m_aScaleWidthMF.SaveValue();
	m_aKerningLB.SaveValue();
	m_aKerningEdit.SaveValue();
	m_aPairKerningBtn.SaveValue();
}

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

sal_Bool SvxCharPositionPage::FillItemSet( SfxItemSet& rSet )
{
	//	Position (hoch, normal oder tief)
	const SfxItemSet& rOldSet = GetItemSet();
	sal_Bool bModified = sal_False, bChanged = sal_True;
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT );
	const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_CHAR_ESCAPEMENT );
	const FASTBOOL bHigh = m_aHighPosBtn.IsChecked();
	short nEsc;
	sal_uInt8  nEscProp;

	if ( bHigh || m_aLowPosBtn.IsChecked() )
	{
		if ( m_aHighLowRB.IsChecked() )
			nEsc = bHigh ? DFLT_ESC_AUTO_SUPER : DFLT_ESC_AUTO_SUB;
		else
		{
			nEsc = (short)m_aHighLowEdit.Denormalize( m_aHighLowEdit.GetValue() );
			nEsc *= bHigh ? 1 : -1;
		}
		nEscProp = (sal_uInt8)m_aFontSizeEdit.Denormalize( m_aFontSizeEdit.GetValue() );
	}
	else
	{
		nEsc  = 0;
		nEscProp = 100;
	}

	if ( pOld )
	{
		const SvxEscapementItem& rItem = *( (const SvxEscapementItem*)pOld );
		if ( rItem.GetEsc() == nEsc && rItem.GetProp() == nEscProp	)
			bChanged = sal_False;
	}

	if ( !bChanged && !m_aHighPosBtn.GetSavedValue() &&
		 !m_aNormalPosBtn.GetSavedValue() && !m_aLowPosBtn.GetSavedValue() )
		bChanged = sal_True;

	if ( bChanged &&
		 ( m_aHighPosBtn.IsChecked() || m_aNormalPosBtn.IsChecked() || m_aLowPosBtn.IsChecked() ) )
	{
		rSet.Put( SvxEscapementItem( nEsc, nEscProp, nWhich ) );
		bModified = sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Kerning
	nWhich = GetWhich( SID_ATTR_CHAR_KERNING );
	pOld = GetOldItem( rSet, SID_ATTR_CHAR_KERNING );
	sal_uInt16 nPos = m_aKerningLB.GetSelectEntryPos();
	short nKerning = 0;
	SfxMapUnit eUnit = rSet.GetPool()->GetMetric( nWhich );

	if ( nPos == LW_GESPERRT || nPos == LW_SCHMAL )
	{
		long nTmp = static_cast<long>(m_aKerningEdit.GetValue());
		long nVal = LogicToLogic( nTmp, MAP_POINT, (MapUnit)eUnit );
		nKerning = (short)m_aKerningEdit.Denormalize( nVal );

		if ( nPos == LW_SCHMAL )
			nKerning *= - 1;
	}

	if ( pOld )
	{
		const SvxKerningItem& rItem = *( (const SvxKerningItem*)pOld );
		if ( rItem.GetValue() == nKerning )
			bChanged = sal_False;
	}

	if ( !bChanged &&
		 ( m_aKerningLB.GetSavedValue() == LISTBOX_ENTRY_NOTFOUND ||
		   ( !m_aKerningEdit.GetSavedValue().Len() && m_aKerningEdit.IsEnabled() ) ) )
		bChanged = sal_True;

	if ( bChanged && nPos != LISTBOX_ENTRY_NOTFOUND )
	{
		rSet.Put( SvxKerningItem( nKerning, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	bChanged = sal_True;

	// Pair-Kerning
	nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN );

	if ( m_aPairKerningBtn.IsChecked() != m_aPairKerningBtn.GetSavedValue() )
	{
		rSet.Put( SvxAutoKernItem( m_aPairKerningBtn.IsChecked(), nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	// Scale Width
	nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH );
	if ( m_aScaleWidthMF.GetText() != m_aScaleWidthMF.GetSavedValue() )
	{
		rSet.Put( SvxCharScaleWidthItem( (sal_uInt16)m_aScaleWidthMF.GetValue(), nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	// Rotation
	nWhich = GetWhich( SID_ATTR_CHAR_ROTATED );
	if ( m_a0degRB     .IsChecked() != m_a0degRB     .GetSavedValue()  ||
		 m_a90degRB    .IsChecked() != m_a90degRB    .GetSavedValue()  ||
		 m_a270degRB   .IsChecked() != m_a270degRB   .GetSavedValue()  ||
		 m_aFitToLineCB.IsChecked() != m_aFitToLineCB.GetSavedValue() )
	{
		SvxCharRotateItem aItem( 0, m_aFitToLineCB.IsChecked(), nWhich );
		if (m_a90degRB.IsChecked())
			aItem.SetBottomToTop();
		else if (m_a270degRB.IsChecked())
			aItem.SetTopToBotton();
		rSet.Put( aItem );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	return bModified;
}

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

void SvxCharPositionPage::FillUserData()
{
	const sal_Unicode cTok = ';';

	String sUser( UniString::CreateFromInt32( m_nSuperEsc ) );
	sUser.Append( cTok );
	sUser.Append( UniString::CreateFromInt32( m_nSubEsc ) );
	sUser.Append( cTok );
	sUser.Append( UniString::CreateFromInt32( m_nSuperProp ) );
	sUser.Append( cTok );
	sUser.Append( UniString::CreateFromInt32( m_nSubProp ) );
	SetUserData( sUser );
}

// -----------------------------------------------------------------------
void SvxCharPositionPage::SetPreviewBackgroundToCharacter()
{
    m_bPreviewBackgroundToCharacter = sal_True;
}
// -----------------------------------------------------------------------
void SvxCharPositionPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
{
	SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
	if (pFlagItem)
	{
		sal_uInt32 nFlags=pFlagItem->GetValue();
		if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
			SetPreviewBackgroundToCharacter();
	}
}
// class SvxCharTwoLinesPage ------------------------------------------------

SvxCharTwoLinesPage::SvxCharTwoLinesPage( Window* pParent, const SfxItemSet& rInSet ) :

	SvxCharBasePage( pParent, CUI_RES( RID_SVXPAGE_CHAR_TWOLINES ), rInSet, WIN_TWOLINES_PREVIEW, FT_TWOLINES_FONTTYPE ),

	m_aSwitchOnLine		( this, CUI_RES( FL_SWITCHON ) ),
	m_aTwoLinesBtn		( this, CUI_RES( CB_TWOLINES ) ),

	m_aEncloseLine		( this, CUI_RES( FL_ENCLOSE ) ),
	m_aStartBracketFT	( this, CUI_RES( FT_STARTBRACKET ) ),
	m_aStartBracketLB	( this, CUI_RES( ED_STARTBRACKET ) ),
	m_aEndBracketFT		( this, CUI_RES( FT_ENDBRACKET ) ),
	m_aEndBracketLB		( this, CUI_RES( ED_ENDBRACKET ) ),
	m_nStartBracketPosition( 0 ),
	m_nEndBracketPosition( 0 )
{
	FreeResource();
	Initialize();
}

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

void SvxCharTwoLinesPage::Initialize()
{
	Size aSize = m_aStartBracketLB.GetSizePixel();
    aSize.Height() = m_aStartBracketLB.CalcSize( 1, 6 ).Height();
	m_aStartBracketLB.SetSizePixel( aSize );
	aSize = m_aEndBracketLB.GetSizePixel();
    aSize.Height() = m_aEndBracketLB.CalcSize( 1, 6 ).Height();
	m_aEndBracketLB.SetSizePixel( aSize );

	m_aTwoLinesBtn.Check( sal_False );
	TwoLinesHdl_Impl( NULL );

	m_aTwoLinesBtn.SetClickHdl( LINK( this, SvxCharTwoLinesPage, TwoLinesHdl_Impl ) );

	Link aLink = LINK( this, SvxCharTwoLinesPage, CharacterMapHdl_Impl );
	m_aStartBracketLB.SetSelectHdl( aLink );
	m_aEndBracketLB.SetSelectHdl( aLink );

	SvxFont& rFont = GetPreviewFont();
    SvxFont& rCJKFont = GetPreviewCJKFont();
	SvxFont& rCTLFont = GetPreviewCTLFont();
	rFont.SetSize( Size( 0, 220 ) );
    rCJKFont.SetSize( Size( 0, 220 ) );
	rCTLFont.SetSize( Size( 0, 220 ) );
}

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

void SvxCharTwoLinesPage::SelectCharacter( ListBox* pBox )
{
	//CHINA001 SvxCharacterMap aDlg( this );
    bool bStart = pBox == &m_aStartBracketLB;
	//SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
	//if(pFact)
	{
		//AbstractSvxCharacterMap* aDlg = pFact->CreateSvxCharacterMap( this,  RID_SVXDLG_CHARMAP );
		SvxCharacterMap* aDlg = new SvxCharacterMap( this );
		aDlg->DisableFontSelection();//CHINA001 aDlg.DisableFontSelection();

		if ( aDlg->Execute() == RET_OK )//CHINA001 ( aDlg.Execute() == RET_OK )
		{
			sal_Unicode cChar = (sal_Unicode) aDlg->GetChar();//CHINA001 aDlg.GetChar();
			SetBracket( cChar, bStart );
		}
        else
        {
            pBox->SelectEntryPos( bStart ? m_nStartBracketPosition : m_nEndBracketPosition );
        }
		delete aDlg; //add CHINA001
	}
}

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

void SvxCharTwoLinesPage::SetBracket( sal_Unicode cBracket, sal_Bool bStart )
{
    sal_uInt16 nEntryPos = 0;
	ListBox* pBox = bStart ? &m_aStartBracketLB : &m_aEndBracketLB;
	if ( 0 == cBracket )
		pBox->SelectEntryPos(0);
	else
	{
		FASTBOOL bFound = sal_False;
		for ( sal_uInt16 i = 1; i < pBox->GetEntryCount(); ++i )
		{
			if ( (sal_uLong)pBox->GetEntryData(i) != CHRDLG_ENCLOSE_SPECIAL_CHAR )
			{
				const sal_Unicode cChar = pBox->GetEntry(i).GetChar(0);
				if ( cChar == cBracket )
				{
					pBox->SelectEntryPos(i);
                    nEntryPos = i;
					bFound = sal_True;
					break;
				}
			}
		}

		if ( !bFound )
		{
            nEntryPos = pBox->InsertEntry( String( cBracket ) );
			pBox->SelectEntryPos( nEntryPos );
		}
	}
    if( bStart )
        m_nStartBracketPosition = nEntryPos;
    else
        m_nEndBracketPosition = nEntryPos;
}

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

IMPL_LINK( SvxCharTwoLinesPage, TwoLinesHdl_Impl, CheckBox*, EMPTYARG )
{
	sal_Bool bChecked = m_aTwoLinesBtn.IsChecked();
	m_aStartBracketFT.Enable( bChecked );
	m_aStartBracketLB.Enable( bChecked );
	m_aEndBracketFT.Enable( bChecked );
	m_aEndBracketLB.Enable( bChecked );

	UpdatePreview_Impl();
	return 0;
}

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

IMPL_LINK( SvxCharTwoLinesPage, CharacterMapHdl_Impl, ListBox*, pBox )
{
	sal_uInt16 nPos = pBox->GetSelectEntryPos();
	if ( CHRDLG_ENCLOSE_SPECIAL_CHAR == (sal_uLong)pBox->GetEntryData( nPos ) )
		SelectCharacter( pBox );
    else
    {
        bool bStart = pBox == &m_aStartBracketLB;
        if( bStart )
            m_nStartBracketPosition = nPos;
        else
            m_nEndBracketPosition = nPos;
    }
	UpdatePreview_Impl();
	return 0;
}

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

void SvxCharTwoLinesPage::ActivatePage( const SfxItemSet& rSet )
{
	SvxCharBasePage::ActivatePage( rSet );
}

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

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

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

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

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

sal_uInt16* SvxCharTwoLinesPage::GetRanges()
{
	return pTwoLinesRanges;
}

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

void SvxCharTwoLinesPage::Reset( const SfxItemSet& rSet )
{
	m_aTwoLinesBtn.Check( sal_False );
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES );
	SfxItemState eState = rSet.GetItemState( nWhich );

	if ( eState >= SFX_ITEM_DONTCARE )
	{
		const SvxTwoLinesItem& rItem = (SvxTwoLinesItem&)rSet.Get( nWhich );
		m_aTwoLinesBtn.Check( rItem.GetValue() );

		if ( rItem.GetValue() )
		{
			SetBracket( rItem.GetStartBracket(), sal_True );
			SetBracket( rItem.GetEndBracket(), sal_False );
		}
	}
	TwoLinesHdl_Impl( NULL );

	SetPrevFontWidthScale( rSet );
}

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

sal_Bool SvxCharTwoLinesPage::FillItemSet( SfxItemSet& rSet )
{
	const SfxItemSet& rOldSet = GetItemSet();
	sal_Bool bModified = sal_False, bChanged = sal_True;
	sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES );
	const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_CHAR_TWO_LINES );
	sal_Bool bOn = m_aTwoLinesBtn.IsChecked();
	sal_Unicode cStart = ( bOn && m_aStartBracketLB.GetSelectEntryPos() > 0 )
		? m_aStartBracketLB.GetSelectEntry().GetChar(0) : 0;
	sal_Unicode cEnd = ( bOn && m_aEndBracketLB.GetSelectEntryPos() > 0 )
		? m_aEndBracketLB.GetSelectEntry().GetChar(0) : 0;

	if ( pOld )
	{
		const SvxTwoLinesItem& rItem = *( (const SvxTwoLinesItem*)pOld );
		if ( rItem.GetValue() ==  bOn &&
			 ( !bOn || ( rItem.GetStartBracket() == cStart && rItem.GetEndBracket() == cEnd ) ) )
			bChanged = sal_False;
	}

	if ( bChanged )
	{
		rSet.Put( SvxTwoLinesItem( bOn, cStart, cEnd, nWhich ) );
		bModified |= sal_True;
	}
	else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, sal_False ) )
		CLEARTITEM;

	return bModified;
}
/* -----------------------------04.12.00 09:48--------------------------------

 ---------------------------------------------------------------------------*/
void	SvxCharTwoLinesPage::UpdatePreview_Impl()
{
	sal_Unicode cStart = m_aStartBracketLB.GetSelectEntryPos() > 0
		? m_aStartBracketLB.GetSelectEntry().GetChar(0) : 0;
	sal_Unicode cEnd = m_aEndBracketLB.GetSelectEntryPos() > 0
		? m_aEndBracketLB.GetSelectEntry().GetChar(0) : 0;
	m_aPreviewWin.SetBrackets(cStart, cEnd);
	m_aPreviewWin.SetTwoLines(m_aTwoLinesBtn.IsChecked());
    m_aPreviewWin.Invalidate();
}
// -----------------------------------------------------------------------
void SvxCharTwoLinesPage::SetPreviewBackgroundToCharacter()
{
    m_bPreviewBackgroundToCharacter = sal_True;
}

// -----------------------------------------------------------------------
void SvxCharTwoLinesPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
{
	SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
	if (pFlagItem)
	{
		sal_uInt32 nFlags=pFlagItem->GetValue();
		if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER )
			SetPreviewBackgroundToCharacter();
	}
}