xref: /aoo41x/main/cui/source/tabpages/tpline.cxx (revision 50edefd7)

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

#ifndef _SVX_SIZEITEM_HXX //autogen

#include <editeng/sizeitem.hxx>
#endif
#include <tools/shl.hxx>
#include <tools/urlobj.hxx>
#include <sfx2/app.hxx>
#include <sfx2/module.hxx>

#define _SVX_TPLINE_CXX

#include <cuires.hrc>
#include "tabline.hrc"
#include "svx/xattr.hxx"
#include <svx/xpool.hxx>
#include <svx/xtable.hxx>
#include "svx/drawitem.hxx"
#include "cuitabline.hxx"
#include "dlgname.hxx"
#include <dialmgr.hxx>
#include "svx/dlgutil.hxx"
#include <svx/svdmodel.hxx>
#include "svx/svxgrahicitem.hxx"
//#include "linectrl.hrc"
#include <sfx2/request.hxx>
#include "svx/ofaitem.hxx"
#include <svx/svdobj.hxx>
#include <svx/svdview.hxx>
#include <svx/svdmodel.hxx>
#include <svx/numvset.hxx>
#include <vcl/msgbox.hxx>
#include <editeng/numitem.hxx>
#include <editeng/svxenum.hxx>
#include <sfx2/objsh.hxx>
#include <editeng/brshitem.hxx>
#include <svx/gallery.hxx>
#include <unotools/localfilehelper.hxx>
#include "paragrph.hrc"
#include "sfx2/opengrf.hxx"
#include <svx/dialmgr.hxx>
#include <svx/dialogs.hrc>

#define MAX_BMP_WIDTH 	16
#define MAX_BMP_HEIGHT  16
// define ----------------------------------------------------------------

#define DLGWIN this->GetParent()->GetParent()

#define BITMAP_WIDTH   32
#define BITMAP_HEIGHT  12
#define XOUT_WIDTH    150

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

static sal_uInt16 pLineRanges[] =
{
	XATTR_LINETRANSPARENCE,
	XATTR_LINETRANSPARENCE,
	SID_ATTR_LINE_STYLE,
	SID_ATTR_LINE_ENDCENTER,
	0
};

/*************************************************************************
|*
|*	Dialog zum Aendern der Linien
|*
\************************************************************************/

SvxLineTabPage::SvxLineTabPage
(
	Window* pParent,
	const SfxItemSet& rInAttrs
) :
	SvxTabPage			( pParent, CUI_RES( RID_SVXPAGE_LINE ), rInAttrs ),
    aFlLine             ( this, CUI_RES( FL_LINE ) ),
    aFtLineStyle        ( this, CUI_RES( FT_LINE_STYLE ) ),
    aLbLineStyle        ( this, CUI_RES( LB_LINE_STYLE ) ),
    aFtColor            ( this, CUI_RES( FT_COLOR ) ),
    aLbColor            ( this, CUI_RES( LB_COLOR ) ),
    aFtLineWidth        ( this, CUI_RES( FT_LINE_WIDTH ) ),
    aMtrLineWidth       ( this, CUI_RES( MTR_FLD_LINE_WIDTH ) ),
    aFtTransparent      ( this, CUI_RES( FT_TRANSPARENT ) ),
    aMtrTransparent     ( this, CUI_RES( MTR_LINE_TRANSPARENT ) ),
    aFlLineEnds         ( this, CUI_RES( FL_LINE_ENDS ) ),
    aLbStartStyle       ( this, CUI_RES( LB_START_STYLE ) ),
    aMtrStartWidth      ( this, CUI_RES( MTR_FLD_START_WIDTH ) ),
    aTsbCenterStart     ( this, CUI_RES( TSB_CENTER_START ) ),
    aFtLineEndsStyle    ( this, CUI_RES( FT_LINE_ENDS_STYLE ) ),
    aLbEndStyle         ( this, CUI_RES( LB_END_STYLE ) ),
	aFtLineEndsWidth    ( this, CUI_RES( FT_LINE_ENDS_WIDTH ) ),
    aMtrEndWidth        ( this, CUI_RES( MTR_FLD_END_WIDTH ) ),
    aTsbCenterEnd       ( this, CUI_RES( TSB_CENTER_END ) ),
    aCbxSynchronize     ( this, CUI_RES( CBX_SYNCHRONIZE ) ),
    aFLSeparator        ( this, CUI_RES( FL_SEPARATOR ) ),
    aCtlPreview         ( this, CUI_RES( CTL_PREVIEW ) ),

    // #116827#
    maFLEdgeStyle       ( this, CUI_RES( FL_EDGE_STYLE ) ),
    maFTEdgeStyle       ( this, CUI_RES( FT_EDGE_STYLE ) ),
    maLBEdgeStyle       ( this, CUI_RES( LB_EDGE_STYLE ) ),

    // LineCaps
    maFTCapStyle        ( this, CUI_RES( FT_CAP_STYLE ) ),
    maLBCapStyle        ( this, CUI_RES( LB_CAP_STYLE ) ),

    pSymbolList(NULL),
    bNewSize(false),
    nNumMenuGalleryItems(0),
    nSymbolType(SVX_SYMBOLTYPE_UNKNOWN), //unbekannt bzw. unchanged
    pSymbolAttr(NULL),
    //#58425# Symbole auf einer Linie (z.B. StarChart)
    aFlSymbol           ( this, CUI_RES(FL_SYMBOL_FORMAT)),
    aSymbolMB           ( this, CUI_RES(MB_SYMBOL_BITMAP)),
    aSymbolWidthFT      ( this, CUI_RES(FT_SYMBOL_WIDTH)),
	aSymbolWidthMF		( this, CUI_RES(MF_SYMBOL_WIDTH)),
	aSymbolHeightFT		( this, CUI_RES(FT_SYMBOL_HEIGHT)),
	aSymbolHeightMF		( this, CUI_RES(MF_SYMBOL_HEIGHT)),
    aSymbolRatioCB      ( this, CUI_RES(CB_SYMBOL_RATIO)),

    bLastWidthModified(sal_False),
    aSymbolLastSize(Size(0,0)),
    bSymbols(sal_False),

    rOutAttrs           ( rInAttrs ),
    bObjSelected( sal_False ),

    pXPool              ( (XOutdevItemPool*) rInAttrs.GetPool() ),
    aXLStyle            ( XLINE_DASH ),
    aXWidth             ( 1 ),
    aXDash              ( String(), XDash( XDASH_RECT, 3, 7, 2, 40, 15 ) ),
    aXColor             ( String(), COL_LIGHTRED ),
    aXLineAttr          ( pXPool ),
    rXLSet              ( aXLineAttr.GetItemSet() ),
 	pnLineEndListState( 0 ),
	pnDashListState( 0 ),
	pnColorTableState( 0 ),
   nPageType           ( 0 )//CHINA001 pPageType           ( NULL ),
{
	aLbEndStyle.SetAccessibleName(String(CUI_RES(STR_STYLE)));
	aLbStartStyle.SetAccessibleName(String(CUI_RES( STR_LB_START_STYLE ) ) );
	aMtrStartWidth.SetAccessibleName(String(CUI_RES( STR_MTR_FLD_START_WIDTH ) ) );
	aLbEndStyle.SetAccessibleName(String(CUI_RES( STR_LB_END_STYLE ) ) );
	aMtrEndWidth.SetAccessibleName(String(CUI_RES( STR_MTR_FLD_END_WIDTH ) ) );
	aTsbCenterStart.SetAccessibleName(String(CUI_RES( STR_CENTER_START ) ) );
	aTsbCenterEnd.SetAccessibleName(String(CUI_RES( STR_CENTER_END ) ) );

	FreeResource();

	aCtlPreview.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));

	// diese Page braucht ExchangeSupport
	SetExchangeSupport();

	// Metrik einstellen
	FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs );

	switch ( eFUnit )
	{
		case FUNIT_M:
		case FUNIT_KM:
			eFUnit = FUNIT_MM;
			// no break -> we now have mm
		case FUNIT_MM:
			aMtrLineWidth.SetSpinSize( 50 );
			aMtrStartWidth.SetSpinSize( 50 );
			aMtrEndWidth.SetSpinSize( 50 );
			break;

			case FUNIT_INCH:
			aMtrLineWidth.SetSpinSize( 2 );
			aMtrStartWidth.SetSpinSize( 2 );
			aMtrEndWidth.SetSpinSize( 2 );
			break;
            default: ;//prevent warning
	}
	SetFieldUnit( aMtrLineWidth, eFUnit );
	SetFieldUnit( aMtrStartWidth, eFUnit );
	SetFieldUnit( aMtrEndWidth, eFUnit );

	// PoolUnit ermitteln
	SfxItemPool* pPool = rOutAttrs.GetPool();
	DBG_ASSERT( pPool, "Wo ist der Pool?" );
	ePoolUnit = pPool->GetMetric( SID_ATTR_LINE_WIDTH );

	aLbLineStyle.SetSelectHdl(
		LINK( this, SvxLineTabPage, ClickInvisibleHdl_Impl ) );
	aLbColor.SetSelectHdl(
		LINK( this, SvxLineTabPage, ChangePreviewHdl_Impl ) );
	aMtrLineWidth.SetModifyHdl(
		LINK( this, SvxLineTabPage, ChangePreviewHdl_Impl ) );
	aMtrTransparent.SetModifyHdl(
		LINK( this, SvxLineTabPage, ChangeTransparentHdl_Impl ) );

	Link aStart = LINK( this, SvxLineTabPage, ChangeStartHdl_Impl );
	Link aEnd = LINK( this, SvxLineTabPage, ChangeEndHdl_Impl );
	aLbStartStyle.SetSelectHdl( aStart );
	aLbEndStyle.SetSelectHdl( aEnd );
	aMtrStartWidth.SetModifyHdl( aStart );
	aMtrEndWidth.SetModifyHdl( aEnd );
	aTsbCenterStart.SetClickHdl( aStart );
	aTsbCenterEnd.SetClickHdl( aEnd );

	// #116827#
	Link aEdgeStyle = LINK( this, SvxLineTabPage, ChangeEdgeStyleHdl_Impl );
	maLBEdgeStyle.SetSelectHdl( aEdgeStyle );

    // LineCaps
    Link aCapStyle = LINK( this, SvxLineTabPage, ChangeCapStyleHdl_Impl );
    maLBCapStyle.SetSelectHdl( aCapStyle );

	//#58425# Symbole auf einer Linie (z.B. StarChart) , MB-Handler setzen
	aSymbolMB.SetSelectHdl(LINK(this, SvxLineTabPage, GraphicHdl_Impl));
    aSymbolMB.SetActivateHdl(LINK(this, SvxLineTabPage, MenuCreateHdl_Impl));
	aSymbolWidthMF.SetModifyHdl(LINK(this, SvxLineTabPage, SizeHdl_Impl));
	aSymbolHeightMF.SetModifyHdl(LINK(this, SvxLineTabPage, SizeHdl_Impl));
	aSymbolRatioCB.SetClickHdl(LINK(this, SvxLineTabPage, RatioHdl_Impl));

	aSymbolRatioCB.Check(sal_True);
	ShowSymbolControls(sal_False);

	// #63083#
	nActLineWidth = -1;
}
//#58425# Symbole auf einer Linie (z.B. StarChart) , Symbol-Controls aktivieren
void SvxLineTabPage::ShowSymbolControls(sal_Bool bOn)
{
	bSymbols=bOn;
	aSymbolWidthFT.Show(bOn);
	aSymbolWidthMF.Show(bOn);
	aSymbolHeightFT.Show(bOn);
	aSymbolHeightMF.Show(bOn);
	aFlSymbol.Show(bOn);
	aSymbolRatioCB.Show(bOn);
	aSymbolMB.Show(bOn);
	aCtlPreview.ShowSymbol(bOn);
}
// -----------------------------------------------------------------------
//#58425# Symbole auf einer Linie (z.B. StarChart) , dtor neu!
SvxLineTabPage::~SvxLineTabPage()
{
	delete aSymbolMB.GetPopupMenu()->GetPopupMenu( MN_GALLERY );

	if(pSymbolList)
		delete aSymbolMB.GetPopupMenu()->GetPopupMenu( MN_SYMBOLS );

	String* pStr = (String*)aGrfNames.First();
	while( pStr )
	{
		delete pStr;
		pStr = (String*)aGrfNames.Next();
	}
	SvxBmpItemInfo* pInfo = (SvxBmpItemInfo*)aGrfBrushItems.First();
	while( pInfo )
	{
		delete pInfo->pBrushItem;
		delete pInfo;
		pInfo = (SvxBmpItemInfo*)aGrfBrushItems.Next();
	}
}
void SvxLineTabPage::Construct()
{
	// Farbtabelle
	aLbColor.Fill( maColorTab );
	FillListboxes();
}

