xref: /AOO41X/main/svtools/source/control/valueset.cxx (revision 3ea0c3d5cfef7203d1d18b0d5fde9ed31f4a4181)

/**************************************************************
 *
 * 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_svtools.hxx"
#include <tools/list.hxx>
#include <tools/debug.hxx>
#include <vcl/decoview.hxx>
#include <vcl/svapp.hxx>
#ifndef _SCRBAR_HXX
#include <vcl/scrbar.hxx>
#endif
#ifndef _HELP_HXX
#include <vcl/help.hxx>
#endif
#include <com/sun/star/accessibility/AccessibleEventObject.hpp>
#include <com/sun/star/accessibility/AccessibleEventId.hpp>
#include <com/sun/star/accessibility/AccessibleStateType.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <rtl/ustring.hxx>
#include "valueimp.hxx"

#define _SV_VALUESET_CXX
#include <svtools/valueset.hxx>

// ------------
// - ValueSet -
// ------------

void ValueSet::ImplInit()
{
	// Size aWinSize		= GetSizePixel();
    mpImpl              = new ValueSet_Impl;
	mpNoneItem			= NULL;
	mpScrBar			= NULL;
	mnTextOffset		= 0;
	mnVisLines			= 0;
	mnLines 			= 0;
	mnUserItemWidth 	= 0;
	mnUserItemHeight	= 0;
	mnFirstLine 		= 0;
	mnOldItemId 		= 0;
	mnSelItemId 		= 0;
	mnHighItemId		= 0;
	mnDropPos			= VALUESET_ITEM_NOTFOUND;
	mnCols				= 0;
	mnCurCol			= 0;
	mnUserCols			= 0;
	mnUserVisLines		= 0;
	mnSpacing			= 0;
	mnFrameStyle		= 0;
	mbFormat			= true;
	mbHighlight 		= false;
	mbSelection 		= false;
	mbNoSelection		= true;
	mbDrawSelection 	= true;
	mbBlackSel			= false;
	mbDoubleSel 		= false;
	mbScroll			= false;
	mbDropPos			= false;
	mbFullMode			= true;
    mbEdgeBlending      = false;

    // #106446#, #106601# force mirroring of virtual device
    maVirDev.EnableRTL( GetParent()->IsRTLEnabled() );

	ImplInitSettings( sal_True, sal_True, sal_True );
}

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

ValueSet::ValueSet( Window* pParent, WinBits nWinStyle, bool bDisableTransientChildren ) :
	Control( pParent, nWinStyle ),
	maVirDev( *this ),
	maColor( COL_TRANSPARENT )
{
	ImplInit();
    if( mpImpl )
        mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren;
}

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

ValueSet::ValueSet( Window* pParent, const ResId& rResId, bool bDisableTransientChildren ) :
	Control( pParent, rResId ),
	maVirDev( *this ),
	maColor( COL_TRANSPARENT )
{
	ImplInit();
    if( mpImpl )
        mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren;
}

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

ValueSet::~ValueSet()
{
    ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent>
          xComponent (GetAccessible(sal_False), ::com::sun::star::uno::UNO_QUERY);
    if (xComponent.is())
        xComponent->dispose ();

	if ( mpScrBar )
		delete mpScrBar;

	if ( mpNoneItem )
		delete mpNoneItem;

	ImplDeleteItems();
    delete mpImpl;
}

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

void ValueSet::ImplDeleteItems()
{
    for( ValueSetItem* pItem = mpImpl->mpItemList->First(); pItem; pItem = mpImpl->mpItemList->Next() )
	{
        if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() )
        {
            ::com::sun::star::uno::Any aOldAny, aNewAny;

            aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
            ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
        }

		delete pItem;
	}

    mpImpl->mpItemList->Clear();
}

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

void ValueSet::ImplInitSettings( sal_Bool bFont, sal_Bool bForeground, sal_Bool bBackground )
{
	const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

	if ( bFont )
	{
		Font aFont;
		aFont = rStyleSettings.GetAppFont();
		if ( IsControlFont() )
			aFont.Merge( GetControlFont() );
		SetZoomedPointFont( aFont );
	}

	if ( bForeground || bFont )
	{
		Color aColor;
		if ( IsControlForeground() )
			aColor = GetControlForeground();
		else
			aColor = rStyleSettings.GetButtonTextColor();
		SetTextColor( aColor );
		SetTextFillColor();
	}

	if ( bBackground )
	{
		Color aColor;
		if ( IsControlBackground() )
			aColor = GetControlBackground();
        else if ( GetStyle() & WB_MENUSTYLEVALUESET )
            aColor = rStyleSettings.GetMenuColor();
        else if ( IsEnabled() && (GetStyle() & WB_FLATVALUESET) )
            aColor = rStyleSettings.GetWindowColor();
		else
			aColor = rStyleSettings.GetFaceColor();
		SetBackground( aColor );
	}
}

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

void ValueSet::ImplInitScrollBar()
{
	if ( GetStyle() & WB_VSCROLL )
	{
		if ( !mpScrBar )
		{
			mpScrBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
			mpScrBar->SetScrollHdl( LINK( this, ValueSet, ImplScrollHdl ) );
		}
		else
		{
			// Wegen Einstellungsaenderungen passen wir hier die Breite an
			long nScrBarWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
			mpScrBar->SetPosSizePixel( 0, 0, nScrBarWidth, 0, WINDOW_POSSIZE_WIDTH );
		}
	}
}

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

void ValueSet::ImplFormatItem( ValueSetItem* pItem )
{
	if ( pItem->meType == VALUESETITEM_SPACE )
		return;

	Rectangle aRect = pItem->maRect;
	WinBits nStyle = GetStyle();
	if ( nStyle & WB_ITEMBORDER )
	{
		aRect.Left()++;
		aRect.Top()++;
		aRect.Right()--;
		aRect.Bottom()--;
		if ( nStyle & WB_FLATVALUESET )
		{
			if ( nStyle  & WB_DOUBLEBORDER )
			{
				aRect.Left()	+= 2;
				aRect.Top() 	+= 2;
				aRect.Right()	-= 2;
				aRect.Bottom()	-= 2;
			}
			else
			{
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
			}
		}
		else
		{
			DecorationView aView( &maVirDev );
			aRect = aView.DrawFrame( aRect, mnFrameStyle );
		}
	}

	if ( pItem == mpNoneItem )
		pItem->maText = GetText();

	if ( (aRect.GetHeight() > 0) && (aRect.GetWidth() > 0) )
	{
        const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

		if ( pItem == mpNoneItem )
		{
			maVirDev.SetFont( GetFont() );
			maVirDev.SetTextColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor() );
			maVirDev.SetTextFillColor();
			maVirDev.SetFillColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuColor() : rStyleSettings.GetWindowColor() );
			maVirDev.DrawRect( aRect );
			Point	aTxtPos( aRect.Left()+2, aRect.Top() );
			long	nTxtWidth = GetTextWidth( pItem->maText );
			if ( nStyle & WB_RADIOSEL )
			{
				aTxtPos.X() += 4;
				aTxtPos.Y() += 4;
			}
			if ( (aTxtPos.X()+nTxtWidth) > aRect.Right() )
			{
				maVirDev.SetClipRegion( Region( aRect ) );
				maVirDev.DrawText( aTxtPos, pItem->maText );
				maVirDev.SetClipRegion();
			}
			else
				maVirDev.DrawText( aTxtPos, pItem->maText );
		}
		else if ( pItem->meType == VALUESETITEM_COLOR )
		{
			maVirDev.SetFillColor( pItem->maColor );
			maVirDev.DrawRect( aRect );
		}
		else
		{
			if ( IsColor() )
				maVirDev.SetFillColor( maColor );
            else if ( nStyle & WB_MENUSTYLEVALUESET )
                maVirDev.SetFillColor( rStyleSettings.GetMenuColor() );
            else if ( IsEnabled() )
                maVirDev.SetFillColor( rStyleSettings.GetWindowColor() );
            else
                maVirDev.SetFillColor( rStyleSettings.GetFaceColor() );
			maVirDev.DrawRect( aRect );

			if ( pItem->meType == VALUESETITEM_USERDRAW )
			{
				UserDrawEvent aUDEvt( &maVirDev, aRect, pItem->mnId );
				UserDraw( aUDEvt );
			}
			else
			{
				Size	aImageSize = pItem->maImage.GetSizePixel();
				Size	aRectSize = aRect.GetSize();
				Point	aPos( aRect.Left(), aRect.Top() );
				aPos.X() += (aRectSize.Width()-aImageSize.Width())/2;
				aPos.Y() += (aRectSize.Height()-aImageSize.Height())/2;

			    sal_uInt16  nImageStyle  = 0;
                if( !IsEnabled() )
					nImageStyle  |= IMAGE_DRAW_DISABLE;

				if ( (aImageSize.Width()  > aRectSize.Width()) ||
					 (aImageSize.Height() > aRectSize.Height()) )
				{
					maVirDev.SetClipRegion( Region( aRect ) );
					maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle);
					maVirDev.SetClipRegion();
				}
				else
					maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle );
			}
		}

        const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0);

        if(nEdgeBlendingPercent)
        {
            const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor());
            const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor());
            const sal_uInt8 nAlpha((nEdgeBlendingPercent * 255) / 100);
            const BitmapEx aBlendFrame(createBlendFrame(aRect.GetSize(), nAlpha, rTopLeft, rBottomRight));

            if(!aBlendFrame.IsEmpty())
            {
                maVirDev.DrawBitmapEx(aRect.TopLeft(), aBlendFrame);
            }
        }
	}
}

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

::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ValueSet::CreateAccessible()
{
    return new ValueSetAcc( this, mpImpl->mbIsTransientChildrenDisabled );
}

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

void ValueSet::Format()
{
	Size		aWinSize = GetOutputSizePixel();
    sal_uLong       nItemCount = mpImpl->mpItemList->Count();
	WinBits 	nStyle = GetStyle();
	long		nTxtHeight = GetTextHeight();
	long		nOff;
	long		nSpace;
	long		nNoneHeight;
	long		nNoneSpace;
	ScrollBar*	pDelScrBar = NULL;

	// Scrolling beruecksichtigen
	if ( nStyle & WB_VSCROLL )
		ImplInitScrollBar();
	else
	{
		if ( mpScrBar )
		{
			// ScrollBar erst spaeter zerstoeren, damit keine rekursiven
			// Aufrufe entstehen koennen
			pDelScrBar = mpScrBar;
			mpScrBar = NULL;
		}
	}

	// Item-Offset berechnen
	if ( nStyle & WB_ITEMBORDER )
	{
		if ( nStyle & WB_DOUBLEBORDER )
			nOff = ITEM_OFFSET_DOUBLE;
		else
			nOff = ITEM_OFFSET;
	}
	else
		nOff = 0;
	nSpace = mnSpacing;

	// Groesse beruecksichtigen, wenn NameField vorhanden
	if ( nStyle & WB_NAMEFIELD )
	{
		mnTextOffset = aWinSize.Height()-nTxtHeight-NAME_OFFSET;
		aWinSize.Height() -= nTxtHeight+NAME_OFFSET;

		if ( !(nStyle & WB_FLATVALUESET) )
		{
			mnTextOffset -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
			aWinSize.Height() -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
		}
	}
	else
		mnTextOffset = 0;

	// Offset und Groesse beruecksichtigen, wenn NoneField vorhanden
	if ( nStyle & WB_NONEFIELD )
	{
		nNoneHeight = nTxtHeight+nOff;
		nNoneSpace = nSpace;
		if ( nStyle & WB_RADIOSEL )
			nNoneHeight += 8;
	}
	else
	{
		nNoneHeight = 0;
		nNoneSpace = 0;

		if ( mpNoneItem )
		{
			delete mpNoneItem;
			mpNoneItem = NULL;
		}
	}

	// Breite vom ScrollBar berechnen
	long nScrBarWidth = 0;
	if ( mpScrBar )
		nScrBarWidth = mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;

	// Spaltenanzahl berechnen
	if ( !mnUserCols )
	{
		if ( mnUserItemWidth )
		{
			mnCols = (sal_uInt16)((aWinSize.Width()-nScrBarWidth+nSpace) / (mnUserItemWidth+nSpace));
			if ( !mnCols )
				mnCols = 1;
		}
		else
			mnCols = 1;
	}
	else
		mnCols = mnUserCols;

	// Zeilenanzahl berechnen
	mbScroll = false;
    mnLines = (long)mpImpl->mpItemList->Count() / mnCols;
    if ( mpImpl->mpItemList->Count() % mnCols )
		mnLines++;
	else if ( !mnLines )
		mnLines = 1;

	long nCalcHeight = aWinSize.Height()-nNoneHeight;
	if ( mnUserVisLines )
		mnVisLines = mnUserVisLines;
	else if ( mnUserItemHeight )
	{
		mnVisLines = (nCalcHeight-nNoneSpace+nSpace) / (mnUserItemHeight+nSpace);
		if ( !mnVisLines )
			mnVisLines = 1;
	}
	else
		mnVisLines = mnLines;
	if ( mnLines > mnVisLines )
		mbScroll = true;
	if ( mnLines <= mnVisLines )
		mnFirstLine = 0;
	else
	{
		if ( mnFirstLine > (sal_uInt16)(mnLines-mnVisLines) )
			mnFirstLine = (sal_uInt16)(mnLines-mnVisLines);
	}

	// Itemgroessen berechnen
	long nColSpace	= (mnCols-1)*nSpace;
	long nLineSpace = ((mnVisLines-1)*nSpace)+nNoneSpace;
	long nItemWidth;
	long nItemHeight;
	if ( mnUserItemWidth && !mnUserCols )
	{
		nItemWidth = mnUserItemWidth;
		if ( nItemWidth > aWinSize.Width()-nScrBarWidth-nColSpace )
			nItemWidth = aWinSize.Width()-nScrBarWidth-nColSpace;
	}
	else
		nItemWidth = (aWinSize.Width()-nScrBarWidth-nColSpace) / mnCols;
	if ( mnUserItemHeight && !mnUserVisLines )
	{
		nItemHeight = mnUserItemHeight;
		if ( nItemHeight > nCalcHeight-nNoneSpace )
			nItemHeight = nCalcHeight-nNoneSpace;
	}
	else
	{
		nCalcHeight -= nLineSpace;
		nItemHeight = nCalcHeight / mnVisLines;
	}

	// Init VirDev
	maVirDev.SetSettings( GetSettings() );
	maVirDev.SetBackground( GetBackground() );
	maVirDev.SetOutputSizePixel( aWinSize, sal_True );

	// Bei zu kleinen Items machen wir nichts
	long nMinHeight = 2;
	if ( nStyle & WB_ITEMBORDER )
		nMinHeight = 4;
	if ( (nItemWidth <= 0) || (nItemHeight <= nMinHeight) || !nItemCount )
	{
		if ( nStyle & WB_NONEFIELD )
		{
			if ( mpNoneItem )
			{
				mpNoneItem->maRect.SetEmpty();
				mpNoneItem->maText = GetText();
			}
		}

		for ( sal_uLong i = 0; i < nItemCount; i++ )
		{
            ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
			pItem->maRect.SetEmpty();
		}

		if ( mpScrBar )
			mpScrBar->Hide();
	}
	else
	{
		// Frame-Style ermitteln
		if ( nStyle & WB_DOUBLEBORDER )
			mnFrameStyle = FRAME_DRAW_DOUBLEIN;
		else
			mnFrameStyle = FRAME_DRAW_IN;

		// Selektionsfarben und -breiten ermitteln
		// Gegebenenfalls die Farben anpassen, damit man die Selektion besser
		// erkennen kann
		const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
		Color aHighColor( rStyleSettings.GetHighlightColor() );
		if ( ((aHighColor.GetRed() > 0x80) || (aHighColor.GetGreen() > 0x80) ||
			  (aHighColor.GetBlue() > 0x80)) ||
			 ((aHighColor.GetRed() == 0x80) && (aHighColor.GetGreen() == 0x80) &&
			  (aHighColor.GetBlue() == 0x80)) )
			mbBlackSel = true;
		else
			mbBlackSel = false;

		// Wenn die Items groesser sind, dann die Selektion doppelt so breit
		// zeichnen
		if ( (nStyle & WB_DOUBLEBORDER) &&
			 ((nItemWidth >= 25) && (nItemHeight >= 20)) )
			mbDoubleSel = true;
		else
			mbDoubleSel = false;

		// Calculate offsets
		long nStartX;
		long nStartY;
		if ( mbFullMode )
		{
			long nAllItemWidth = (nItemWidth*mnCols)+nColSpace;
			long nAllItemHeight = (nItemHeight*mnVisLines)+nNoneHeight+nLineSpace;
			nStartX = (aWinSize.Width()-nScrBarWidth-nAllItemWidth)/2;
			nStartY = (aWinSize.Height()-nAllItemHeight)/2;
		}
		else
		{
			nStartX = 0;
			nStartY = 0;
		}

		// Items berechnen und zeichnen
		maVirDev.SetLineColor();
		long x = nStartX;
		long y = nStartY;

		// NoSelection-Field erzeugen und anzeigen
		if ( nStyle & WB_NONEFIELD )
		{
			if ( !mpNoneItem )
				mpNoneItem = new ValueSetItem( *this );

			mpNoneItem->mnId			= 0;
			mpNoneItem->meType			= VALUESETITEM_NONE;
			mpNoneItem->maRect.Left()	= x;
			mpNoneItem->maRect.Top()	= y;
			mpNoneItem->maRect.Right()	= mpNoneItem->maRect.Left()+aWinSize.Width()-x-1;
			mpNoneItem->maRect.Bottom() = y+nNoneHeight-1;

			ImplFormatItem( mpNoneItem );

			y += nNoneHeight+nNoneSpace;
		}

		// draw items
		sal_uLong nFirstItem = mnFirstLine * mnCols;
		sal_uLong nLastItem = nFirstItem + (mnVisLines * mnCols);

        if ( !mbFullMode )
		{
			// If want also draw parts of items in the last line,
			// then we add one more line if parts of these line are
			// visible
			if ( y+(mnVisLines*(nItemHeight+nSpace)) < aWinSize.Height() )
				nLastItem += mnCols;
		}
		for ( sal_uLong i = 0; i < nItemCount; i++ )
		{
            ValueSetItem*   pItem = mpImpl->mpItemList->GetObject( i );

			if ( (i >= nFirstItem) && (i < nLastItem) )
			{
                const sal_Bool bWasEmpty = pItem->maRect.IsEmpty();

				pItem->maRect.Left()	= x;
				pItem->maRect.Top() 	= y;
				pItem->maRect.Right()	= pItem->maRect.Left()+nItemWidth-1;
				pItem->maRect.Bottom()	= pItem->maRect.Top()+nItemHeight-1;

                if( bWasEmpty && ImplHasAccessibleListeners() )
                {
                    ::com::sun::star::uno::Any aOldAny, aNewAny;

                    aNewAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
                    ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
                }

				ImplFormatItem( pItem );

				if ( !((i+1) % mnCols) )
				{
					x = nStartX;
					y += nItemHeight+nSpace;
				}
				else
					x += nItemWidth+nSpace;
			}
			else
            {
                if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() )
                {
                    ::com::sun::star::uno::Any aOldAny, aNewAny;

                    aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
                    ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
                }

                pItem->maRect.SetEmpty();
            }
		}

		// ScrollBar anordnen, Werte setzen und anzeigen
		if ( mpScrBar )
		{
			Point	aPos( aWinSize.Width()-nScrBarWidth+SCRBAR_OFFSET, 0 );
			Size	aSize( nScrBarWidth-SCRBAR_OFFSET, aWinSize.Height() );
			// If a none field is visible, then we center the scrollbar
			if ( nStyle & WB_NONEFIELD )
			{
				aPos.Y() = nStartY+nNoneHeight+1;
				aSize.Height() = ((nItemHeight+nSpace)*mnVisLines)-2-nSpace;
			}
			mpScrBar->SetPosSizePixel( aPos, aSize );
			mpScrBar->SetRangeMax( mnLines );
			mpScrBar->SetVisibleSize( mnVisLines );
			mpScrBar->SetThumbPos( (long)mnFirstLine );
			long nPageSize = mnVisLines;
			if ( nPageSize < 1 )
				nPageSize = 1;
			mpScrBar->SetPageSize( nPageSize );
			mpScrBar->Show();
		}
	}

	// Jetzt haben wir formatiert und warten auf das naechste
	mbFormat = false;

	// ScrollBar loeschen
	if ( pDelScrBar )
		delete pDelScrBar;
}

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

void ValueSet::ImplDrawItemText( const XubString& rText )
{
	if ( !(GetStyle() & WB_NAMEFIELD) )
		return;

	Size	aWinSize = GetOutputSizePixel();
	long	nTxtWidth = GetTextWidth( rText );
	long	nTxtOffset = mnTextOffset;

	// Rechteck loeschen und Text ausgeben
	if ( GetStyle() & WB_FLATVALUESET )
	{
		const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
		SetLineColor();
		SetFillColor( rStyleSettings.GetFaceColor() );
		DrawRect( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
		SetTextColor( rStyleSettings.GetButtonTextColor() );
	}
	else
	{
		nTxtOffset += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
		Erase( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
	}
	DrawText( Point( (aWinSize.Width()-nTxtWidth) / 2, nTxtOffset+(NAME_OFFSET/2) ), rText );
}

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

void ValueSet::ImplDrawSelect()
{
	if ( !IsReallyVisible() )
		return;

	sal_Bool bFocus = HasFocus();
	sal_Bool bDrawSel;

	if ( (mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight) )
		bDrawSel = sal_False;
	else
		bDrawSel = sal_True;

	if ( !bFocus &&
		 ((mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight)) )
	{
		XubString aEmptyStr;
		ImplDrawItemText( aEmptyStr );
		return;
	}

	sal_uInt16 nItemId = mnSelItemId;

	for( int stage = 0; stage < 2; stage++ )
	{
		if( stage == 1 )
		{
			if ( mbHighlight )
				nItemId = mnHighItemId;
			else
				break;
		}

		ValueSetItem* pItem;
		if ( nItemId )
            pItem = mpImpl->mpItemList->GetObject( GetItemPos( nItemId ) );
		else
		{
			if ( mpNoneItem )
				pItem = mpNoneItem;
			else
			{
				pItem = ImplGetFirstItem();
				if ( !bFocus || !pItem )
					continue;
			}
		}

		if ( pItem->maRect.IsEmpty() )
			continue;

		// Selection malen
		const StyleSettings&	rStyleSettings = GetSettings().GetStyleSettings();
		Rectangle				aRect = pItem->maRect;
		Control::SetFillColor();

		Color aDoubleColor( rStyleSettings.GetHighlightColor() );
		Color aSingleColor( rStyleSettings.GetHighlightTextColor() );
		if( ! mbDoubleSel )
		{
			/*
			*  #99777# contrast enhancement for thin mode
			*/
			const Wallpaper& rWall = GetDisplayBackground();
			if( ! rWall.IsBitmap() && ! rWall.IsGradient() )
			{
				const Color& rBack = rWall.GetColor();
				if( rBack.IsDark() && ! aDoubleColor.IsBright() )
				{
					aDoubleColor = Color( COL_WHITE );
					aSingleColor = Color( COL_BLACK );
				}
				else if( rBack.IsBright() && ! aDoubleColor.IsDark() )
				{
					aDoubleColor = Color( COL_BLACK );
					aSingleColor = Color( COL_WHITE );
				}
			}
		}

		// Selectionsausgabe festlegen
		WinBits nStyle = GetStyle();
		if ( nStyle & WB_MENUSTYLEVALUESET )
		{
			if ( bFocus )
				ShowFocus( aRect );

			if ( bDrawSel )
			{
				if ( mbBlackSel )
					SetLineColor( Color( COL_BLACK ) );
				else
					SetLineColor( aDoubleColor );
				DrawRect( aRect );
			}
		}
		else if ( nStyle & WB_RADIOSEL )
		{
			aRect.Left()	+= 3;
			aRect.Top() 	+= 3;
			aRect.Right()	-= 3;
			aRect.Bottom()	-= 3;
			if ( nStyle & WB_DOUBLEBORDER )
			{
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
			}

			if ( bFocus )
				ShowFocus( aRect );

			aRect.Left()++;
			aRect.Top()++;
			aRect.Right()--;
			aRect.Bottom()--;

			if ( bDrawSel )
			{
				SetLineColor( aDoubleColor );
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
				DrawRect( aRect );
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
				DrawRect( aRect );
			}
		}
		else
		{
			if ( bDrawSel )
			{
				if ( mbBlackSel )
					SetLineColor( Color( COL_BLACK ) );
				else
					SetLineColor( aDoubleColor );
				DrawRect( aRect );
			}
			if ( mbDoubleSel )
			{
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
				if ( bDrawSel )
					DrawRect( aRect );
			}
			aRect.Left()++;
			aRect.Top()++;
			aRect.Right()--;
			aRect.Bottom()--;
			Rectangle aRect2 = aRect;
			aRect.Left()++;
			aRect.Top()++;
			aRect.Right()--;
			aRect.Bottom()--;
			if ( bDrawSel )
				DrawRect( aRect );
			if ( mbDoubleSel )
			{
				aRect.Left()++;
				aRect.Top()++;
				aRect.Right()--;
				aRect.Bottom()--;
				if ( bDrawSel )
					DrawRect( aRect );
			}

			if ( bDrawSel )
			{
				if ( mbBlackSel )
					SetLineColor( Color( COL_WHITE ) );
				else
					SetLineColor( aSingleColor );
			}
			else
				SetLineColor( Color( COL_LIGHTGRAY ) );
			DrawRect( aRect2 );

			if ( bFocus )
				ShowFocus( aRect2 );
		}

		ImplDrawItemText( pItem->maText );
	}
}

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