void SvxLineTabPage::FillListboxes()
{
	// Linienstile
	sal_uInt16 nOldSelect = aLbLineStyle.GetSelectEntryPos();
	// aLbLineStyle.FillStyles();
	aLbLineStyle.Fill( maDashList );
	aLbLineStyle.SelectEntryPos( nOldSelect );

	// LinienEndenStile
	String sNone( SVX_RES( RID_SVXSTR_NONE ) );
	nOldSelect = aLbStartStyle.GetSelectEntryPos();
	aLbStartStyle.Clear();
	aLbStartStyle.InsertEntry( sNone );
	aLbStartStyle.Fill( maLineEndList );
	aLbStartStyle.SelectEntryPos( nOldSelect );
	nOldSelect = aLbEndStyle.GetSelectEntryPos();
	aLbEndStyle.Clear();
	aLbEndStyle.InsertEntry( sNone );
	aLbEndStyle.Fill( maLineEndList, sal_False );
	aLbEndStyle.SelectEntryPos( nOldSelect );
}

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

void SvxLineTabPage::ActivatePage( const SfxItemSet& rSet )
{
	SFX_ITEMSET_ARG (&rSet,pPageTypeItem,CntUInt16Item,SID_PAGE_TYPE,sal_False); //add CHINA001 begin
	if (pPageTypeItem)
		SetPageType(pPageTypeItem->GetValue());	//add CHINA001 end
	if( nDlgType == 0 && maDashList.get() )  //CHINA001 if( *pDlgType == 0 && pDashList ) // Linien-Dialog
	{
		sal_uInt16 nPos;
		sal_uInt16 nCount;

		// Dashliste
		if( ( *pnDashListState & CT_MODIFIED ) ||
			( *pnDashListState & CT_CHANGED ) )
		{
			if( *pnDashListState & CT_CHANGED )
				maDashList = ( (SvxLineTabDialog*) DLGWIN )->GetNewDashList();
			*pnDashListState = CT_NONE;

			// Styleliste
			nPos = aLbLineStyle.GetSelectEntryPos();

			aLbLineStyle.Clear();
			aLbLineStyle.InsertEntry(
				SVX_RESSTR( RID_SVXSTR_INVISIBLE ) );
			aLbLineStyle.InsertEntry(
				SVX_RESSTR( RID_SVXSTR_SOLID ) );
			aLbLineStyle.Fill( maDashList );
			nCount = aLbLineStyle.GetEntryCount();

			if ( nCount == 0 )
				; // Dieser Fall sollte nicht auftreten
			else if( nCount <= nPos )
				aLbLineStyle.SelectEntryPos( 0 );
			else
				aLbLineStyle.SelectEntryPos( nPos );
			// SelectStyleHdl_Impl( this );
		}

		INetURLObject	aDashURL( maDashList->GetPath() );

		aDashURL.Append( maDashList->GetName() );
		DBG_ASSERT( aDashURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
/*		// Ermitteln (evtl. abschneiden) des Namens und in
		// der GroupBox darstellen
		String			aString( ResId( RID_SVXSTR_TABLE, pMgr ) ); aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );

		if ( aDashURL.getBase().Len() > 18 )
		{
			aString += aDashURL.getBase().Copy( 0, 15 );
			aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "..." ) );
		}
		else
			aString += aDashURL.getBase();

		aGrpLine.SetText( aString );
*/
		// LineEndliste
		if( ( *pnLineEndListState & CT_MODIFIED ) ||
			( *pnLineEndListState & CT_CHANGED ) )
		{
			if( *pnLineEndListState & CT_CHANGED )
				maLineEndList = ( (SvxLineTabDialog*) DLGWIN )->GetNewLineEndList();
			*pnLineEndListState = CT_NONE;

			nPos = aLbLineStyle.GetSelectEntryPos();
			String sNone( SVX_RES( RID_SVXSTR_NONE ) );
			aLbStartStyle.Clear();
			aLbStartStyle.InsertEntry( sNone );

			aLbStartStyle.Fill( maLineEndList );
			nCount = aLbStartStyle.GetEntryCount();
			if( nCount == 0 )
				; // Dieser Fall sollte nicht auftreten
			else if( nCount <= nPos )
				aLbStartStyle.SelectEntryPos( 0 );
			else
				aLbStartStyle.SelectEntryPos( nPos );

			aLbEndStyle.Clear();
			aLbEndStyle.InsertEntry( sNone );

			aLbEndStyle.Fill( maLineEndList, sal_False );
			nCount = aLbEndStyle.GetEntryCount();

			if( nCount == 0 )
				; // Dieser Fall sollte nicht auftreten
			else if( nCount <= nPos )
				aLbEndStyle.SelectEntryPos( 0 );
			else
				aLbEndStyle.SelectEntryPos( nPos );
		}
		INetURLObject aLineURL( maLineEndList->GetPath() );

		aLineURL.Append( maLineEndList->GetName() );
		DBG_ASSERT( aLineURL.GetProtocol() != INET_PROT_NOT_VALID, "invalid URL" );
/*		// Ermitteln (evtl. abschneiden) des Namens und in
		// der GroupBox darstellen
		aString = String( ResId( RID_SVXSTR_TABLE, pMgr ) ); aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ": " ) );

		if ( aLineURL.getBase().Len() > 18 )
		{
			aString += aLineURL.getBase().Copy( 0, 15 );
			aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "..." ) );
		}
		else
			aString += aLineURL.getBase();

		aGrpLineEnds.SetText( aString );
*/
		// Auswertung, ob von einer anderen TabPage ein anderer Fuelltyp gesetzt wurde
		if( aLbLineStyle.GetSelectEntryPos() != 0 )
		{
			if( nPageType == 2 ) // 1//CHINA001 if( *pPageType == 2 ) // 1
			{
				aLbLineStyle.SelectEntryPos( *pPosDashLb + 2 ); // +2 wegen SOLID und INVLISIBLE
				ChangePreviewHdl_Impl( this );
			}
			if( nPageType == 3 )//CHINA001 if( *pPageType == 3 )
			{
				aLbStartStyle.SelectEntryPos( *pPosLineEndLb + 1 );// +1 wegen SOLID
				aLbEndStyle.SelectEntryPos( *pPosLineEndLb + 1 );// +1 wegen SOLID
				ChangePreviewHdl_Impl( this );
			}
		}

			// ColorTable
			if( *pnColorTableState )
			{
				if( *pnColorTableState & CT_CHANGED )
					maColorTab = ( (SvxLineTabDialog*) DLGWIN )->GetNewColorTable();
				// aLbColor
                sal_uInt16 nColorPos = aLbColor.GetSelectEntryPos();
				aLbColor.Clear();
				aLbColor.Fill( maColorTab );
				nCount = aLbColor.GetEntryCount();
				if( nCount == 0 )
					; // This case should never occur
                else if( nCount <= nColorPos )
					aLbColor.SelectEntryPos( 0 );
				else
                    aLbColor.SelectEntryPos( nColorPos );

				ChangePreviewHdl_Impl( this );
			}

		nPageType = 0;//CHINA001 *pPageType = 0;
	}
	// Seite existiert im Ctor noch nicht, deswegen hier!

	else if ( nDlgType == 1100 || // Chart-Dialog//CHINA001 else if ( *pDlgType == 1100 || // Chart-Dialog
			  nDlgType == 1101 )//CHINA001 *pDlgType == 1101 )
	{
		aFtLineEndsStyle.Hide();
		aFtLineEndsWidth.Hide();
		aLbStartStyle.Hide();
		aMtrStartWidth.Hide();
		aTsbCenterStart.Hide();
		aLbEndStyle.Hide();
		aMtrEndWidth.Hide();
		aTsbCenterEnd.Hide();
		aCbxSynchronize.Hide();
		aFlLineEnds.Hide();

		// #116827#
		maFLEdgeStyle.Hide();
		maFTEdgeStyle.Hide();
		maLBEdgeStyle.Hide();

        // LineCaps
        maFTCapStyle.Hide();
        maLBCapStyle.Hide();
	}
}

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

int SvxLineTabPage::DeactivatePage( SfxItemSet* _pSet )
{
	if( nDlgType == 0 ) // Linien-Dialog//CHINA001 if( *pDlgType == 0 ) // Linien-Dialog
	{
		nPageType = 1; // evtl. fuer Erweiterungen//CHINA001 *pPageType = 1; // evtl. fuer Erweiterungen
		*pPosDashLb = aLbLineStyle.GetSelectEntryPos() - 2;// erster Eintrag SOLID !!!
		sal_uInt16 nPos = aLbStartStyle.GetSelectEntryPos();
		if( nPos != LISTBOX_ENTRY_NOTFOUND )
			nPos--;
		*pPosLineEndLb = nPos;
	}

    if( _pSet )
        FillItemSet( *_pSet );

	return( LEAVE_PAGE );
}

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

sal_Bool SvxLineTabPage::FillItemSet( SfxItemSet& rAttrs )
{
	const SfxPoolItem* pOld = NULL;
	sal_uInt16	nPos;
	sal_Bool	bModified = sal_False;

	// Um evtl. Modifikationen der Liste vorzubeugen
	// werden Items anderer Seiten nicht gesetzt
	if( nDlgType != 0 || nPageType != 2 )//CHINA001 if( *pDlgType != 0 || *pPageType != 2 )
	{
		nPos = aLbLineStyle.GetSelectEntryPos();
		if( nPos != LISTBOX_ENTRY_NOTFOUND &&
			nPos != aLbLineStyle.GetSavedValue() )
		{
			XLineStyleItem*	pStyleItem = NULL;

			if( nPos == 0 )
				pStyleItem = new XLineStyleItem( XLINE_NONE );
			else if( nPos == 1 )
				pStyleItem = new XLineStyleItem( XLINE_SOLID );
			else
			{
				pStyleItem = new XLineStyleItem( XLINE_DASH );

				// Zusaetzliche Sicherheit
				if( maDashList->Count() > (long) ( nPos - 2 ) )
				{
					XLineDashItem aDashItem( aLbLineStyle.GetSelectEntry(), maDashList->GetDash( nPos - 2 )->GetDash() );
					pOld = GetOldItem( rAttrs, XATTR_LINEDASH );
					if ( !pOld || !( *(const XLineDashItem*)pOld == aDashItem ) )
					{
						rAttrs.Put( aDashItem );
						bModified = sal_True;
					}
				}
			}
			pOld = GetOldItem( rAttrs, XATTR_LINESTYLE );
			if ( !pOld || !( *(const XLineStyleItem*)pOld == *pStyleItem ) )
			{
				rAttrs.Put( *pStyleItem );
				bModified = sal_True;
			}
			delete pStyleItem;
		}
	}
	// Linienbreite
	// GetSavedValue() liefert String!
	if( aMtrLineWidth.GetText() != aMtrLineWidth.GetSavedValue() )
	{
		XLineWidthItem aItem( GetCoreValue( aMtrLineWidth, ePoolUnit ) );
		pOld = GetOldItem( rAttrs, XATTR_LINEWIDTH );
		if ( !pOld || !( *(const XLineWidthItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}
	//Breite Linienanfang
	if( aMtrStartWidth.GetText() != aMtrStartWidth.GetSavedValue() )
	{
		XLineStartWidthItem aItem( GetCoreValue( aMtrStartWidth, ePoolUnit ) );
		pOld = GetOldItem( rAttrs, XATTR_LINESTARTWIDTH );
		if ( !pOld || !( *(const XLineStartWidthItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}
	//Breite Linienende
	if( aMtrEndWidth.GetText() != aMtrEndWidth.GetSavedValue() )
	{
		XLineEndWidthItem aItem( GetCoreValue( aMtrEndWidth, ePoolUnit ) );
		pOld = GetOldItem( rAttrs, XATTR_LINEENDWIDTH );
		if ( !pOld || !( *(const XLineEndWidthItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}

	// Linienfarbe
	if( aLbColor.GetSelectEntryPos() != aLbColor.GetSavedValue() )
	{
		XLineColorItem aItem( aLbColor.GetSelectEntry(),
							  aLbColor.GetSelectEntryColor() );
		pOld = GetOldItem( rAttrs, XATTR_LINECOLOR );
		if ( !pOld || !( *(const XLineColorItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}

	if( nDlgType != 0 || nPageType != 3 )//CHINA001 if( *pDlgType != 0 || *pPageType != 3 )
	{
		// Linienanfang
		nPos = aLbStartStyle.GetSelectEntryPos();
		if( nPos != LISTBOX_ENTRY_NOTFOUND &&
			nPos != aLbStartStyle.GetSavedValue() )
		{
			XLineStartItem* pItem = NULL;
			if( nPos == 0 )
				pItem = new XLineStartItem();
			else if( maLineEndList->Count() > (long) ( nPos - 1 ) )
				pItem = new XLineStartItem( aLbStartStyle.GetSelectEntry(),
                            maLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() );
			pOld = GetOldItem( rAttrs, XATTR_LINESTART );
			if( pItem &&
				( !pOld || !( *(const XLineEndItem*)pOld == *pItem ) ) )
			{
				rAttrs.Put( *pItem );
				bModified = sal_True;
			}
			delete pItem;
		}
		// Linienende
		nPos = aLbEndStyle.GetSelectEntryPos();
		if( nPos != LISTBOX_ENTRY_NOTFOUND &&
			nPos != aLbEndStyle.GetSavedValue() )
		{
			XLineEndItem* pItem = NULL;
			if( nPos == 0 )
				pItem = new XLineEndItem();
			else if( maLineEndList->Count() > (long) ( nPos - 1 ) )
				pItem = new XLineEndItem( aLbEndStyle.GetSelectEntry(),
                            maLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() );
			pOld = GetOldItem( rAttrs, XATTR_LINEEND );
			if( pItem &&
				( !pOld || !( *(const XLineEndItem*)pOld == *pItem ) ) )
			{
				rAttrs.Put( *pItem );
				bModified = sal_True;
			}
			delete pItem;
		}
	}

	// Linienenden zentriert
	TriState eState = aTsbCenterStart.GetState();
	if( eState != aTsbCenterStart.GetSavedValue() )
	{
		XLineStartCenterItem aItem( sal::static_int_cast< sal_Bool >( eState ) );
		pOld = GetOldItem( rAttrs, XATTR_LINESTARTCENTER );
		if ( !pOld || !( *(const XLineStartCenterItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}
	eState = aTsbCenterEnd.GetState();
	if( eState != aTsbCenterEnd.GetSavedValue() )
	{
		XLineEndCenterItem aItem( sal::static_int_cast< sal_Bool >( eState ) );
		pOld = GetOldItem( rAttrs, XATTR_LINEENDCENTER );
		if ( !pOld || !( *(const XLineEndCenterItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}

	//Breite Linienanfang
	if( aMtrStartWidth.GetText() != aMtrStartWidth.GetSavedValue() )
	{
		XLineStartWidthItem aItem( GetCoreValue( aMtrStartWidth, ePoolUnit ) );
		pOld = GetOldItem( rAttrs, XATTR_LINESTARTWIDTH );
		if ( !pOld || !( *(const XLineStartWidthItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}
	//Breite Linienende
	if( aMtrEndWidth.GetText() != aMtrEndWidth.GetSavedValue() )
	{
		XLineEndWidthItem aItem( GetCoreValue( aMtrEndWidth, ePoolUnit ) );
		pOld = GetOldItem( rAttrs, XATTR_LINEENDWIDTH );
		if ( !pOld || !( *(const XLineEndWidthItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}

	// Transparenz
	sal_uInt16 nVal = (sal_uInt16)aMtrTransparent.GetValue();
	if( nVal != (sal_uInt16)aMtrTransparent.GetSavedValue().ToInt32() )
	{
		XLineTransparenceItem aItem( nVal );
		pOld = GetOldItem( rAttrs, XATTR_LINETRANSPARENCE );
		if ( !pOld || !( *(const XLineTransparenceItem*)pOld == aItem ) )
		{
			rAttrs.Put( aItem );
			bModified = sal_True;
		}
	}

	// #116827#
	nPos = maLBEdgeStyle.GetSelectEntryPos();
	if( LISTBOX_ENTRY_NOTFOUND != nPos && nPos != maLBEdgeStyle.GetSavedValue() )
	{
		XLineJointItem* pNew = 0L;

		switch(nPos)
		{
			case 0: // Rounded, default
			{
				pNew = new XLineJointItem(com::sun::star::drawing::LineJoint_ROUND);
				break;
			}
			case 1: // - none -
			{
				pNew = new XLineJointItem(com::sun::star::drawing::LineJoint_NONE);
				break;
			}
			case 2: // Miter
			{
				pNew = new XLineJointItem(com::sun::star::drawing::LineJoint_MITER);
				break;
			}
			case 3: // Bevel
			{
				pNew = new XLineJointItem(com::sun::star::drawing::LineJoint_BEVEL);
				break;
			}
		}

		if(pNew)
		{
			pOld = GetOldItem( rAttrs, XATTR_LINEJOINT );

			if(!pOld || !(*(const XLineJointItem*)pOld == *pNew))
			{
				rAttrs.Put( *pNew );
				bModified = sal_True;
			}

			delete pNew;
		}
	}

    // LineCaps
    nPos = maLBCapStyle.GetSelectEntryPos();
    if( LISTBOX_ENTRY_NOTFOUND != nPos && nPos != maLBCapStyle.GetSavedValue() )
    {
        XLineCapItem* pNew = 0L;

        switch(nPos)
        {
            case 0: // Butt (=Flat), default
            {
                pNew = new XLineCapItem(com::sun::star::drawing::LineCap_BUTT);
                break;
            }
            case 1: // Round
            {
                pNew = new XLineCapItem(com::sun::star::drawing::LineCap_ROUND);
                break;
            }
            case 2: // Square
            {
                pNew = new XLineCapItem(com::sun::star::drawing::LineCap_SQUARE);
                break;
            }
        }

        if(pNew)
        {
            pOld = GetOldItem( rAttrs, XATTR_LINECAP );

            if(!pOld || !(*(const XLineCapItem*)pOld == *pNew))
            {
                rAttrs.Put( *pNew );
                bModified = sal_True;
            }

            delete pNew;
        }
    }

	if(nSymbolType!=SVX_SYMBOLTYPE_UNKNOWN || bNewSize)
	{
		//wurde also per Auswahl gesetzt oder Gr��e ist anders
		SvxSizeItem  aSItem(rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE),aSymbolSize);
		const SfxPoolItem* pSOld = GetOldItem( rAttrs, rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE) );
		bNewSize  = pSOld ? *(const SvxSizeItem *)pSOld != aSItem : bNewSize ;
		if(bNewSize)
		{
			rAttrs.Put(aSItem);
			bModified=sal_True;
		}

		SfxInt32Item aTItem(rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE),nSymbolType);
		const SfxPoolItem* pTOld = GetOldItem( rAttrs, rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE) );
		bool bNewType = pTOld == NULL || *(const SfxInt32Item*)pTOld != aTItem;
		if(bNewType && nSymbolType==SVX_SYMBOLTYPE_UNKNOWN)
			bNewType=false;//kleine Korrektur, Typ wurde garnicht gesetzt -> kein Type-Item erzeugen!
		if(bNewType)
		{
			rAttrs.Put(aTItem);
			bModified=sal_True;
		}

		if(nSymbolType!=SVX_SYMBOLTYPE_NONE)
		{
			SvxBrushItem aBItem(aSymbolGraphic,GPOS_MM,rAttrs.GetPool()->GetWhich(SID_ATTR_BRUSH));
			const SfxPoolItem* pBOld = GetOldItem( rAttrs, rAttrs.GetPool()->GetWhich(SID_ATTR_BRUSH) );
			bool bNewBrush =
                pBOld == NULL || *(const SvxBrushItem*)pBOld != aBItem;
			if(bNewBrush)
			{
				rAttrs.Put(aBItem);
				bModified=sal_True;
			}
		}
	}
	rAttrs.Put (CntUInt16Item(SID_PAGE_TYPE,nPageType));//add CHINA001
	return( bModified );
}

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

sal_Bool SvxLineTabPage::FillXLSet_Impl()
{
	sal_uInt16 nPos;

	if( aLbLineStyle.GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND )
	{
		//rXLSet.Put( XLineDashItem ( rOutAttrs.Get( GetWhich( XATTR_LINEDASH ) ) ) );
		rXLSet.Put( XLineStyleItem( XLINE_NONE ) );
	}
	else if( aLbLineStyle.IsEntryPosSelected( 0 ) )
		rXLSet.Put( XLineStyleItem( XLINE_NONE ) );
	else if( aLbLineStyle.IsEntryPosSelected( 1 ) )
		rXLSet.Put( XLineStyleItem( XLINE_SOLID ) );
	else
	{
		rXLSet.Put( XLineStyleItem( XLINE_DASH ) );

		nPos = aLbLineStyle.GetSelectEntryPos();
		if( nPos != LISTBOX_ENTRY_NOTFOUND )
		{
			rXLSet.Put( XLineDashItem( aLbLineStyle.GetSelectEntry(), maDashList->GetDash( nPos - 2 )->GetDash() ) );
		}
	}

	nPos = aLbStartStyle.GetSelectEntryPos();
	if( nPos != LISTBOX_ENTRY_NOTFOUND )
	{
		if( nPos == 0 )
			rXLSet.Put( XLineStartItem() );
		else
			rXLSet.Put( XLineStartItem( aLbStartStyle.GetSelectEntry(),
                        maLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) );
	}
	nPos = aLbEndStyle.GetSelectEntryPos();
	if( nPos != LISTBOX_ENTRY_NOTFOUND )
	{
		if( nPos == 0 )
			rXLSet.Put( XLineEndItem() );
		else
			rXLSet.Put( XLineEndItem( aLbEndStyle.GetSelectEntry(),
                        maLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) );
	}

	// #116827#
	nPos = maLBEdgeStyle.GetSelectEntryPos();
	if(LISTBOX_ENTRY_NOTFOUND != nPos)
	{
		switch(nPos)
		{
			case 0: // Rounded, default
			{
				rXLSet.Put(XLineJointItem(com::sun::star::drawing::LineJoint_ROUND));
				break;
			}
			case 1: // - none -
			{
				rXLSet.Put(XLineJointItem(com::sun::star::drawing::LineJoint_NONE));
				break;
			}
			case 2: // Miter
			{
				rXLSet.Put(XLineJointItem(com::sun::star::drawing::LineJoint_MITER));
				break;
			}
			case 3: // Bevel
			{
				rXLSet.Put(XLineJointItem(com::sun::star::drawing::LineJoint_BEVEL));
				break;
			}
		}
	}

    // LineCaps
    nPos = maLBCapStyle.GetSelectEntryPos();
    if(LISTBOX_ENTRY_NOTFOUND != nPos)
    {
        switch(nPos)
        {
            case 0: // Butt (=Flat), default
            {
                rXLSet.Put(XLineCapItem(com::sun::star::drawing::LineCap_BUTT));
                break;
            }
            case 1: // Round
            {
                rXLSet.Put(XLineCapItem(com::sun::star::drawing::LineCap_ROUND));
                break;
            }
            case 2: // Square
            {
                rXLSet.Put(XLineCapItem(com::sun::star::drawing::LineCap_SQUARE));
                break;
            }
        }
    }

	rXLSet.Put( XLineStartWidthItem( GetCoreValue( aMtrStartWidth, ePoolUnit ) ) );
	rXLSet.Put( XLineEndWidthItem( GetCoreValue( aMtrEndWidth, ePoolUnit ) ) );

	rXLSet.Put( XLineWidthItem( GetCoreValue( aMtrLineWidth, ePoolUnit ) ) );
	rXLSet.Put( XLineColorItem( aLbColor.GetSelectEntry(),
									aLbColor.GetSelectEntryColor() ) );

	// Linienenden zentriert
	if( aTsbCenterStart.GetState() == STATE_CHECK )
		rXLSet.Put( XLineStartCenterItem( sal_True ) );
	else if( aTsbCenterStart.GetState() == STATE_NOCHECK )
		rXLSet.Put( XLineStartCenterItem( sal_False ) );

	if( aTsbCenterEnd.GetState() == STATE_CHECK )
		rXLSet.Put( XLineEndCenterItem( sal_True ) );
	else if( aTsbCenterEnd.GetState() == STATE_NOCHECK )
		rXLSet.Put( XLineEndCenterItem( sal_False ) );

	// Transparenz
	sal_uInt16 nVal = (sal_uInt16)aMtrTransparent.GetValue();
	rXLSet.Put( XLineTransparenceItem( nVal ) );

	// #116827#
	aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet());

	return( sal_True );
}

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

void SvxLineTabPage::Reset( const SfxItemSet& rAttrs )
{
	String		aString;
	XLineStyle	eXLS; // XLINE_NONE, XLINE_SOLID, XLINE_DASH

	// Linienstil
/*
	if( bObjSelected &&
		rAttrs.GetItemState( GetWhich( XATTR_LINESTYLE ) ) == SFX_ITEM_DEFAULT )
	{
		aLbLineStyle.Disable();
	}
*/
	const SfxPoolItem *pPoolItem;
	long nSymType=SVX_SYMBOLTYPE_UNKNOWN;
	sal_Bool bPrevSym=sal_False;
	sal_Bool bEnable=sal_True;
	sal_Bool bIgnoreGraphic=sal_False;
	sal_Bool bIgnoreSize=sal_False;
	if(rAttrs.GetItemState(rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE),sal_True,&pPoolItem) == SFX_ITEM_SET)
	{
		nSymType=((const SfxInt32Item *)pPoolItem)->GetValue();
	}

	if(nSymType == SVX_SYMBOLTYPE_AUTO)
	{
		aSymbolGraphic=aAutoSymbolGraphic;
		aSymbolSize=aSymbolLastSize=aAutoSymbolGraphic.GetPrefSize();
		bPrevSym=sal_True;
	}
	else if(nSymType == SVX_SYMBOLTYPE_NONE)
	{
		bEnable=sal_False;
		bIgnoreGraphic=sal_True;
		bIgnoreSize=sal_True;
	}
	else if(nSymType >= 0)
	{
		VirtualDevice aVDev;
		aVDev.SetMapMode(MapMode(MAP_100TH_MM));

		SdrModel* pModel = new SdrModel(NULL, NULL, LOADREFCOUNTS);
		pModel->GetItemPool().FreezeIdRanges();
		SdrPage* pPage = new SdrPage( *pModel, sal_False );
		pPage->SetSize(Size(1000,1000));
		pModel->InsertPage( pPage, 0 );
		SdrView* pView = new SdrView( pModel, &aVDev );
		pView->hideMarkHandles();
		/*SdrPageView* pPageView = */pView->ShowSdrPage(pPage);
		SdrObject *pObj=NULL;
		long nSymTmp=nSymType;
		if(pSymbolList)
		{
			if(pSymbolList->GetObjCount())
			{
				nSymTmp=nSymTmp%pSymbolList->GetObjCount(); //Liste wird als cyclisch betrachtet!!!
				pObj=pSymbolList->GetObj(nSymTmp);
				if(pObj)
				{
					pObj=pObj->Clone();
					if(pSymbolAttr)
					{
						pObj->SetMergedItemSet(*pSymbolAttr);
					}
					else
					{
						pObj->SetMergedItemSet(rOutAttrs);
					}

                    pPage->NbcInsertObject(pObj);

                    // Generate invisible square to give all symbol types a
                    // bitmap size, which is indepedent from specific glyph
                    SdrObject *pInvisibleSquare=pSymbolList->GetObj(0);
                    pInvisibleSquare=pInvisibleSquare->Clone();
                    pPage->NbcInsertObject(pInvisibleSquare);
                    pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100));
                    pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100));

                    pView->MarkAll();
					GDIMetaFile aMeta(pView->GetMarkedObjMetaFile());

					aSymbolGraphic=Graphic(aMeta);
					aSymbolSize=pObj->GetSnapRect().GetSize();
                    aSymbolGraphic.SetPrefSize(pInvisibleSquare->GetSnapRect().GetSize());
					aSymbolGraphic.SetPrefMapMode(MAP_100TH_MM);
					bPrevSym=sal_True;
					bEnable=sal_True;
					bIgnoreGraphic=sal_True;

					pView->UnmarkAll();
                    pInvisibleSquare=pPage->RemoveObject(1);
                    SdrObject::Free( pInvisibleSquare);
					pObj=pPage->RemoveObject(0);
                    SdrObject::Free( pObj );
				}
			}
		}
		delete pView;
		delete pModel;
	}
	if(rAttrs.GetItemState(rAttrs.GetPool()->GetWhich(SID_ATTR_BRUSH),sal_True,&pPoolItem) == SFX_ITEM_SET)
	{
		const Graphic* pGraphic = ((const SvxBrushItem *)pPoolItem)->GetGraphic();
		if( pGraphic )
        {
            if(!bIgnoreGraphic)
		    {
			    aSymbolGraphic=*pGraphic;
		    }
		    if(!bIgnoreSize)
		    {
			    aSymbolSize=OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
													    pGraphic->GetPrefMapMode(),
													    MAP_100TH_MM );
		    }
		    bPrevSym=sal_True;
        }
	}

	if(rAttrs.GetItemState(rAttrs.GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE),sal_True,&pPoolItem) == SFX_ITEM_SET)
	{
		aSymbolSize = ((const SvxSizeItem *)pPoolItem)->GetSize();
	}

	aSymbolRatioCB.Enable(bEnable);
	aSymbolHeightFT.Enable(bEnable);
	aSymbolWidthFT.Enable(bEnable);
	aSymbolWidthMF.Enable(bEnable);
	aSymbolHeightMF.Enable(bEnable);
	if(bPrevSym)
	{
		SetMetricValue(aSymbolWidthMF,  aSymbolSize.Width(), ePoolUnit);
		SetMetricValue(aSymbolHeightMF, aSymbolSize.Height(),ePoolUnit);
		aCtlPreview.SetSymbol(&aSymbolGraphic,aSymbolSize);
		aSymbolLastSize=aSymbolSize;
	}

	if( rAttrs.GetItemState( XATTR_LINESTYLE ) != SFX_ITEM_DONTCARE )
	{
		eXLS = (XLineStyle) ( ( const XLineStyleItem& ) rAttrs.Get( XATTR_LINESTYLE ) ).GetValue();

		switch( eXLS )
		{
			case XLINE_NONE:
				aLbLineStyle.SelectEntryPos( 0 );
				break;
			case XLINE_SOLID:
				aLbLineStyle.SelectEntryPos( 1 );
				break;

			case XLINE_DASH:
				aLbLineStyle.SetNoSelection();
				aLbLineStyle.SelectEntry( ( ( const XLineDashItem& ) rAttrs.
								Get( XATTR_LINEDASH ) ).GetName() );
				break;

			default:
				break;
		}
	}
	else
	{
		aLbLineStyle.SetNoSelection();
	}

	// Linienstaerke
/*
	if( bObjSelected &&
		rAttrs.GetItemState( GetWhich( XATTR_LINEWIDTH ) ) == SFX_ITEM_DEFAULT )
	{
		aMtrLineWidth.Disable();
	}
*/
	if( rAttrs.GetItemState( XATTR_LINEWIDTH ) != SFX_ITEM_DONTCARE )
	{
		SetMetricValue( aMtrLineWidth, ( ( const XLineWidthItem& ) rAttrs.
							Get( XATTR_LINEWIDTH ) ).GetValue(), ePoolUnit );
	}
	else
		aMtrLineWidth.SetText( String() );

	// Linienfarbe
/*
	if( bObjSelected &&
		rAttrs.GetItemState( GetWhich( XATTR_LINECOLOR ) ) == SFX_ITEM_DEFAULT )
	{
		aLbColor.Disable();
	}
*/
	aLbColor.SetNoSelection();

	if ( rAttrs.GetItemState( XATTR_LINECOLOR ) != SFX_ITEM_DONTCARE )
	{
        Color aCol = ( ( const XLineColorItem& ) rAttrs.Get( XATTR_LINECOLOR ) ).GetColorValue();
		aLbColor.SelectEntry( aCol );
		if( aLbColor.GetSelectEntryCount() == 0 )
		{
			aLbColor.InsertEntry( aCol, String() );
			aLbColor.SelectEntry( aCol );
		}
	}

	// LinienAnfang
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINESTART ) == SFX_ITEM_DEFAULT )
	{
		aLbStartStyle.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINESTART ) != SFX_ITEM_DONTCARE )
	{
		// #86265# select entry using list and polygon, not string
		sal_Bool bSelected(sal_False);
		const basegfx::B2DPolyPolygon& rItemPolygon = ((const XLineStartItem&)rAttrs.Get(XATTR_LINESTART)).GetLineStartValue();

		for(sal_Int32 a(0);!bSelected &&  a < maLineEndList->Count(); a++)
		{
			XLineEndEntry* pEntry = maLineEndList->GetLineEnd(a);
			const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd();

			if(rItemPolygon == rEntryPolygon)
			{
				// select this entry
				aLbStartStyle.SelectEntryPos((sal_uInt16)a + 1);
				bSelected = sal_True;
			}
		}

		if(!bSelected)
			aLbStartStyle.SelectEntryPos( 0 );
	}
	else
	{
		aLbStartStyle.SetNoSelection();
	}

	// LinienEnde
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINEEND ) == SFX_ITEM_DEFAULT )
	{
		aLbEndStyle.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINEEND ) != SFX_ITEM_DONTCARE )
	{
		// #86265# select entry using list and polygon, not string
		sal_Bool bSelected(sal_False);
		const basegfx::B2DPolyPolygon& rItemPolygon = ((const XLineEndItem&)rAttrs.Get(XATTR_LINEEND)).GetLineEndValue();

		for(sal_Int32 a(0);!bSelected &&  a < maLineEndList->Count(); a++)
		{
			XLineEndEntry* pEntry = maLineEndList->GetLineEnd(a);
			const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd();

			if(rItemPolygon == rEntryPolygon)
			{
				// select this entry
				aLbEndStyle.SelectEntryPos((sal_uInt16)a + 1);
				bSelected = sal_True;
			}
		}

		if(!bSelected)
			aLbEndStyle.SelectEntryPos( 0 );
	}
	else
	{
		aLbEndStyle.SetNoSelection();
	}

	// LinienAnfang St"arke
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINESTARTWIDTH ) == SFX_ITEM_DEFAULT )
	{
		aMtrStartWidth.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINESTARTWIDTH ) != SFX_ITEM_DONTCARE )
	{
		SetMetricValue( aMtrStartWidth, ( ( const XLineStartWidthItem& ) rAttrs.
							Get( XATTR_LINESTARTWIDTH ) ).GetValue(), ePoolUnit );
	}
	else
		aMtrStartWidth.SetText( String() );

	// LinienEnde St"arke
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINEENDWIDTH ) == SFX_ITEM_DEFAULT )
	{
		aMtrEndWidth.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINEENDWIDTH ) != SFX_ITEM_DONTCARE )
	{
		SetMetricValue( aMtrEndWidth, ( ( const XLineEndWidthItem& ) rAttrs.
							Get( XATTR_LINEENDWIDTH ) ).GetValue(), ePoolUnit );
	}
	else
		aMtrEndWidth.SetText( String() );

	// Linienenden zentriert (Start)
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINESTARTCENTER ) == SFX_ITEM_DEFAULT )
	{
		aTsbCenterStart.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINESTARTCENTER ) != SFX_ITEM_DONTCARE )
	{
		aTsbCenterStart.EnableTriState( sal_False );

		if( ( ( const XLineStartCenterItem& ) rAttrs.Get( XATTR_LINESTARTCENTER ) ).GetValue() )
			aTsbCenterStart.SetState( STATE_CHECK );
		else
			aTsbCenterStart.SetState( STATE_NOCHECK );
	}
	else
	{
		aTsbCenterStart.SetState( STATE_DONTKNOW );
	}

	// Linienenden zentriert (Ende)
	if( bObjSelected &&
		rAttrs.GetItemState( XATTR_LINEENDCENTER ) == SFX_ITEM_DEFAULT )
	{
		aTsbCenterEnd.Disable();
	}
	else if( rAttrs.GetItemState( XATTR_LINEENDCENTER ) != SFX_ITEM_DONTCARE )
	{
		aTsbCenterEnd.EnableTriState( sal_False );

		if( ( ( const XLineEndCenterItem& ) rAttrs.Get( XATTR_LINEENDCENTER ) ).GetValue() )
			aTsbCenterEnd.SetState( STATE_CHECK );
		else
			aTsbCenterEnd.SetState( STATE_NOCHECK );
	}
	else
	{
		aTsbCenterEnd.SetState( STATE_DONTKNOW );
	}

	// Transparenz
	if( rAttrs.GetItemState( XATTR_LINETRANSPARENCE ) != SFX_ITEM_DONTCARE )
	{
		sal_uInt16 nTransp = ( ( const XLineTransparenceItem& ) rAttrs.
								Get( XATTR_LINETRANSPARENCE ) ).GetValue();
		aMtrTransparent.SetValue( nTransp );
		ChangeTransparentHdl_Impl( NULL );
	}
	else
		aMtrTransparent.SetText( String() );

	if( !aLbStartStyle.IsEnabled()	&&
		!aLbEndStyle.IsEnabled()	&&
		!aMtrStartWidth.IsEnabled() &&
		!aMtrEndWidth.IsEnabled()	&&
		!aTsbCenterStart.IsEnabled()&&
		!aTsbCenterEnd.IsEnabled() )
	{
		aCbxSynchronize.Disable();
		aFtLineEndsStyle.Disable();
		aFtLineEndsWidth.Disable();
		aFlLineEnds.Disable();
	}

	// Synchronisieren
	// Jetzt wird der Wert aus der INI-Datei geholt (#42258#)
	String aStr = GetUserData();
	aCbxSynchronize.Check( (sal_Bool)aStr.ToInt32() );

	// #116827#
	if(bObjSelected && SFX_ITEM_DEFAULT == rAttrs.GetItemState(XATTR_LINEJOINT))
	{
		maFTEdgeStyle.Disable();
		maLBEdgeStyle.Disable();
	}
	else if(SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_LINEJOINT))
	{
		const com::sun::star::drawing::LineJoint eLineJoint = ((const XLineJointItem&)(rAttrs.Get(XATTR_LINEJOINT))).GetValue();

		switch(eLineJoint)
		{
            case com::sun::star::drawing::LineJoint_MIDDLE : // fallback to round, unused value
			case com::sun::star::drawing::LineJoint_ROUND : maLBEdgeStyle.SelectEntryPos(0); break;
			case com::sun::star::drawing::LineJoint_NONE : maLBEdgeStyle.SelectEntryPos(1); break;
			case com::sun::star::drawing::LineJoint_MITER : maLBEdgeStyle.SelectEntryPos(2); break;
			case com::sun::star::drawing::LineJoint_BEVEL : maLBEdgeStyle.SelectEntryPos(3); break;
			default: break;
		}
	}
	else
	{
		maLBEdgeStyle.SetNoSelection();
	}

	/*
	if( aLbStartStyle.GetSelectEntryPos() == aLbEndStyle.GetSelectEntryPos() &&
		aMtrStartWidth.GetValue() == aMtrEndWidth.GetValue() &&
		aTsbCenterStart.GetState() == aTsbCenterEnd.GetState() )
	{
		aCbxSynchronize.Check();
	}
	*/

    // fdo#43209
    if(bObjSelected && SFX_ITEM_DEFAULT == rAttrs.GetItemState(XATTR_LINECAP))
    {
        maFTCapStyle.Disable();
        maLBCapStyle.Disable();
    }
    else if(SFX_ITEM_DONTCARE != rAttrs.GetItemState(XATTR_LINECAP))
    {
        const com::sun::star::drawing::LineCap eLineCap(((const XLineCapItem&)(rAttrs.Get(XATTR_LINECAP))).GetValue());

        switch(eLineCap)
        {
            case com::sun::star::drawing::LineCap_ROUND: maLBCapStyle.SelectEntryPos(1); break;
            case com::sun::star::drawing::LineCap_SQUARE : maLBCapStyle.SelectEntryPos(2); break;
            default /*com::sun::star::drawing::LineCap_BUTT*/: maLBCapStyle.SelectEntryPos(0); break;
        }
    }
    else
    {
        maLBCapStyle.SetNoSelection();
    }

	// Werte sichern
	aLbLineStyle.SaveValue();
	aMtrLineWidth.SaveValue();
	aLbColor.SaveValue();
	aLbStartStyle.SaveValue();
	aLbEndStyle.SaveValue();
	aMtrStartWidth.SaveValue();
	aMtrEndWidth.SaveValue();
	aTsbCenterStart.SaveValue();
	aTsbCenterEnd.SaveValue();
	aMtrTransparent.SaveValue();

	// #116827#
	maLBEdgeStyle.SaveValue();

    // LineCaps
    maLBCapStyle.SaveValue();

	ClickInvisibleHdl_Impl( this );
	//ClickMeasuringHdl_Impl( this );
	//aCtlPosition.Reset();

	ChangePreviewHdl_Impl( NULL );
}

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

SfxTabPage* SvxLineTabPage::Create( Window* pWindow,
				const SfxItemSet& rAttrs )
{
	return( new SvxLineTabPage( pWindow, rAttrs ) );
}

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

sal_uInt16*	SvxLineTabPage::GetRanges()
{
	return( pLineRanges );
}

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

IMPL_LINK( SvxLineTabPage, ChangePreviewHdl_Impl, void *, pCntrl )
{
	if(pCntrl == &aMtrLineWidth)
	{
		// Linienbreite und Start/EndBreite
		sal_Int32 nNewLineWidth = GetCoreValue( aMtrLineWidth, ePoolUnit );
		if(nActLineWidth == -1)
		{
			// Noch nicht initialisiert, hole den Startwert
			const SfxPoolItem* pOld = GetOldItem( rXLSet, XATTR_LINEWIDTH );
			sal_Int32 nStartLineWidth = 0;
			if(pOld)
				nStartLineWidth = (( const XLineWidthItem *)pOld)->GetValue();
			nActLineWidth = nStartLineWidth;
		}

		if(nActLineWidth != nNewLineWidth)
		{
			// Anpassungen Start/EndWidth #63083#
			sal_Int32 nValAct = GetCoreValue( aMtrStartWidth, ePoolUnit );
			sal_Int32 nValNew = nValAct + (((nNewLineWidth - nActLineWidth) * 15) / 10);
			if(nValNew < 0)
				nValNew = 0;
			SetMetricValue( aMtrStartWidth, nValNew, ePoolUnit );

			nValAct = GetCoreValue( aMtrEndWidth, ePoolUnit );
			nValNew = nValAct + (((nNewLineWidth - nActLineWidth) * 15) / 10);
			if(nValNew < 0)
				nValNew = 0;
			SetMetricValue( aMtrEndWidth, nValNew, ePoolUnit );
		}

		// Aktuellen Wert merken
		nActLineWidth = nNewLineWidth;
	}

	FillXLSet_Impl();
	aCtlPreview.Invalidate();

	// Transparenz entspr. zugaenglich machen
	if( aLbLineStyle.GetSelectEntryPos() == 0 ) // unsichtbar
	{
		aFtTransparent.Disable();
		aMtrTransparent.Disable();
	}
	else
	{
		aFtTransparent.Enable();
		aMtrTransparent.Enable();
	}

	const bool bHasLineStart = aLbStartStyle.GetSelectEntryPos() != 0;
	const bool bHasLineEnd = aLbEndStyle.GetSelectEntryPos() != 0;

    aFtLineEndsWidth.Enable( bHasLineStart || bHasLineEnd );
    aMtrStartWidth.Enable( bHasLineStart );
    aTsbCenterStart.Enable( bHasLineStart );
    aMtrEndWidth.Enable( bHasLineEnd );
    aTsbCenterEnd.Enable( bHasLineEnd );

	return( 0L );
}

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