void ValueSet::ImplHideSelect( sal_uInt16 nItemId )
{
	Rectangle aRect;

    sal_uInt16 nItemPos = GetItemPos( nItemId );
	if ( nItemPos != sal::static_int_cast<sal_uInt16>(LIST_ENTRY_NOTFOUND) )
        aRect = mpImpl->mpItemList->GetObject( nItemPos )->maRect;
	else
	{
		if ( mpNoneItem )
			aRect = mpNoneItem->maRect;
	}

	if ( !aRect.IsEmpty() )
	{
		HideFocus();
		Point aPos	= aRect.TopLeft();
		Size  aSize = aRect.GetSize();
		DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
	}
}

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

void ValueSet::ImplHighlightItem( sal_uInt16 nItemId, sal_Bool bIsSelection )
{
	if ( mnHighItemId != nItemId )
	{
		// Alten merken, um vorherige Selektion zu entfernen
		sal_uInt16 nOldItem = mnHighItemId;
		mnHighItemId = nItemId;

		// Wenn keiner selektiert ist, dann Selektion nicht malen
		if ( !bIsSelection && mbNoSelection )
			mbDrawSelection = false;

		// Neu ausgeben und alte Selection wegnehmen
		ImplHideSelect( nOldItem );
		ImplDrawSelect();
		mbDrawSelection = true;
	}
}

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