IMPL_LINK( SvxLineTabPage, ChangeStartHdl_Impl, void *, p )
{
	if( aCbxSynchronize.IsChecked() )
	{
		if( p == &aMtrStartWidth )
			aMtrEndWidth.SetValue( aMtrStartWidth.GetValue() );
		if( p == &aLbStartStyle )
			aLbEndStyle.SelectEntryPos( aLbStartStyle.GetSelectEntryPos() );
		if( p == &aTsbCenterStart )
			aTsbCenterEnd.SetState( aTsbCenterStart.GetState() );
	}

	ChangePreviewHdl_Impl( this );

	return( 0L );
}

//------------------------------------------------------------------------
// #116827#

IMPL_LINK( SvxLineTabPage, ChangeEdgeStyleHdl_Impl, void *, EMPTYARG )
{
	ChangePreviewHdl_Impl( this );

	return( 0L );
}

//------------------------------------------------------------------------
// fdo#43209

IMPL_LINK( SvxLineTabPage, ChangeCapStyleHdl_Impl, void *, EMPTYARG )
{
    ChangePreviewHdl_Impl( this );

    return( 0L );
}
//------------------------------------------------------------------------

IMPL_LINK( SvxLineTabPage, ClickInvisibleHdl_Impl, void *, EMPTYARG )
{
	if( aLbLineStyle.GetSelectEntryPos() == 0 ) // unsichtbar
	{
		aFtColor.Disable();
        if(!bSymbols)
		    aLbColor.Disable();
		aFtLineWidth.Disable();
		aMtrLineWidth.Disable();

		if( aFlLineEnds.IsEnabled() )
		{
			aFtLineEndsStyle.Disable();
			aFtLineEndsWidth.Disable();
			aLbStartStyle.Disable();
			aMtrStartWidth.Disable();
			aTsbCenterStart.Disable();
			aLbEndStyle.Disable();
			aMtrEndWidth.Disable();
			aTsbCenterEnd.Disable();
			aCbxSynchronize.Disable();

			// #116827#
			maFTEdgeStyle.Disable();
			maLBEdgeStyle.Disable();

            // LineCaps
            maFTCapStyle.Disable();
            maLBCapStyle.Disable();
		}
	}
	else
	{
		aFtColor.Enable();
		aLbColor.Enable();
		aFtLineWidth.Enable();
		aMtrLineWidth.Enable();

		if( aFlLineEnds.IsEnabled() )
		{
			aFtLineEndsStyle.Enable();
			aFtLineEndsWidth.Enable();
			aLbStartStyle.Enable();
			aMtrStartWidth.Enable();
			aTsbCenterStart.Enable();
			aLbEndStyle.Enable();
			aMtrEndWidth.Enable();
			aTsbCenterEnd.Enable();
			aCbxSynchronize.Enable();

			// #116827#
			maFTEdgeStyle.Enable();
			maLBEdgeStyle.Enable();

            // LineCaps
            maFTCapStyle.Enable();
            maLBCapStyle.Enable();
		}
	}
	ChangePreviewHdl_Impl( NULL );

	return( 0L );
}

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

IMPL_LINK( SvxLineTabPage, ChangeEndHdl_Impl, void *, p )
{
	if( aCbxSynchronize.IsChecked() )
	{
		if( p == &aMtrEndWidth )
			aMtrStartWidth.SetValue( aMtrEndWidth.GetValue() );
		if( p == &aLbEndStyle )
			aLbStartStyle.SelectEntryPos( aLbEndStyle.GetSelectEntryPos() );
		if( p == &aTsbCenterEnd )
			aTsbCenterStart.SetState( aTsbCenterEnd.GetState() );
	}

	ChangePreviewHdl_Impl( this );

	return( 0L );
}

//------------------------------------------------------------------------
/*

long SvxLineTabPage::ClickMeasuringHdl_Impl( void* )
{
	if( aTsbShowMeasuring.GetState() == STATE_NOCHECK )
	{
		aFtPosition.Disable();
		aCtlPosition.Disable();
	}
	else
	{
		aFtPosition.Enable();
		aCtlPosition.Enable();
	}
	aCtlPosition.Invalidate();

	return( 0L );
}
*/
//------------------------------------------------------------------------

IMPL_LINK( SvxLineTabPage, ChangeTransparentHdl_Impl, void *, EMPTYARG )
{
	sal_uInt16 nVal = (sal_uInt16)aMtrTransparent.GetValue();
	XLineTransparenceItem aItem( nVal );

	rXLSet.Put( XLineTransparenceItem( aItem ) );

	// #116827#
	FillXLSet_Impl();

	aCtlPreview.Invalidate();

	return( 0L );
}

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