void ValueSet::ImplDrawDropPos( sal_Bool bShow )
{
    if ( (mnDropPos != VALUESET_ITEM_NOTFOUND) && mpImpl->mpItemList->Count() )
	{
		sal_uInt16	nItemPos = mnDropPos;
		sal_uInt16	nItemId1;
		sal_uInt16	nItemId2 = 0;
		sal_Bool	bRight;
        if ( nItemPos >= mpImpl->mpItemList->Count() )
		{
            nItemPos = (sal_uInt16)(mpImpl->mpItemList->Count()-1);
			bRight = sal_True;
		}
		else
			bRight = sal_False;

		nItemId1 = GetItemId( nItemPos );
		if ( (nItemId1 != mnSelItemId) && (nItemId1 != mnHighItemId) )
			nItemId1 = 0;
        Rectangle aRect2 = mpImpl->mpItemList->GetObject( nItemPos )->maRect;
		Rectangle aRect1;
		if ( bRight )
		{
			aRect1 = aRect2;
			aRect2.SetEmpty();
		}
		else if ( nItemPos > 0 )
		{
            aRect1 = mpImpl->mpItemList->GetObject( nItemPos-1 )->maRect;
			nItemId2 = GetItemId( nItemPos-1 );
			if ( (nItemId2 != mnSelItemId) && (nItemId2 != mnHighItemId) )
				nItemId2 = 0;
		}

		// Items ueberhaupt sichtbar (nur Erstes/Letztes)
		if ( !aRect1.IsEmpty() || !aRect2.IsEmpty() )
		{
			if ( nItemId1 )
				ImplHideSelect( nItemId1 );
			if ( nItemId2 )
				ImplHideSelect( nItemId2 );

			if ( bShow )
			{
				const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
				long	nX;
				long	nY;
				SetLineColor( rStyleSettings.GetButtonTextColor() );
				if ( !aRect1.IsEmpty() )
				{
					Point aPos = aRect1.RightCenter();
					nX = aPos.X()-2;
					nY = aPos.Y();
					for ( sal_uInt16 i = 0; i < 4; i++ )
						DrawLine( Point( nX-i, nY-i ), Point( nX-i, nY+i ) );
				}
				if ( !aRect2.IsEmpty() )
				{
					Point aPos = aRect2.LeftCenter();
					nX = aPos.X()+2;
					nY = aPos.Y();
					for ( sal_uInt16 i = 0; i < 4; i++ )
						DrawLine( Point( nX+i, nY-i ), Point( nX+i, nY+i ) );
				}
			}
			else
			{
				if ( !aRect1.IsEmpty() )
				{
					Point aPos	= aRect1.TopLeft();
					Size  aSize = aRect1.GetSize();
					DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
				}
				if ( !aRect2.IsEmpty() )
				{
					Point aPos	= aRect2.TopLeft();
					Size  aSize = aRect2.GetSize();
					DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
				}
			}

			if ( nItemId1 || nItemId2 )
				ImplDrawSelect();
		}
	}
}

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

void ValueSet::ImplDraw()
{
	if ( mbFormat )
		Format();

	HideFocus();

	Point	aDefPos;
	Size	aSize = maVirDev.GetOutputSizePixel();

	if ( mpScrBar && mpScrBar->IsVisible() )
	{
		Point	aScrPos = mpScrBar->GetPosPixel();
		Size	aScrSize = mpScrBar->GetSizePixel();
		Point	aTempPos( 0, aScrPos.Y() );
		Size	aTempSize( aSize.Width(), aScrPos.Y() );

		DrawOutDev( aDefPos, aTempSize, aDefPos, aTempSize, maVirDev );
		aTempSize.Width()	= aScrPos.X()-1;
		aTempSize.Height()	= aScrSize.Height();
		DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
		aTempPos.Y()		= aScrPos.Y()+aScrSize.Height();
		aTempSize.Width()	= aSize.Width();
		aTempSize.Height()	= aSize.Height()-aTempPos.Y();
		DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
	}
	else
		DrawOutDev( aDefPos, aSize, aDefPos, aSize, maVirDev );

	// Trennlinie zum Namefield zeichnen
	if ( GetStyle() & WB_NAMEFIELD )
	{
		if ( !(GetStyle() & WB_FLATVALUESET) )
		{
			const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
			Size aWinSize = GetOutputSizePixel();
			Point aPos1( NAME_LINE_OFF_X, mnTextOffset+NAME_LINE_OFF_Y );
			Point aPos2( aWinSize.Width()-(NAME_LINE_OFF_X*2), mnTextOffset+NAME_LINE_OFF_Y );
			if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
			{
				SetLineColor( rStyleSettings.GetShadowColor() );
				DrawLine( aPos1, aPos2 );
				aPos1.Y()++;
				aPos2.Y()++;
				SetLineColor( rStyleSettings.GetLightColor() );
			}
			else
				SetLineColor( rStyleSettings.GetWindowTextColor() );
			DrawLine( aPos1, aPos2 );
		}
	}

	ImplDrawSelect();
}

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

sal_Bool ValueSet::ImplScroll( const Point& rPos )
{
	Size aOutSize = GetOutputSizePixel();
	long nScrBarWidth;

	if ( mpScrBar )
		nScrBarWidth = mpScrBar->GetSizePixel().Width();
	else
		nScrBarWidth = 0;

	if ( !mbScroll || (rPos.X() < 0) || (rPos.X() > aOutSize.Width()-nScrBarWidth) )
		return sal_False;

	long			 nScrollOffset;
	sal_uInt16			 nOldLine = mnFirstLine;
    const Rectangle& rTopRect = mpImpl->mpItemList->GetObject( mnFirstLine*mnCols )->maRect;
	if ( rTopRect.GetHeight() <= 16 )
		nScrollOffset = VALUESET_SCROLL_OFFSET/2;
	else
		nScrollOffset = VALUESET_SCROLL_OFFSET;
	if ( (mnFirstLine > 0) && (rPos.Y() >= 0) )
	{
		long nTopPos = rTopRect.Top();
		if ( (rPos.Y() >= nTopPos) && (rPos.Y() <= nTopPos+nScrollOffset) )
			mnFirstLine--;
	}
	if ( (mnFirstLine == nOldLine) &&
		 (mnFirstLine < (sal_uInt16)(mnLines-mnVisLines)) && (rPos.Y() < aOutSize.Height()) )
	{
        long nBottomPos = mpImpl->mpItemList->GetObject( (mnFirstLine+mnVisLines-1)*mnCols )->maRect.Bottom();
		if ( (rPos.Y() >= nBottomPos-nScrollOffset) && (rPos.Y() <= nBottomPos) )
			mnFirstLine++;
	}

	if ( mnFirstLine != nOldLine )
	{
		mbFormat = true;
		ImplDraw();
		return sal_True;
	}
	else
		return sal_False;
}

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

sal_uInt16 ValueSet::ImplGetItem( const Point& rPos, sal_Bool bMove ) const
{
	if ( mpNoneItem )
	{
		if ( mpNoneItem->maRect.IsInside( rPos ) )
			return VALUESET_ITEM_NONEITEM;
	}

	Point	  aDefPos;
	Rectangle aWinRect( aDefPos, maVirDev.GetOutputSizePixel() );

    sal_uLong nItemCount = mpImpl->mpItemList->Count();
	for ( sal_uLong i = 0; i < nItemCount; i++ )
	{
        ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
		if ( pItem->maRect.IsInside( rPos ) )
		{
			if ( aWinRect.IsInside( rPos ) )
				return (sal_uInt16)i;
			else
				return VALUESET_ITEM_NOTFOUND;
		}
	}

	// Wenn Spacing gesetzt ist, wird der vorher selektierte
	// Eintrag zurueckgegeben, wenn die Maus noch nicht das Fenster
	// verlassen hat
	if ( bMove && mnSpacing && mnHighItemId )
	{
		if ( aWinRect.IsInside( rPos ) )
			return GetItemPos( mnHighItemId );
	}

	return VALUESET_ITEM_NOTFOUND;
}

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

ValueSetItem* ValueSet::ImplGetItem( sal_uInt16 nPos )
{
	if ( nPos == VALUESET_ITEM_NONEITEM )
		return mpNoneItem;
	else
        return mpImpl->mpItemList->GetObject( nPos );
}

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

ValueSetItem* ValueSet::ImplGetFirstItem()
{
    sal_uInt16 nItemCount = (sal_uInt16)mpImpl->mpItemList->Count();
	sal_uInt16 i = 0;

	while ( i < nItemCount )
	{
        ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
		if ( pItem->meType != VALUESETITEM_SPACE )
			return pItem;
		i++;
	}

	return NULL;
}

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

sal_uInt16 ValueSet::ImplGetVisibleItemCount() const
{
    sal_uInt16 nRet = 0;

    for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); n < nItemCount; n++  )
    {
        ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n );

		//IAccessible2 implementation - also count empty rectangles as visible...
		if( pItem->meType != VALUESETITEM_SPACE )
            nRet++;
    }

    return nRet;
}

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