void SvxLineTabPage::PointChanged( Window*, RECT_POINT eRcPt )
{
	eRP = eRcPt;
}

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

void SvxLineTabPage::FillUserData()
{
	// Abgleich wird in der Ini-Datei festgehalten
	UniString aStrUserData = UniString::CreateFromInt32( (sal_Int32) aCbxSynchronize.IsChecked() );
	SetUserData( aStrUserData );
}


//#58425# Symbole auf einer Linie (z.B. StarChart)
//Handler f�r Popup-Menue der Symbolauswahl (NumMenueButton)
//der folgende Link stammt urspruenglich aus SvxNumOptionsTabPage
IMPL_LINK( SvxLineTabPage, MenuCreateHdl_Impl, MenuButton *, pButton )
{
	//Popup initialisieren
	if(!pButton->GetPopupMenu()->GetPopupMenu( MN_GALLERY ))
	{
		// Gallery-Eintraege besorgen
		GalleryExplorer::FillObjList(GALLERY_THEME_BULLETS, aGrfNames);

		PopupMenu* pPopup = new PopupMenu;
		String aEmptyStr;

		nNumMenuGalleryItems=aGrfNames.Count();
		for(long i = 0; i < nNumMenuGalleryItems; i++)
		{
            const String* pGrfName = (const String*)aGrfNames.GetObject(i);
            const String* pUIName = pGrfName;

            // convert URL encodings to UI characters (eg %20 for spaces)
            String aPhysicalName;
            if( ::utl::LocalFileHelper::ConvertURLToPhysicalName( *pGrfName, aPhysicalName ))
                pUIName = &aPhysicalName;

            SvxBrushItem* pBrushItem = new SvxBrushItem(*pGrfName, aEmptyStr, GPOS_AREA, SID_ATTR_BRUSH);
			pBrushItem->SetDoneLink(STATIC_LINK(this, SvxLineTabPage, GraphicArrivedHdl_Impl));

			SvxBmpItemInfo* pInfo = new SvxBmpItemInfo();
			pInfo->pBrushItem = pBrushItem;
			pInfo->nItemId = (sal_uInt16)(MN_GALLERY_ENTRY + i);
			aGrfBrushItems.Insert(pInfo, i);
			const Graphic* pGraphic = pBrushItem->GetGraphic();

			if(pGraphic)
			{
				Bitmap aBitmap(pGraphic->GetBitmap());
				Size aSize(aBitmap.GetSizePixel());
				if(aSize.Width()  > MAX_BMP_WIDTH ||
				   aSize.Height() > MAX_BMP_HEIGHT)
				{
					sal_Bool bWidth = aSize.Width() > aSize.Height();
					double nScale = bWidth ?
										(double)MAX_BMP_WIDTH / (double)aSize.Width():
										(double)MAX_BMP_HEIGHT / (double)aSize.Height();
					aBitmap.Scale(nScale, nScale);

				}
				Image aImage(aBitmap);
				pPopup->InsertItem(pInfo->nItemId, *pUIName, aImage );
			}
			else
			{
				Image aImage;
				pPopup->InsertItem(pInfo->nItemId, *pUIName, aImage );
			}
		}
		aSymbolMB.GetPopupMenu()->SetPopupMenu( MN_GALLERY, pPopup );
		if(!aGrfNames.Count())
			aSymbolMB.GetPopupMenu()->EnableItem(MN_GALLERY, sal_False);
	}

	if(!pButton->GetPopupMenu()->GetPopupMenu( MN_SYMBOLS ) && pSymbolList)
	{
		VirtualDevice aVDev;
		aVDev.SetMapMode(MapMode(MAP_100TH_MM));
		SdrModel* pModel = new SdrModel(NULL, NULL, LOADREFCOUNTS);
		pModel->GetItemPool().FreezeIdRanges();
		// Page
		SdrPage* pPage = new SdrPage( *pModel, sal_False );
		pPage->SetSize(Size(1000,1000));
		pModel->InsertPage( pPage, 0 );
		// 3D View
		SdrView* pView = new SdrView( pModel, &aVDev );
		pView->hideMarkHandles();
		/*SdrPageView* pPageView = */pView->ShowSdrPage(pPage);

		PopupMenu* pPopup = new PopupMenu;
		String aEmptyStr;

        // Generate invisible square to give all symbols a
        // bitmap size, which is indepedent from specific glyph
        SdrObject *pInvisibleSquare=pSymbolList->GetObj(0);
        pInvisibleSquare=pInvisibleSquare->Clone();
        pPage->NbcInsertObject(pInvisibleSquare);
        pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100));
        pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100));

		for(long i=0;; ++i)
		{
            SdrObject *pObj=pSymbolList->GetObj(i);
            if(pObj==NULL)
                break;
			pObj=pObj->Clone();
			//const String* pGrfName = (const String*)aGrfNames.GetObject(i);
			String *pStr=new String();//String(i));
			aGrfNames.Insert(pStr,LIST_APPEND);
			//Rectangle aRect(pObj->GetLogicRect());
			pPage->NbcInsertObject(pObj);
			if(pSymbolAttr)
			{
				pObj->SetMergedItemSet(*pSymbolAttr);
			}
			else
			{
				pObj->SetMergedItemSet(rOutAttrs);
			}
            pView->MarkAll();
			BitmapEx aBitmapEx(pView->GetMarkedObjBitmapEx());
			GDIMetaFile aMeta(pView->GetMarkedObjMetaFile());
			pView->UnmarkAll();
			pObj=pPage->RemoveObject(1);
            SdrObject::Free(pObj);

            SvxBrushItem* pBrushItem = new SvxBrushItem(Graphic(aMeta), GPOS_AREA, SID_ATTR_BRUSH);
			pBrushItem->SetDoneLink(STATIC_LINK(this, SvxLineTabPage, GraphicArrivedHdl_Impl));

			SvxBmpItemInfo* pInfo = new SvxBmpItemInfo();
			pInfo->pBrushItem = pBrushItem;
			pInfo->nItemId = (sal_uInt16)(MN_GALLERY_ENTRY + i + nNumMenuGalleryItems);
			aGrfBrushItems.Insert(pInfo, nNumMenuGalleryItems + i);

			Size aSize(aBitmapEx.GetSizePixel());
			if(aSize.Width() > MAX_BMP_WIDTH || aSize.Height() > MAX_BMP_HEIGHT)
			{
				sal_Bool bWidth = aSize.Width() > aSize.Height();
				double nScale = bWidth ?
									(double)MAX_BMP_WIDTH / (double)aSize.Width():
									(double)MAX_BMP_HEIGHT / (double)aSize.Height();
				aBitmapEx.Scale(nScale, nScale);
			}
			Image aImage(aBitmapEx);
			pPopup->InsertItem(pInfo->nItemId,*pStr,aImage);
		}
        pInvisibleSquare=pPage->RemoveObject(0);
        SdrObject::Free(pInvisibleSquare);

		aSymbolMB.GetPopupMenu()->SetPopupMenu( MN_SYMBOLS, pPopup );
		if(!aGrfNames.Count())
			aSymbolMB.GetPopupMenu()->EnableItem(MN_SYMBOLS, sal_False);

		delete pView;
		delete pModel;
	}
	return 0;
}
//#58425# Symbole auf einer Linie (z.B. StarChart)
//Handler f�r Popup-Menue der Symbolauswahl (NumMenueButton)
//der folgende Link stammt urspruenglich aus SvxNumOptionsTabPage:
IMPL_STATIC_LINK(SvxLineTabPage, GraphicArrivedHdl_Impl, SvxBrushItem*, pItem)
{
	PopupMenu* pPopup = pThis->aSymbolMB.GetPopupMenu()->GetPopupMenu( MN_GALLERY );

	SvxBmpItemInfo* pBmpInfo = 0;
	for ( sal_uInt16 i = 0; i < pThis->aGrfBrushItems.Count(); i++ )
	{
		SvxBmpItemInfo* pInfo = (SvxBmpItemInfo*)pThis->aGrfBrushItems.GetObject(i);
		if( pInfo->pBrushItem == pItem )
		{
			pBmpInfo = pInfo; break;
		}
	}
	if( pBmpInfo )
	{
        if( pItem->GetGraphic() )
        {
            Bitmap aBitmap(pItem->GetGraphic()->GetBitmap());
            Size aSize(aBitmap.GetSizePixel());
            if(aSize.Width()  > MAX_BMP_WIDTH ||
               aSize.Height() > MAX_BMP_HEIGHT)
            {
                sal_Bool bWidth = aSize.Width() > aSize.Height();
                double nScale = bWidth ?
                    (double)MAX_BMP_WIDTH / (double)aSize.Width():
                    (double)MAX_BMP_HEIGHT / (double)aSize.Height();
                aBitmap.Scale(nScale, nScale);
            }
            Image aImage(aBitmap);
            pPopup->SetItemImage( pBmpInfo->nItemId, aImage );
        }
	}

	return 0;
}