ValueSetItem* ValueSet::ImplGetVisibleItem( sal_uInt16 nVisiblePos )
{
    ValueSetItem*   pRet = NULL;
    sal_uInt16          nFoundPos = 0;

    for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); ( n < nItemCount ) && !pRet; n++  )
    {
        ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n );

        if( ( pItem->meType != VALUESETITEM_SPACE ) && !pItem->maRect.IsEmpty() && ( nVisiblePos == nFoundPos++ ) )
            pRet = pItem;
    }

    return pRet;
}

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

void ValueSet::ImplFireAccessibleEvent( short nEventId, const ::com::sun::star::uno::Any& rOldValue, const ::com::sun::star::uno::Any& rNewValue )
{
    ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );

    if( pAcc )
        pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue );
}

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

sal_Bool ValueSet::ImplHasAccessibleListeners()
{
    ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
    return( pAcc && pAcc->HasAccessibleListeners() );
}

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

IMPL_LINK( ValueSet,ImplScrollHdl, ScrollBar*, pScrollBar )
{
	sal_uInt16 nNewFirstLine = (sal_uInt16)pScrollBar->GetThumbPos();
	if ( nNewFirstLine != mnFirstLine )
	{
		mnFirstLine = nNewFirstLine;
		mbFormat = true;
		ImplDraw();
	}
	return 0;
}

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

IMPL_LINK( ValueSet,ImplTimerHdl, Timer*, EMPTYARG )
{
	ImplTracking( GetPointerPosPixel(), sal_True );
	return 0;
}

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

void ValueSet::ImplTracking( const Point& rPos, sal_Bool bRepeat )
{
	if ( bRepeat || mbSelection )
	{
		if ( ImplScroll( rPos ) )
		{
			if ( mbSelection )
			{
				maTimer.SetTimeoutHdl( LINK( this, ValueSet, ImplTimerHdl ) );
				maTimer.SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
				maTimer.Start();
			}
		}
	}

	ValueSetItem* pItem = ImplGetItem( ImplGetItem( rPos ) );
	if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
	{
		if( GetStyle() & WB_MENUSTYLEVALUESET )
			mbHighlight = true;

		ImplHighlightItem( pItem->mnId );
	}
	else
	{
		if( GetStyle() & WB_MENUSTYLEVALUESET )
			mbHighlight = true;

		ImplHighlightItem( mnSelItemId, sal_False );
	}
}

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

void ValueSet::ImplEndTracking( const Point& rPos, sal_Bool bCancel )
{
	ValueSetItem* pItem;

	// Bei Abbruch, den alten Status wieder herstellen
	if ( bCancel )
		pItem = NULL;
	else
		pItem = ImplGetItem( ImplGetItem( rPos ) );

	if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
	{
		SelectItem( pItem->mnId );
		if ( !mbSelection && !(GetStyle() & WB_NOPOINTERFOCUS) )
			GrabFocus();
		mbHighlight = false;
		mbSelection = false;
		Select();
	}
	else
	{
		ImplHighlightItem( mnSelItemId, sal_False );
		mbHighlight = false;
		mbSelection = false;
	}
}

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

void ValueSet::MouseButtonDown( const MouseEvent& rMEvt )
{
	if ( rMEvt.IsLeft() )
	{
		ValueSetItem* pItem = ImplGetItem( ImplGetItem( rMEvt.GetPosPixel() ) );
		if ( mbSelection )
		{
			mbHighlight = true;
			if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
			{
				mnOldItemId  = mnSelItemId;
				mnHighItemId = mnSelItemId;
				ImplHighlightItem( pItem->mnId );
			}

			return;
		}
		else
		{
			if ( pItem && (pItem->meType != VALUESETITEM_SPACE) && !rMEvt.IsMod2() )
			{
				if ( (pItem->mnBits & VIB_NODOUBLECLICK) || (rMEvt.GetClicks() == 1) )
				{
					mnOldItemId  = mnSelItemId;
					mbHighlight  = true;
					mnHighItemId = mnSelItemId;
					ImplHighlightItem( pItem->mnId );
					StartTracking( STARTTRACK_SCROLLREPEAT );
				}
				else if ( rMEvt.GetClicks() == 2 )
					DoubleClick();

				return;
			}
		}
	}

	Control::MouseButtonDown( rMEvt );
}

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

void ValueSet::MouseButtonUp( const MouseEvent& rMEvt )
{
	// Wegen SelectionMode
	if ( rMEvt.IsLeft() && mbSelection )
		ImplEndTracking( rMEvt.GetPosPixel(), sal_False );
	else
		Control::MouseButtonUp( rMEvt );
}

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

void ValueSet::MouseMove( const MouseEvent& rMEvt )
{
	// Wegen SelectionMode
	if ( mbSelection || (GetStyle() & WB_MENUSTYLEVALUESET) )
		ImplTracking( rMEvt.GetPosPixel(), sal_False );
	Control::MouseMove( rMEvt );
}

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

void ValueSet::Tracking( const TrackingEvent& rTEvt )
{
	Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();

	if ( rTEvt.IsTrackingEnded() )
		ImplEndTracking( aMousePos, rTEvt.IsTrackingCanceled() );
	else
		ImplTracking( aMousePos, rTEvt.IsTrackingRepeat() );
}

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

void ValueSet::KeyInput( const KeyEvent& rKEvt )
{
    sal_uInt16 nLastItem = (sal_uInt16)mpImpl->mpItemList->Count();
	sal_uInt16 nItemPos = VALUESET_ITEM_NOTFOUND;
	sal_uInt16 nCurPos = VALUESET_ITEM_NONEITEM;
	sal_uInt16 nCalcPos;

	if ( !nLastItem || !ImplGetFirstItem() )
	{
		Control::KeyInput( rKEvt );
		return;
	}
	else
		nLastItem--;

	if ( mnSelItemId )
		nCurPos = GetItemPos( mnSelItemId );
	nCalcPos = nCurPos;

    //switch off selection mode if key travelling is used
    sal_Bool bDefault = sal_False;
    switch ( rKEvt.GetKeyCode().GetCode() )
	{
		case KEY_HOME:
			if ( mpNoneItem )
				nItemPos = VALUESET_ITEM_NONEITEM;
			else
			{
				nItemPos = 0;
				while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE )
					nItemPos++;
			}
			break;

		case KEY_END:
			nItemPos = nLastItem;
			while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE )
			{
				if ( nItemPos == 0 )
					nItemPos = VALUESET_ITEM_NONEITEM;
				else
					nItemPos--;
			}
			break;

		case KEY_LEFT:
		case KEY_RIGHT:
            if ( rKEvt.GetKeyCode().GetCode()==KEY_LEFT )
            {
                do
                {
                    if ( nCalcPos == VALUESET_ITEM_NONEITEM )
                        nItemPos = nLastItem;
                    else if ( !nCalcPos )
                    {
                        if ( mpNoneItem )
                            nItemPos = VALUESET_ITEM_NONEITEM;
                        else
                            nItemPos = nLastItem;
                    }
                    else
                        nItemPos = nCalcPos-1;
                    nCalcPos = nItemPos;
                }
                while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
            }
            else
            {
                do
                {
                    if ( nCalcPos == VALUESET_ITEM_NONEITEM )
                        nItemPos = 0;
                    else if ( nCalcPos == nLastItem )
                    {
                        if ( mpNoneItem )
                            nItemPos = VALUESET_ITEM_NONEITEM;
                        else
                            nItemPos = 0;
                    }
                    else
                        nItemPos = nCalcPos+1;
                    nCalcPos = nItemPos;
                }
                while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
            }
            break;

		case KEY_UP:
		case KEY_PAGEUP:
        {
            if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEUP ||
                ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) )
            {
                const long nLineCount = ( ( KEY_UP == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines );
			    do
			    {
				    if ( nCalcPos == VALUESET_ITEM_NONEITEM )
				    {
					    if ( nLastItem+1 <= mnCols )
						    nItemPos = mnCurCol;
					    else
					    {
						    nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(mnCurCol%mnCols);
						    if ( nItemPos+mnCols <= nLastItem )
							    nItemPos = nItemPos + mnCols;
					    }
				    }
				    else if ( nCalcPos >= ( nLineCount * mnCols ) )
					    nItemPos = sal::static_int_cast< sal_uInt16 >(
                            nCalcPos - ( nLineCount * mnCols ));
				    else
				    {
						if ( mpNoneItem )
						{
							mnCurCol  = nCalcPos%mnCols;
							nItemPos = VALUESET_ITEM_NONEITEM;
						}
						else
						{
							if ( nLastItem+1 <= mnCols )
								nItemPos = nCalcPos;
							else
							{
								nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(nCalcPos%mnCols);
								if ( nItemPos+mnCols <= nLastItem )
									nItemPos = nItemPos + mnCols;
							}
						}
				    }
				    nCalcPos = nItemPos;
			    }
			    while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
            }
            else
    			Control::KeyInput( rKEvt );
        }
		break;

		case KEY_DOWN:
		case KEY_PAGEDOWN:
        {
            if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEDOWN ||
                ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) )
            {
                const long nLineCount = ( ( KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines );
                do
			    {
				    if ( nCalcPos == VALUESET_ITEM_NONEITEM )
					    nItemPos = mnCurCol;
				    else if ( nCalcPos + ( nLineCount * mnCols ) <= nLastItem )
					    nItemPos = sal::static_int_cast< sal_uInt16 >(
                            nCalcPos + ( nLineCount * mnCols ));
				    else
				    {
#if 0
						if( (KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) && (GetStyle() & WB_MENUSTYLEVALUESET) )
						{
							Window* pParent = GetParent();
							pParent->GrabFocus();
							pParent->KeyInput( rKEvt );
							break;
						}
						else
#endif
						{
							if ( mpNoneItem )
							{
								mnCurCol  = nCalcPos%mnCols;
								nItemPos = VALUESET_ITEM_NONEITEM;
							}
							else
								nItemPos = nCalcPos%mnCols;
						}
				    }
				    nCalcPos = nItemPos;
			    }
			    while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
            }
            else
    			Control::KeyInput( rKEvt );

        }
        break;
        case KEY_RETURN:
            //enable default handling of KEY_RETURN in dialogs
			if(0 != (GetStyle()&WB_NO_DIRECTSELECT))
            {
                Select();
                break;
            }
            //no break;
		default:
			Control::KeyInput( rKEvt );
            bDefault = sal_True;
			break;
	}
    if(!bDefault)
        EndSelection();
    if ( nItemPos != VALUESET_ITEM_NOTFOUND )
	{
		sal_uInt16 nItemId;
		if ( nItemPos != VALUESET_ITEM_NONEITEM )
			nItemId = GetItemId( nItemPos );
		else
			nItemId = 0;

		if ( nItemId != mnSelItemId )
		{
			SelectItem( nItemId );
			//select only if WB_NO_DIRECTSELECT is not set
			if(0 == (GetStyle()&WB_NO_DIRECTSELECT))
				Select();
		}
	}
}

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