//#58425# Symbole auf einer Linie (z.B. StarChart)
//Handler f�r Menuebutton
IMPL_LINK( SvxLineTabPage, GraphicHdl_Impl, MenuButton *, pButton )
{
	sal_uInt16 nItemId = pButton->GetCurItemId();
	const Graphic* pGraphic = 0;
	Graphic aGraphic;
	String aGrfName;
	sal_Bool bResetSize = sal_False;
	sal_Bool bEnable=sal_True;
    long nPreviousSymbolType = nSymbolType;

	if(nItemId >= MN_GALLERY_ENTRY)
	{
		if( (nItemId-MN_GALLERY_ENTRY) >= nNumMenuGalleryItems)
		{
			nSymbolType=nItemId-MN_GALLERY_ENTRY-nNumMenuGalleryItems; //Index der Liste
		}
		else
		{
			nSymbolType=SVX_SYMBOLTYPE_BRUSHITEM;
            bResetSize = sal_True;
		}
		SvxBmpItemInfo* pInfo = (SvxBmpItemInfo*)aGrfBrushItems.GetObject(nItemId - MN_GALLERY_ENTRY);
		pGraphic = pInfo->pBrushItem->GetGraphic();
	}
	else switch(nItemId)
	{
		case MN_SYMBOLS_AUTO:
		{
			pGraphic=&aAutoSymbolGraphic;
			aAutoSymbolGraphic.SetPrefSize( Size(253,253) );
			nSymbolType=SVX_SYMBOLTYPE_AUTO;
		}
		break;

		case MN_SYMBOLS_NONE:
		{
			nSymbolType=SVX_SYMBOLTYPE_NONE;
			pGraphic=NULL;
			bEnable=sal_False;
		}
		break;
		default:
		{
			SvxOpenGraphicDialog aGrfDlg(CUI_RES(RID_STR_EDIT_GRAPHIC));
			aGrfDlg.EnableLink(sal_False);
			aGrfDlg.AsLink(sal_False);
			if( !aGrfDlg.Execute() )
			{
				// ausgewaehlten Filter merken
				aGrfName = aGrfDlg.GetPath();
				if( !aGrfDlg.GetGraphic(aGraphic) )
                {
                    nSymbolType=SVX_SYMBOLTYPE_BRUSHITEM;
					pGraphic = &aGraphic;
                    bResetSize = sal_True;
                }
			}
            if( !pGraphic )
                return 0;
		}
		break;
	}

	if(pGraphic)
	{
		Size aSize = SvxNumberFormat::GetGraphicSizeMM100(pGraphic);
		aSize = OutputDevice::LogicToLogic(aSize, MAP_100TH_MM, (MapUnit)ePoolUnit);
		aSymbolGraphic=*pGraphic;
		if( bResetSize )
		{
			aSymbolSize=aSize;
		}
        else if( nPreviousSymbolType == SVX_SYMBOLTYPE_BRUSHITEM )
        {   //#i31097# Data Point Symbol size changes when a different symbol is choosen(maoyg)
            if( aSymbolSize.Width() != aSymbolSize.Height() )
            {
                aSize.setWidth( (long)( aSymbolSize.Width() + aSymbolSize.Height() )/2 );
                aSize.setHeight( (long)( aSymbolSize.Width() + aSymbolSize.Height() )/2 );
                aSymbolSize = aSize;
            }
        }
		aCtlPreview.SetSymbol(&aSymbolGraphic,aSymbolSize);
	}
	else
	{
		aSymbolGraphic=Graphic();
		aCtlPreview.SetSymbol(NULL,aSymbolSize);
		bEnable=sal_False;
	}
	aSymbolLastSize=aSymbolSize;
	SetMetricValue(aSymbolWidthMF,  aSymbolSize.Width(), ePoolUnit);
	SetMetricValue(aSymbolHeightMF, aSymbolSize.Height(), ePoolUnit);
	aSymbolRatioCB.Enable(bEnable);
	aSymbolHeightFT.Enable(bEnable);
	aSymbolWidthFT.Enable(bEnable);
	aSymbolWidthMF.Enable(bEnable);
	aSymbolHeightMF.Enable(bEnable);
	aCtlPreview.Invalidate();

	return 0;
}
IMPL_LINK( SvxLineTabPage, SizeHdl_Impl, MetricField *, pField)
{
	bNewSize=true;
	sal_Bool bWidth = (sal_Bool)(pField == &aSymbolWidthMF);
	bLastWidthModified = bWidth;
	sal_Bool bRatio = aSymbolRatioCB.IsChecked();
	long nWidthVal = static_cast<long>(aSymbolWidthMF.Denormalize(aSymbolWidthMF.GetValue(FUNIT_100TH_MM)));
	long nHeightVal= static_cast<long>(aSymbolHeightMF.Denormalize(aSymbolHeightMF.GetValue(FUNIT_100TH_MM)));
	nWidthVal = OutputDevice::LogicToLogic(nWidthVal,MAP_100TH_MM,(MapUnit)ePoolUnit );
	nHeightVal = OutputDevice::LogicToLogic(nHeightVal,MAP_100TH_MM,(MapUnit)ePoolUnit);
	aSymbolSize=Size(nWidthVal,nHeightVal);
	double	fSizeRatio = (double)1;

	if(bRatio)
	{
		if (aSymbolLastSize.Height() && aSymbolLastSize.Width())
			fSizeRatio = (double)aSymbolLastSize.Width() / aSymbolLastSize.Height();
	}

	//Size aSymbolSize(aSymbolLastSize);

	if(bWidth)
	{
		long nDelta = nWidthVal - aSymbolLastSize.Width();
		aSymbolSize.Width() = nWidthVal;
		if (bRatio)
		{
			aSymbolSize.Height() = aSymbolLastSize.Height() + (long)((double)nDelta / fSizeRatio);
			aSymbolSize.Height() = OutputDevice::LogicToLogic( aSymbolSize.Height(),(MapUnit)ePoolUnit, MAP_100TH_MM );
			aSymbolHeightMF.SetUserValue(aSymbolHeightMF.Normalize(aSymbolSize.Height()), FUNIT_100TH_MM);
		}
	}
	else
	{
		long nDelta = nHeightVal - aSymbolLastSize.Height();
		aSymbolSize.Height() = nHeightVal;
		if (bRatio)
		{
			aSymbolSize.Width() = aSymbolLastSize.Width() + (long)((double)nDelta * fSizeRatio);
			aSymbolSize.Width() = OutputDevice::LogicToLogic( aSymbolSize.Width(),
								(MapUnit)ePoolUnit, MAP_100TH_MM );
			aSymbolWidthMF.SetUserValue(aSymbolWidthMF.Normalize(aSymbolSize.Width()), FUNIT_100TH_MM);
		}
	}
	aCtlPreview.ResizeSymbol(aSymbolSize);
	aSymbolLastSize=aSymbolSize;
	return 0;
}
IMPL_LINK( SvxLineTabPage, RatioHdl_Impl, CheckBox *, pBox )
{
	if (pBox->IsChecked())
	{
		if (bLastWidthModified)
			SizeHdl_Impl(&aSymbolWidthMF);
		else
			SizeHdl_Impl(&aSymbolHeightMF);
	}
	return 0;
}