void ValueSet::Command( const CommandEvent& rCEvt )
{
	if ( (rCEvt.GetCommand() == COMMAND_WHEEL) ||
		 (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) ||
		 (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) )
	{
		if ( HandleScrollCommand( rCEvt, NULL, mpScrBar ) )
			return;
	}

	Control::Command( rCEvt );
}

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

void ValueSet::Paint( const Rectangle& )
{
	if ( GetStyle() & WB_FLATVALUESET )
	{
		const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
		SetLineColor();
		SetFillColor( rStyleSettings.GetFaceColor() );
		long nOffY = maVirDev.GetOutputSizePixel().Height();
		Size aWinSize = GetOutputSizePixel();
		DrawRect( Rectangle( Point( 0, nOffY ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
	}

	ImplDraw();
}

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

void ValueSet::GetFocus()
{
    OSL_TRACE ("value set getting focus");
	ImplDrawSelect();
	Control::GetFocus();

    // Tell the accessible object that we got the focus.
    ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
    if( pAcc )
        pAcc->GetFocus();
}

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

void ValueSet::LoseFocus()
{
    OSL_TRACE ("value set losing focus");
	if ( mbNoSelection && mnSelItemId )
		ImplHideSelect( mnSelItemId );
	else
		HideFocus();
	Control::LoseFocus();

    // Tell the accessible object that we lost the focus.
    ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
    if( pAcc )
        pAcc->LoseFocus();
}

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

void ValueSet::Resize()
{
	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
	Control::Resize();
}

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

void ValueSet::RequestHelp( const HelpEvent& rHEvt )
{
	if ( (rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON)) == HELPMODE_QUICK )
	{
		Point aPos = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
		sal_uInt16 nItemPos = ImplGetItem( aPos );
		if ( nItemPos != VALUESET_ITEM_NOTFOUND )
		{
			ValueSetItem* pItem = ImplGetItem( nItemPos );
			Rectangle aItemRect = pItem->maRect;
			Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
			aItemRect.Left()   = aPt.X();
			aItemRect.Top()    = aPt.Y();
			aPt = OutputToScreenPixel( aItemRect.BottomRight() );
			aItemRect.Right()  = aPt.X();
			aItemRect.Bottom() = aPt.Y();
			Help::ShowQuickHelp( this, aItemRect, GetItemText( pItem->mnId ) );
			return;
		}
	}

	Control::RequestHelp( rHEvt );
}

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

void ValueSet::StateChanged( StateChangedType nType )
{
	Control::StateChanged( nType );

	if ( nType == STATE_CHANGE_INITSHOW )
	{
		if ( mbFormat )
			Format();
	}
	else if ( nType == STATE_CHANGE_UPDATEMODE )
	{
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
	else if ( nType == STATE_CHANGE_TEXT )
	{
		if ( mpNoneItem && !mbFormat && IsReallyVisible() && IsUpdateMode() )
		{
			ImplFormatItem( mpNoneItem );
			Invalidate( mpNoneItem->maRect );
		}
	}
	else if ( (nType == STATE_CHANGE_ZOOM) ||
			  (nType == STATE_CHANGE_CONTROLFONT) )
	{
		ImplInitSettings( sal_True, sal_False, sal_False );
		Invalidate();
	}
	else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
	{
		ImplInitSettings( sal_False, sal_True, sal_False );
		Invalidate();
	}
	else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
	{
		ImplInitSettings( sal_False, sal_False, sal_True );
		Invalidate();
	}
    else if ( (nType == STATE_CHANGE_STYLE) || (nType == STATE_CHANGE_ENABLE) )
	{
		mbFormat = true;
		ImplInitSettings( sal_False, sal_False, sal_True );
		Invalidate();
	}
}

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

void ValueSet::DataChanged( const DataChangedEvent& rDCEvt )
{
	Control::DataChanged( rDCEvt );

	if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
		 (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
		 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
		 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
		  (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
	{
		mbFormat = true;
		ImplInitSettings( sal_True, sal_True, sal_True );
		Invalidate();
	}
}

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

void ValueSet::Select()
{
	maSelectHdl.Call( this );
}

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

void ValueSet::DoubleClick()
{
	maDoubleClickHdl.Call( this );
}

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

void ValueSet::UserDraw( const UserDrawEvent& )
{
}

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

void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_IMAGE;
	pItem->maImage	= rImage;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_COLOR;
	pItem->maColor	= rColor;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage,
						   const XubString& rText, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_IMAGE;
	pItem->maImage	= rImage;
	pItem->maText	= rText;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor,
						   const XubString& rText, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_COLOR;
	pItem->maColor	= rColor;
	pItem->maText	= rText;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

//method to set accessible when the style is user draw.
void ValueSet::InsertItem( sal_uInt16 nItemId, const XubString& rText, sal_uInt16 nPos	)
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );
	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_USERDRAW;
	pItem->maText	= rText;
	mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
	mbFormat = sal_True;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::InsertItem( sal_uInt16 nItemId, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertItem(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_USERDRAW;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::InsertSpace( sal_uInt16 nItemId, sal_uInt16 nPos )
{
	DBG_ASSERT( nItemId, "ValueSet::InsertSpace(): ItemId == 0" );
	DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
				"ValueSet::InsertSpace(): ItemId already exists" );

	ValueSetItem* pItem = new ValueSetItem( *this );
	pItem->mnId 	= nItemId;
	pItem->meType	= VALUESETITEM_SPACE;
    mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::RemoveItem( sal_uInt16 nItemId )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos == VALUESET_ITEM_NOTFOUND )
		return;

    delete mpImpl->mpItemList->Remove( nPos );

	// Variablen zuruecksetzen
	if ( (mnHighItemId == nItemId) || (mnSelItemId == nItemId) )
	{
		mnCurCol		= 0;
		mnOldItemId 	= 0;
		mnHighItemId	= 0;
		mnSelItemId 	= 0;
		mbNoSelection	= true;
	}

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::CopyItems( const ValueSet& rValueSet )
{
    ImplDeleteItems();

    ValueSetItem* pItem = rValueSet.mpImpl->mpItemList->First();
	while ( pItem )
	{
        ValueSetItem* pNewItem = new ValueSetItem( *this );

        pNewItem->mnId = pItem->mnId;
        pNewItem->mnBits = pItem->mnBits;
        pNewItem->meType = pItem->meType;
        pNewItem->maImage = pItem->maImage;
        pNewItem->maColor = pItem->maColor;
        pNewItem->maText = pItem->maText;
        pNewItem->mpData = pItem->mpData;
        pNewItem->maRect = pItem->maRect;
        pNewItem->mpxAcc = NULL;

        mpImpl->mpItemList->Insert( pNewItem );
        pItem = rValueSet.mpImpl->mpItemList->Next();
	}

	// Variablen zuruecksetzen
	mnFirstLine 	= 0;
	mnCurCol		= 0;
	mnOldItemId 	= 0;
	mnHighItemId	= 0;
	mnSelItemId 	= 0;
	mbNoSelection	= true;

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

void ValueSet::Clear()
{
    ImplDeleteItems();

	// Variablen zuruecksetzen
	mnFirstLine 	= 0;
	mnCurCol		= 0;
	mnOldItemId 	= 0;
	mnHighItemId	= 0;
	mnSelItemId 	= 0;
	mbNoSelection	= true;

	mbFormat = true;
	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
}

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

sal_uInt16 ValueSet::GetItemCount() const
{
    return (sal_uInt16)mpImpl->mpItemList->Count();
}

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

sal_uInt16 ValueSet::GetItemPos( sal_uInt16 nItemId ) const
{
    ValueSetItem* pItem = mpImpl->mpItemList->First();
	while ( pItem )
	{
		if ( pItem->mnId == nItemId )
            return (sal_uInt16)mpImpl->mpItemList->GetCurPos();
        pItem = mpImpl->mpItemList->Next();
	}

	return VALUESET_ITEM_NOTFOUND;
}

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

sal_uInt16 ValueSet::GetItemId( sal_uInt16 nPos ) const
{
    ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );

	if ( pItem )
		return pItem->mnId;
	else
		return 0;
}

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

sal_uInt16 ValueSet::GetItemId( const Point& rPos ) const
{
	sal_uInt16 nItemPos = ImplGetItem( rPos );
	if ( nItemPos != VALUESET_ITEM_NOTFOUND )
		return GetItemId( nItemPos );

	return 0;
}

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

Rectangle ValueSet::GetItemRect( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->maRect;
	else
		return Rectangle();
}

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

void ValueSet::EnableFullItemMode( bool bFullMode )
{
	mbFullMode = bFullMode;
}

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

void ValueSet::SetColCount( sal_uInt16 nNewCols )
{
	if ( mnUserCols != nNewCols )
	{
		mnUserCols = nNewCols;
		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::SetLineCount( sal_uInt16 nNewLines )
{
	if ( mnUserVisLines != nNewLines )
	{
		mnUserVisLines = nNewLines;
		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::SetItemWidth( long nNewItemWidth )
{
	if ( mnUserItemWidth != nNewItemWidth )
	{
		mnUserItemWidth = nNewItemWidth;
		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::SetItemHeight( long nNewItemHeight )
{
	if ( mnUserItemHeight != nNewItemHeight )
	{
		mnUserItemHeight = nNewItemHeight;
		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::SetFirstLine( sal_uInt16 nNewLine )
{
	if ( mnFirstLine != nNewLine )
	{
		mnFirstLine = nNewLine;
		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::SelectItem( sal_uInt16 nItemId )
{
	sal_uInt16 nItemPos = 0;

	if ( nItemId )
	{
		nItemPos = GetItemPos( nItemId );
		if ( nItemPos == VALUESET_ITEM_NOTFOUND )
			return;
        if ( mpImpl->mpItemList->GetObject( nItemPos )->meType == VALUESETITEM_SPACE )
			return;
	}

	if ( (mnSelItemId != nItemId) || mbNoSelection )
	{
        sal_uInt16 nOldItem = mnSelItemId ? mnSelItemId : 1;
		mnSelItemId = nItemId;
		mbNoSelection = false;

		sal_Bool bNewOut;
		sal_Bool bNewLine;
		if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
			bNewOut = sal_True;
		else
			bNewOut = sal_False;
		bNewLine = sal_False;

		// Gegebenenfalls in den sichtbaren Bereich scrollen
		if ( mbScroll && nItemId )
		{
			sal_uInt16 nNewLine = (sal_uInt16)(nItemPos / mnCols);
			if ( nNewLine < mnFirstLine )
			{
				mnFirstLine = nNewLine;
				bNewLine = sal_True;
			}
			else if ( nNewLine > (sal_uInt16)(mnFirstLine+mnVisLines-1) )
			{
				mnFirstLine = (sal_uInt16)(nNewLine-mnVisLines+1);
				bNewLine = sal_True;
			}
		}

		if ( bNewOut )
		{
			if ( bNewLine )
			{
				// Falls sich der sichtbare Bereich geaendert hat,
				// alles neu ausgeben
				mbFormat = true;
				ImplDraw();
			}
			else
			{
				// alte Selection wegnehmen und neue ausgeben
				ImplHideSelect( nOldItem );
				ImplDrawSelect();
			}
		}

        if( ImplHasAccessibleListeners() )
        {
            // focus event (deselect)
            if( nOldItem )
            {
	            const sal_uInt16 nPos = GetItemPos( nItemId );

	            if( nPos != VALUESET_ITEM_NOTFOUND )
                {
                    ValueItemAcc* pItemAcc = ValueItemAcc::getImplementation(
                        mpImpl->mpItemList->GetObject( nPos )->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );

                    if( pItemAcc )
                    {
                        ::com::sun::star::uno::Any aOldAny, aNewAny;
                        if( !mpImpl->mbIsTransientChildrenDisabled)
                        {
                            aOldAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
                                static_cast< ::cppu::OWeakObject* >( pItemAcc ));
                            ImplFireAccessibleEvent (::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
                        }
                        else
                        {
                            aOldAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
                            pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
                        }
                    }
                }
            }

            // focus event (select)
            const sal_uInt16 nPos = GetItemPos( mnSelItemId );

            ValueSetItem* pItem;
            if( nPos != VALUESET_ITEM_NOTFOUND )
                pItem = mpImpl->mpItemList->GetObject(nPos);
            else
                pItem = mpNoneItem;

            ValueItemAcc* pItemAcc = NULL;
            if (pItem != NULL)
                pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );

            if( pItemAcc )
            {
                ::com::sun::star::uno::Any aOldAny, aNewAny;
                if( !mpImpl->mbIsTransientChildrenDisabled)
                {
                    aNewAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
                        static_cast< ::cppu::OWeakObject* >( pItemAcc ));
                    ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
                }
                else
                {
                    aNewAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
                    pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
                }
            }

            // selection event
            ::com::sun::star::uno::Any aOldAny, aNewAny;
            ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny );
        }
		mpImpl->maHighlightHdl.Call(this);
	}
}

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

void ValueSet::SetNoSelection()
{
	mbNoSelection	= true;
	mbHighlight 	= false;
	mbSelection 	= false;

	if ( IsReallyVisible() && IsUpdateMode() )
		ImplDraw();
}

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

void ValueSet::SetItemBits( sal_uInt16 nItemId, sal_uInt16 nItemBits )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        mpImpl->mpItemList->GetObject( nPos )->mnBits = nItemBits;
}

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

sal_uInt16 ValueSet::GetItemBits( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->mnBits;
	else
		return 0;
}

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

void ValueSet::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos == VALUESET_ITEM_NOTFOUND )
		return;

    ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
	pItem->meType  = VALUESETITEM_IMAGE;
	pItem->maImage = rImage;

	if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
	{
		ImplFormatItem( pItem );
		Invalidate( pItem->maRect );
	}
	else
		mbFormat = true;
}

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

Image ValueSet::GetItemImage( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->maImage;
	else
		return Image();
}

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

void ValueSet::SetItemColor( sal_uInt16 nItemId, const Color& rColor )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos == VALUESET_ITEM_NOTFOUND )
		return;

    ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
	pItem->meType  = VALUESETITEM_COLOR;
	pItem->maColor = rColor;

	if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
	{
		ImplFormatItem( pItem );
		Invalidate( pItem->maRect );
	}
	else
		mbFormat = true;
}

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

Color ValueSet::GetItemColor( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->maColor;
	else
		return Color();
}

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

void ValueSet::SetItemData( sal_uInt16 nItemId, void* pData )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos == VALUESET_ITEM_NOTFOUND )
		return;

    ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
	pItem->mpData = pData;

	if ( pItem->meType == VALUESETITEM_USERDRAW )
	{
		if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
		{
			ImplFormatItem( pItem );
			Invalidate( pItem->maRect );
		}
		else
			mbFormat = true;
	}
}

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

void* ValueSet::GetItemData( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->mpData;
	else
		return NULL;
}

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

void ValueSet::SetItemText( sal_uInt16 nItemId, const XubString& rText )
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos == VALUESET_ITEM_NOTFOUND )
		return;


    ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );

    // Remember old and new name for accessibility event.
    ::com::sun::star::uno::Any aOldName, aNewName;
    ::rtl::OUString sString (pItem->maText);
    aOldName <<= sString;
    sString = rText;
    aNewName <<= sString;

	pItem->maText = rText;

	if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
	{
		sal_uInt16 nTempId = mnSelItemId;

		if ( mbHighlight )
			nTempId = mnHighItemId;

		if ( nTempId == nItemId )
			ImplDrawItemText( pItem->maText );
	}

    if (ImplHasAccessibleListeners())
    {
        ::com::sun::star::uno::Reference<
              ::com::sun::star::accessibility::XAccessible> xAccessible (
                  pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );
        static_cast<ValueItemAcc*>(xAccessible.get())->FireAccessibleEvent (
            ::com::sun::star::accessibility::AccessibleEventId::NAME_CHANGED,
            aOldName, aNewName);
    }
}

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

XubString ValueSet::GetItemText( sal_uInt16 nItemId ) const
{
	sal_uInt16 nPos = GetItemPos( nItemId );

	if ( nPos != VALUESET_ITEM_NOTFOUND )
        return mpImpl->mpItemList->GetObject( nPos )->maText;
	else
		return XubString();
}

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

void ValueSet::SetColor( const Color& rColor )
{
	maColor 	= rColor;
	mbFormat	= true;
	if ( IsReallyVisible() && IsUpdateMode() )
		ImplDraw();
}

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

void ValueSet::SetExtraSpacing( sal_uInt16 nNewSpacing )
{
	if ( GetStyle() & WB_ITEMBORDER )
	{
		mnSpacing = nNewSpacing;

		mbFormat = true;
		if ( IsReallyVisible() && IsUpdateMode() )
			Invalidate();
	}
}

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

void ValueSet::StartSelection()
{
	mnOldItemId 	= mnSelItemId;
	mbHighlight 	= true;
	mbSelection 	= true;
	mnHighItemId	= mnSelItemId;
}

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

void ValueSet::EndSelection()
{
	if ( mbHighlight )
	{
		if ( IsTracking() )
			EndTracking( ENDTRACK_CANCEL );

		ImplHighlightItem( mnSelItemId );
		mbHighlight = false;
	}
	mbSelection = false;
}

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

sal_Bool ValueSet::StartDrag( const CommandEvent& rCEvt, Region& rRegion )
{
	if ( rCEvt.GetCommand() != COMMAND_STARTDRAG )
		return sal_False;

	// Gegebenenfalls eine vorhandene Aktion abbrechen
	EndSelection();

	// Testen, ob angeklickte Seite selektiert ist. Falls dies nicht
	// der Fall ist, setzen wir ihn als aktuellen Eintrag. Falls Drag and
	// Drop auch mal ueber Tastatur ausgeloest werden kann, testen wir
	// dies nur bei einer Mausaktion.
	sal_uInt16 nSelId;
	if ( rCEvt.IsMouseEvent() )
		nSelId = GetItemId( rCEvt.GetMousePosPixel() );
	else
		nSelId = mnSelItemId;

	// Falls kein Eintrag angeklickt wurde, starten wir kein Dragging
	if ( !nSelId )
		return sal_False;

	// Testen, ob Seite selektiertiert ist. Falls nicht, als aktuelle
	// Seite setzen und Select rufen.
	if ( nSelId != mnSelItemId )
	{
		SelectItem( nSelId );
		Update();
		Select();
	}

	Region aRegion;

	// Region zuweisen
	rRegion = aRegion;

	return sal_True;
}

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

Size ValueSet::CalcWindowSizePixel( const Size& rItemSize, sal_uInt16 nDesireCols,
									sal_uInt16 nDesireLines )
{
	long nCalcCols = (long)nDesireCols;
	long nCalcLines = (long)nDesireLines;

	if ( !nCalcCols )
	{
		if ( mnUserCols )
			nCalcCols = (long)mnUserCols;
		else
			nCalcCols = 1;
	}

	if ( !nCalcLines )
	{
		nCalcLines = mnVisLines;

		if ( mbFormat )
		{
			if ( mnUserVisLines )
				nCalcLines = mnUserVisLines;
			else
			{
                nCalcLines = (long)mpImpl->mpItemList->Count() / nCalcCols;
                if ( mpImpl->mpItemList->Count() % nCalcCols )
					nCalcLines++;
				else if ( !nCalcLines )
					nCalcLines = 1;
			}
		}
	}

	Size		aSize( rItemSize.Width()*nCalcCols, rItemSize.Height()*nCalcLines );
	WinBits 	nStyle = GetStyle();
	long		nTxtHeight = GetTextHeight();
	long		nSpace;
	long		n;

	if ( nStyle & WB_ITEMBORDER )
	{
		if ( nStyle & WB_DOUBLEBORDER )
			n = ITEM_OFFSET_DOUBLE;
		else
			n = ITEM_OFFSET;

		aSize.Width()  += n*nCalcCols;
		aSize.Height() += n*nCalcLines;
	}
	else
		n = 0;

	if ( mnSpacing )
	{
		nSpace = mnSpacing;
		aSize.Width()  += mnSpacing*(nCalcCols-1);
		aSize.Height() += mnSpacing*(nCalcLines-1);
	}
	else
		nSpace = 0;

	if ( nStyle & WB_NAMEFIELD )
	{
		aSize.Height() += nTxtHeight + NAME_OFFSET;
		if ( !(nStyle & WB_FLATVALUESET) )
			aSize.Height() += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
	}

	if ( nStyle & WB_NONEFIELD )
	{
		aSize.Height() += nTxtHeight + n + nSpace;
		if ( nStyle & WB_RADIOSEL )
			aSize.Height() += 8;
	}

	// Evt. ScrollBar-Breite aufaddieren
	aSize.Width() += GetScrollWidth();

	return aSize;
}

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

Size ValueSet::CalcItemSizePixel( const Size& rItemSize, bool bOut ) const
{
	Size aSize = rItemSize;

	WinBits nStyle = GetStyle();
	if ( nStyle & WB_ITEMBORDER )
	{
		long n;

		if ( nStyle & WB_DOUBLEBORDER )
			n = ITEM_OFFSET_DOUBLE;
		else
			n = ITEM_OFFSET;

		if ( bOut )
		{
			aSize.Width()  += n;
			aSize.Height() += n;
		}
		else
		{
			aSize.Width()  -= n;
			aSize.Height() -= n;
		}
	}

	return aSize;
}

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

long ValueSet::GetScrollWidth() const
{
	if ( GetStyle() & WB_VSCROLL )
	{
		((ValueSet*)this)->ImplInitScrollBar();
		return mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;
	}
	else
		return 0;
}

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

sal_uInt16 ValueSet::ShowDropPos( const Point& rPos )
{
	mbDropPos = true;

	// Gegebenenfalls scrollen
	ImplScroll( rPos );

	// DropPosition ermitteln
	sal_uInt16 nPos = ImplGetItem( rPos, sal_True );
	if ( nPos == VALUESET_ITEM_NONEITEM )
		nPos = 0;
	else if ( nPos == VALUESET_ITEM_NOTFOUND )
	{
		Size aOutSize = GetOutputSizePixel();
		if ( GetStyle() & WB_NAMEFIELD )
			aOutSize.Height() = mnTextOffset;
		if ( (rPos.X() >= 0) && (rPos.X() < aOutSize.Width()) &&
			 (rPos.Y() >= 0) && (rPos.Y() < aOutSize.Height()) )
            nPos = (sal_uInt16)mpImpl->mpItemList->Count();
	}
	else
	{
		// Im letzten viertel, dann wird ein Item spaeter eingefuegt
        Rectangle aRect = mpImpl->mpItemList->GetObject( nPos )->maRect;
		if ( rPos.X() > aRect.Left()+aRect.GetWidth()-(aRect.GetWidth()/4) )
			nPos++;
	}

	if ( nPos != mnDropPos )
	{
		ImplDrawDropPos( sal_False );
		mnDropPos = nPos;
		ImplDrawDropPos( sal_True );
	}

	return mnDropPos;
}

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

void ValueSet::HideDropPos()
{
	if ( mbDropPos )
	{
		ImplDrawDropPos( sal_False );
		mbDropPos = false;
	}
}

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

bool ValueSet::IsRTLActive (void)
{
    return Application::GetSettings().GetLayoutRTL() && IsRTLEnabled();
}

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

void ValueSet::SetHighlightHdl( const Link& rLink )
{
	mpImpl->maHighlightHdl = rLink;
}

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

const Link& ValueSet::GetHighlightHdl() const
{
	return mpImpl->maHighlightHdl;
}

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

void ValueSet::SetEdgeBlending(bool bNew)
{
    if(mbEdgeBlending != bNew)
    {
        mbEdgeBlending = bNew;
        mbFormat = true;

        if(IsReallyVisible() && IsUpdateMode())
        {
            Invalidate();
        }
    }
}
//For sending out the focused event on the first focused item when this valueset is first focused.
// MT: Focus notifications changed in DEV300 meanwhile, so this is not used for now.
// Just keeping it here for reference, in case something in out implementation doesn't work as expected...
/*
void ValueSet::SetFocusedItem(sal_Bool bFocused)
{
	if( ImplHasAccessibleListeners() )
	{
        // selection event
        ::com::sun::star::uno::Any aSelOldAny, aSelNewAny;
		if ( mnSelItemId >= 0)
		{
			// focus event (select)
		    sal_uInt16 nPos = GetItemPos( mnSelItemId );

			ValueSetItem* pItem;
			if ((GetStyle() & WB_NONEFIELD) != 0
				&& nPos == VALUESET_ITEM_NOTFOUND
				&& mnSelItemId == 0)
			{
				// When present the first item is the then allways visible none field.
				pItem = ImplGetItem (VALUESET_ITEM_NONEITEM);
			}
			else
			{
				if (nPos == VALUESET_ITEM_NOTFOUND)
					nPos = 0;
				pItem = mpImpl->mpItemList->GetObject(nPos);
			}
			ValueItemAcc* pItemAcc = NULL;
			if (pItem != NULL)
				pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled) );
			if( pItemAcc )
			{
				if (bFocused)
					aSelNewAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled);
				else
					aSelOldAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled);
			}
			ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aSelOldAny, aSelNewAny );
			if (pItemAcc && bFocused)
			{
				pItemAcc->FireAccessibleEvent(
					::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED,
					::com::sun::star::uno::Any(),::com::sun::star::uno::Any());
			}
		}
	}
}
*/
//end


// -----------------------------------------------------------------------
// eof