void SvxLineTabPage::DataChanged( const DataChangedEvent& rDCEvt )
{
	SvxTabPage::DataChanged( rDCEvt );

	if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
	{
		FillListboxes();
	}
}

void SvxLineTabPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
{
	SFX_ITEMSET_ARG (&aSet,pColorTabItem,SvxColorTableItem,SID_COLOR_TABLE,sal_False);
	SFX_ITEMSET_ARG (&aSet,pDashListItem,SvxDashListItem,SID_DASH_LIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pLineEndListItem,SvxLineEndListItem,SID_LINEEND_LIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pPageTypeItem,SfxUInt16Item,SID_PAGE_TYPE,sal_False);
	SFX_ITEMSET_ARG (&aSet,pDlgTypeItem,SfxUInt16Item,SID_DLG_TYPE,sal_False);
	SFX_ITEMSET_ARG (&aSet,pSdrObjListItem,OfaPtrItem,SID_OBJECT_LIST,sal_False);
	SFX_ITEMSET_ARG (&aSet,pSymbolAttrItem,SfxTabDialogItem,SID_ATTR_SET,sal_False);
	SFX_ITEMSET_ARG (&aSet,pGraphicItem,SvxGraphicItem,SID_GRAPHIC,sal_False);

	if (pColorTabItem)
		SetColorTable(pColorTabItem->GetColorTable());
	if (pDashListItem)
		SetDashList(pDashListItem->GetDashList());
	if (pLineEndListItem)
		SetLineEndList(pLineEndListItem->GetLineEndList());
	if (pPageTypeItem)
		SetPageType(pPageTypeItem->GetValue());
	if (pDlgTypeItem)
		SetDlgType(pDlgTypeItem->GetValue());
	Construct();

	if(pSdrObjListItem) //symbols
	{
		ShowSymbolControls(sal_True);
		pSymbolList = static_cast<SdrObjList*>(pSdrObjListItem->GetValue());
		if (pSymbolAttrItem)
			pSymbolAttr = new SfxItemSet(pSymbolAttrItem->GetItemSet());
		if(pGraphicItem)
			aAutoSymbolGraphic = pGraphicItem->GetGraphic();
	}
}