/**************************************************************
 * 
 * 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 <svtools/brwbox.hxx>
#include <svtools/brwhead.hxx>
#include "datwin.hxx"
#include <tools/debug.hxx>
#include <tools/stream.hxx>

#include <functional>
#include <algorithm>
#include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
#include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
#include <com/sun/star/accessibility/AccessibleEventId.hpp>
#include <com/sun/star/accessibility/XAccessible.hpp>
#include <tools/multisel.hxx>
#include "brwimpl.hxx"

DBG_NAME(BrowseBox)

extern const char* BrowseBoxCheckInvariants( const void* pVoid );

DECLARE_LIST( BrowserColumns, BrowserColumn* )

#define SCROLL_FLAGS (SCROLL_CLIP | SCROLL_NOCHILDREN)
#define getDataWindow() ((BrowserDataWin*)pDataWin)

using namespace com::sun::star::accessibility::AccessibleEventId;
using namespace com::sun::star::accessibility::AccessibleTableModelChangeType;
using com::sun::star::accessibility::AccessibleTableModelChange;
using com::sun::star::lang::XComponent;
using namespace ::com::sun::star::uno;
using namespace svt;

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

#ifdef DBG_MI
void DoLog_Impl( const BrowseBox *pThis, const char *pWhat, const char *pWho )
{
	SvFileStream aLog( "d:\\cursor.log", STREAM_WRITE|STREAM_NOCREATE );
	if ( aLog.IsOpen() )
	{
		aLog.Seek( STREAM_SEEK_TO_END );
		String aEntry( (long) pThis );
		aEntry += "(row=";
		aEntry += pThis->GetCurRow();
		aEntry += "): ";
		aEntry += pWhat;
		aEntry += " from ";
		aEntry += pWho;
		aEntry += " => ";
		aEntry += pThis->GetCursorHideCount();
		aLog.WriteLine( aEntry );
	}
}
#endif

namespace
{
	void disposeAndClearHeaderCell(::svt::BrowseBoxImpl::THeaderCellMap& _rHeaderCell)
	{
		::std::for_each(
						_rHeaderCell.begin(),
						_rHeaderCell.end(),
						::svt::BrowseBoxImpl::THeaderCellMapFunctorDispose()
							);
		_rHeaderCell.clear();
	}
}

//===================================================================

void BrowseBox::ConstructImpl( BrowserMode nMode )
{
	DBG_TRACE1( "BrowseBox: %p->ConstructImpl", this );
	bMultiSelection = sal_False;
	pColSel = 0;
	pDataWin = 0;
	pVScroll = 0;

	pDataWin = new BrowserDataWin( this );
	pCols = new BrowserColumns;
	m_pImpl.reset( new ::svt::BrowseBoxImpl() );

	aGridLineColor = Color( COL_LIGHTGRAY );
	InitSettings_Impl( this );
	InitSettings_Impl( pDataWin );

	bBootstrapped = sal_False;
	nDataRowHeight = 0;
	nTitleLines = 1;
	nFirstCol = 0;
	nTopRow = 0;
	nCurRow = BROWSER_ENDOFSELECTION;
	nCurColId = 0;
	bResizing = sal_False;
	bSelect = sal_False;
	bSelecting = sal_False;
	bScrolling = sal_False;
	bSelectionIsVisible = sal_False;
	bNotToggleSel = sal_False;
	bRowDividerDrag = sal_False;
	bHit = sal_False;
	mbInteractiveRowHeight = sal_False;
	bHideSelect = sal_False;
	bHideCursor = NO_CURSOR_HIDE;
	nRowCount = 0;
	m_bFocusOnlyCursor = sal_True;
	m_aCursorColor = COL_TRANSPARENT;
	m_nCurrentMode = 0;
    nControlAreaWidth = USHRT_MAX;
	uRow.nSel = BROWSER_ENDOFSELECTION;

	aHScroll.SetLineSize(1);
	aHScroll.SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
	aHScroll.SetEndScrollHdl( LINK( this, BrowseBox, EndScrollHdl ) );
	pDataWin->Show();

	SetMode( nMode );
	bSelectionIsVisible = bKeepHighlight;
	bHasFocus = HasChildPathFocus();
	getDataWindow()->nCursorHidden =
				( bHasFocus ? 0 : 1 ) + ( GetUpdateMode() ? 0 : 1 );
	LOG( this, "ConstructImpl", "*" );
}

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

BrowseBox::BrowseBox( Window* pParent, WinBits nBits, BrowserMode nMode )
	:Control( pParent, nBits | WB_3DLOOK )
	,DragSourceHelper( this )
	,DropTargetHelper( this )
	,aHScroll( this, WinBits( WB_HSCROLL ) )
{
	DBG_CTOR( BrowseBox, NULL );
	ConstructImpl( nMode );
}

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

BrowseBox::BrowseBox( Window* pParent, const ResId& rId, BrowserMode nMode )
	:Control( pParent, rId )
	,DragSourceHelper( this )
	,DropTargetHelper( this )
	,aHScroll( this, WinBits(WB_HSCROLL) )
{
	DBG_CTOR( BrowseBox, NULL );
	ConstructImpl(nMode);
}
//-------------------------------------------------------------------

BrowseBox::~BrowseBox()
{
	DBG_DTOR(BrowseBox,BrowseBoxCheckInvariants);
	DBG_TRACE1( "BrowseBox: %p~", this );

	if ( m_pImpl->m_pAccessible )
	{
		disposeAndClearHeaderCell(m_pImpl->m_aColHeaderCellMap);
		disposeAndClearHeaderCell(m_pImpl->m_aRowHeaderCellMap);
		m_pImpl->m_pAccessible->dispose();
	}

	Hide();
	delete getDataWindow()->pHeaderBar;
	delete getDataWindow()->pCornerWin;
	delete pDataWin;
	delete pVScroll;

	// free columns-space
	for ( sal_uInt16 n = 0; n < pCols->Count(); ++n )
		delete pCols->GetObject(n);
	delete pCols;
	delete pColSel;
	if ( bMultiSelection )
		delete uRow.pSel;
}

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

short BrowseBox::GetCursorHideCount() const
{
	return getDataWindow()->nCursorHidden;
}

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

void BrowseBox::DoShowCursor( const char *
#ifdef DBG_MI
pWhoLogs
#endif
)
{
	short nHiddenCount = --getDataWindow()->nCursorHidden;
	if (PaintCursorIfHiddenOnce())
	{
		if (1 == nHiddenCount)
			DrawCursor();
	}
	else
	{
		if (0 == nHiddenCount)
			DrawCursor();
	}
	LOG( this, "DoShowCursor", pWhoLogs );
}

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

void BrowseBox::DoHideCursor( const char *
#ifdef DBG_MI
pWhoLogs
#endif
)
{
	short nHiddenCount = ++getDataWindow()->nCursorHidden;
	if (PaintCursorIfHiddenOnce())
	{
		if (2 == nHiddenCount)
			DrawCursor();
	}
	else
	{
		if (1 == nHiddenCount)
			DrawCursor();
	}
	LOG( this, "DoHideCursor", pWhoLogs );
}

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

void BrowseBox::SetRealRowCount( const String &rRealRowCount )
{
	getDataWindow()->aRealRowCount = rRealRowCount;
}

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

void BrowseBox::SetFont( const Font& rNewFont )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);
	pDataWin->SetFont( rNewFont );
	ImpGetDataRowHeight();
}

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

sal_uLong BrowseBox::GetDefaultColumnWidth( const String& _rText ) const
{
	return GetDataWindow().GetTextWidth( _rText ) + GetDataWindow().GetTextWidth( '0' ) * 4;
}

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

void BrowseBox::InsertHandleColumn( sal_uLong nWidth )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	pCols->Insert( new BrowserColumn( 0, Image(), String(), nWidth, GetZoom(), 0 ), (sal_uLong) 0 );
	FreezeColumn( 0 );

	// Headerbar anpassen
	if ( getDataWindow()->pHeaderBar )
	{
		getDataWindow()->pHeaderBar->SetPosSizePixel(
					Point(nWidth, 0),
                    Size( GetOutputSizePixel().Width() - nWidth, GetTitleHeight() )
                    );
	}

	/*if ( getDataWindow()->pHeaderBar )
		getDataWindow()->pHeaderBar->InsertItem( USHRT_MAX - 1,
				"", nWidth, HIB_FIXEDPOS|HIB_FIXED, 0 );*/
	ColumnInserted( 0 );
}

//-------------------------------------------------------------------
void BrowseBox::InsertDataColumn( sal_uInt16 nItemId, const Image& rImage,
		long nWidth, HeaderBarItemBits nBits, sal_uInt16 nPos )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	pCols->Insert( new BrowserColumn( nItemId, rImage, String(), nWidth, GetZoom(), nBits ),
						   Min( nPos, (sal_uInt16)(pCols->Count()) ) );
	if ( nCurColId == 0 )
		nCurColId = nItemId;
	if ( getDataWindow()->pHeaderBar )
	{
		// Handlecolumn nicht in der Headerbar
		sal_uInt16 nHeaderPos = nPos;
		if (nHeaderPos != HEADERBAR_APPEND && !GetColumnId(0))
			nHeaderPos--;
		getDataWindow()->pHeaderBar->InsertItem(
				nItemId, rImage, nWidth, nBits, nHeaderPos );
	}
	ColumnInserted( nPos );
}

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

void BrowseBox::InsertDataColumn( sal_uInt16 nItemId, const XubString& rText,
		long nWidth, HeaderBarItemBits nBits, sal_uInt16 nPos )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	pCols->Insert( new BrowserColumn( nItemId, Image(), rText, nWidth, GetZoom(), nBits ),
						   Min( nPos, (sal_uInt16)(pCols->Count()) ) );
	if ( nCurColId == 0 )
		nCurColId = nItemId;

	if ( getDataWindow()->pHeaderBar )
	{
		// Handlecolumn nicht in der Headerbar
		sal_uInt16 nHeaderPos = nPos;
		if (nHeaderPos != HEADERBAR_APPEND && !GetColumnId(0))
			nHeaderPos--;
		getDataWindow()->pHeaderBar->InsertItem(
				nItemId, rText, nWidth, nBits, nHeaderPos );
	}
	ColumnInserted( nPos );
}

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

void BrowseBox::InsertDataColumn( sal_uInt16 nItemId,
		const Image& rImage, const XubString& rText,
		long nWidth, HeaderBarItemBits nBits, sal_uInt16 nPos,
		const String* pHelpText )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	pCols->Insert( new BrowserColumn( nItemId, rImage, rText, nWidth, GetZoom(), nBits ),
						   Min( nPos, (sal_uInt16)(pCols->Count()) ) );
	if ( nCurColId == 0 )
		nCurColId = nItemId;
	if ( getDataWindow()->pHeaderBar )
	{
		// Handlecolumn nicht in der Headerbar
		sal_uInt16 nHeaderPos = nPos;
		if (nHeaderPos != HEADERBAR_APPEND && !GetColumnId(0))
			nHeaderPos--;

		getDataWindow()->pHeaderBar->InsertItem(
				nItemId, rImage, rText, nWidth, nBits, nHeaderPos );
		if( pHelpText && !rText.Len() )
		{
			getDataWindow()->pHeaderBar->SetHelpText(
				nItemId, *pHelpText );
		}
	}
	ColumnInserted( nPos );
}
//-------------------------------------------------------------------
sal_uInt16 BrowseBox::ToggleSelectedColumn()
{
	sal_uInt16 nSelectedColId = USHRT_MAX;
	if ( pColSel && pColSel->GetSelectCount() )
	{
		DoHideCursor( "ToggleSelectedColumn" );
		ToggleSelection();
		nSelectedColId = pCols->GetObject(pColSel->FirstSelected())->GetId();
		pColSel->SelectAll(sal_False);
	}
	return nSelectedColId;
}
// -----------------------------------------------------------------------------
void BrowseBox::SetToggledSelectedColumn(sal_uInt16 _nSelectedColumnId)
{
	if ( pColSel && _nSelectedColumnId != USHRT_MAX )
	{
		pColSel->Select( GetColumnPos( _nSelectedColumnId ) );
		ToggleSelection();
		DBG_TRACE1( "BrowseBox: %p->SetToggledSelectedColumn", this );
		DoShowCursor( "SetToggledSelectedColumn" );
	}
}
// -----------------------------------------------------------------------------
void BrowseBox::FreezeColumn( sal_uInt16 nItemId, sal_Bool bFreeze )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// never unfreeze the handle-column
	if ( nItemId == 0 && !bFreeze )
		return;

	// get the position in the current array
	sal_uInt16 nItemPos = GetColumnPos( nItemId );
	if ( nItemPos >= pCols->Count() )
		// not available!
		return;

	// doesn't the state change?
	if ( pCols->GetObject(nItemPos)->IsFrozen() == bFreeze )
		return;

	// remark the column selection
	sal_uInt16 nSelectedColId = ToggleSelectedColumn();

	// freeze or unfreeze?
	if ( bFreeze )
	{
		// to be moved?
		if ( nItemPos != 0 && !pCols->GetObject(nItemPos-1)->IsFrozen() )
		{
			// move to the right of the last frozen column
			sal_uInt16 nFirstScrollable = FrozenColCount();
			BrowserColumn *pColumn = pCols->GetObject(nItemPos);
			pCols->Remove( (sal_uLong) nItemPos );
			nItemPos = nFirstScrollable;
			pCols->Insert( pColumn, (sal_uLong) nItemPos );
		}

		// adjust the number of the first scrollable and visible column
		if ( nFirstCol <= nItemPos )
			nFirstCol = nItemPos + 1;
	}
	else
	{
		// to be moved?
		if ( nItemPos != FrozenColCount()-1 )
		{
			// move to the leftmost scrollable column
			sal_uInt16 nFirstScrollable = FrozenColCount();
			BrowserColumn *pColumn = pCols->GetObject(nItemPos);
			pCols->Remove( (sal_uLong) nItemPos );
			nItemPos = nFirstScrollable;
			pCols->Insert( pColumn, (sal_uLong) nItemPos );
		}

		// adjust the number of the first scrollable and visible column
		nFirstCol = nItemPos;
	}

	// toggle the freeze-state of the column
	pCols->GetObject(nItemPos)->Freeze( bFreeze );

	// align the scrollbar-range
	UpdateScrollbars();

	// repaint
	Control::Invalidate();
	getDataWindow()->Invalidate();

	// remember the column selection
	SetToggledSelectedColumn(nSelectedColId);
}

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

void BrowseBox::SetColumnPos( sal_uInt16 nColumnId, sal_uInt16 nPos )
{
	// never set pos of the handle-column
	if ( nColumnId == 0 )
		return;

	// do not move handle column
	if (nPos == 0 && !pCols->GetObject(0)->GetId())
		return;

	// get the position in the current array
	sal_uInt16 nOldPos = GetColumnPos( nColumnId );
	if ( nOldPos >= pCols->Count() )
		// not available!
		return;

	// does the state change?
	if (nOldPos != nPos)
	{
		// remark the column selection
		sal_uInt16 nSelectedColId = ToggleSelectedColumn();

		// determine old column area
		Size aDataWinSize( pDataWin->GetSizePixel() );
		if ( getDataWindow()->pHeaderBar )
			aDataWinSize.Height() += getDataWindow()->pHeaderBar->GetSizePixel().Height();

		Rectangle aFromRect( GetFieldRect( nColumnId) );
		aFromRect.Right() += 2*MIN_COLUMNWIDTH;

		sal_uInt16 nNextPos = nOldPos + 1;
		if ( nOldPos > nPos )
			nNextPos = nOldPos - 1;

		BrowserColumn *pNextCol = pCols->GetObject(nNextPos);
		Rectangle aNextRect(GetFieldRect( pNextCol->GetId() ));

		// move column internally
		pCols->Insert( pCols->Remove( nOldPos ), nPos );

		// determine new column area
		Rectangle aToRect( GetFieldRect( nColumnId ) );
		aToRect.Right() += 2*MIN_COLUMNWIDTH;

		// do scroll, let redraw
		if( pDataWin->GetBackground().IsScrollable() )
		{
			long nScroll = -aFromRect.GetWidth();
			Rectangle aScrollArea;
			if ( nOldPos > nPos )
			{
				long nFrozenWidth = GetFrozenWidth();
				if ( aToRect.Left() < nFrozenWidth )
					aToRect.Left() = nFrozenWidth;
				aScrollArea = Rectangle(Point(aToRect.Left(),0),
									    Point(aNextRect.Right(),aDataWinSize.Height()));
				nScroll *= -1; // reverse direction
			}
			else
				aScrollArea = Rectangle(Point(aNextRect.Left(),0),
									    Point(aToRect.Right(),aDataWinSize.Height()));

			pDataWin->Scroll( nScroll, 0, aScrollArea );
			aToRect.Top() = 0;
			aToRect.Bottom() = aScrollArea.Bottom();
			Invalidate( aToRect );
		}
		else
			pDataWin->Window::Invalidate( INVALIDATE_NOCHILDREN );

		// adjust header bar positions
		if ( getDataWindow()->pHeaderBar )
		{
			sal_uInt16 nNewPos = nPos;
			if ( !GetColumnId(0) )
				--nNewPos;
			getDataWindow()->pHeaderBar->MoveItem(nColumnId,nNewPos);
		}
		// remember the column selection
		SetToggledSelectedColumn(nSelectedColId);

        if ( isAccessibleAlive() )
		{
			commitTableEvent(
                TABLE_MODEL_CHANGED,
				makeAny( AccessibleTableModelChange(
                            DELETE,
							0,
							GetRowCount(),
							nOldPos,
							nOldPos
                        )
                ),
                Any()
            );

			commitTableEvent(
                TABLE_MODEL_CHANGED,
			    makeAny( AccessibleTableModelChange(
                            INSERT,
							0,
							GetRowCount(),
							nPos,
							nPos
                        )
                ),
				Any()
            );
		}
	}

}

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

void BrowseBox::SetColumnMode( sal_uInt16 nColumnId, BrowserColumnMode nFlags )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// never set mode of the handle-column
	if ( nColumnId == 0 )
		return;

	// get the position in the current array
	sal_uInt16 nColumnPos = GetColumnPos( nColumnId );
	if ( nColumnPos >= pCols->Count() )
		// not available!
		return;

	// does the state change?
	BrowserColumn *pCol = pCols->GetObject(nColumnPos);
	if ( pCol->Flags() != nFlags )
	{
		pCol->Flags() = sal::static_int_cast< HeaderBarItemBits >(nFlags);

		// redraw visible colums
		if ( GetUpdateMode() && ( pCol->IsFrozen() || nColumnPos > nFirstCol ) )
			Invalidate( Rectangle( Point(0,0),
				Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
	}
}

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

void BrowseBox::SetColumnTitle( sal_uInt16 nItemId, const String& rTitle )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// never set title of the handle-column
	if ( nItemId == 0 )
		return;

	// get the position in the current array
	sal_uInt16 nItemPos = GetColumnPos( nItemId );
	if ( nItemPos >= pCols->Count() )
		// not available!
		return;

	// does the state change?
	BrowserColumn *pCol = pCols->GetObject(nItemPos);
	if ( pCol->Title() != rTitle )
	{
		::rtl::OUString sNew(rTitle);
		::rtl::OUString sOld(pCol->Title());

		pCol->Title() = rTitle;

		// Headerbar-Column anpassen
		if ( getDataWindow()->pHeaderBar )
			getDataWindow()->pHeaderBar->SetItemText(
					nItemId ? nItemId : USHRT_MAX - 1, rTitle );
		else
		{
			// redraw visible colums
			if ( GetUpdateMode() && ( pCol->IsFrozen() || nItemPos > nFirstCol ) )
				Invalidate( Rectangle( Point(0,0),
					Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
		}

        if ( isAccessibleAlive() )
		{
			commitTableEvent(	TABLE_COLUMN_DESCRIPTION_CHANGED,
			    makeAny( sNew ),
			    makeAny( sOld )
            );
		}
	}
}

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

void BrowseBox::SetColumnWidth( sal_uInt16 nItemId, sal_uLong nWidth )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// get the position in the current array
	sal_uInt16 nItemPos = GetColumnPos( nItemId );
	if ( nItemPos >= pCols->Count() )
		return;

	// does the state change?
	nWidth = QueryColumnResize( nItemId, nWidth );
	if ( nWidth >= LONG_MAX || pCols->GetObject(nItemPos)->Width() != nWidth )
	{
		long nOldWidth = pCols->GetObject(nItemPos)->Width();

		// ggf. letzte Spalte anpassen
		if ( IsVisible() && nItemPos == pCols->Count() - 1 )
		{
			long nMaxWidth = pDataWin->GetSizePixel().Width();
			nMaxWidth -= getDataWindow()->bAutoSizeLastCol
					? GetFieldRect(nItemId).Left()
					: GetFrozenWidth();
			if ( ( (BrowserDataWin*)pDataWin )->bAutoSizeLastCol || nWidth > (sal_uLong)nMaxWidth )
			{
				nWidth = nMaxWidth > 16 ? nMaxWidth : nOldWidth;
				nWidth = QueryColumnResize( nItemId, nWidth );
			}
		}

		// OV
		// In AutoSizeLastColumn() wird SetColumnWidth mit nWidth==0xffff
		// gerufen. Deshalb muss hier nochmal geprueft werden, ob sich die
		// Breite tatsaechlich geaendert hat.
		if( (sal_uLong)nOldWidth == nWidth )
			return;

		// soll die Aenderung sofort dargestellt werden?
		sal_Bool bUpdate = GetUpdateMode() &&
					   ( pCols->GetObject(nItemPos)->IsFrozen() || nItemPos >= nFirstCol );

		if ( bUpdate )
		{
			// Selection hiden
			DoHideCursor( "SetColumnWidth" );
			ToggleSelection();
			//!getDataWindow()->Update();
			//!Control::Update();
		}

		// Breite setzen
		pCols->GetObject(nItemPos)->SetWidth(nWidth, GetZoom());
#if 0
		if ( nItemPos != pCols->Count() - 1 )
		{
			long nLastColMaxWidth = pDataWin->GetSizePixel().Width() -
						GetFieldRect(GetColumnId(pCols->Count()-1)).Left();
			pCols->GetObject(pCols->Count()-1)->Width() = nLastColMaxWidth;
		}
#endif

		// scroll and invalidate
		if ( bUpdate )
		{
			// X-Pos der veraenderten Spalte ermitteln
			long nX = 0;
			for ( sal_uInt16 nCol = 0; nCol < nItemPos; ++nCol )
			{
				BrowserColumn *pCol = pCols->GetObject(nCol);
				if ( pCol->IsFrozen() || nCol >= nFirstCol )
					nX += pCol->Width();
			}

			// eigentliches scroll+invalidate
			pDataWin->SetClipRegion();
			sal_Bool bSelVis = bSelectionIsVisible;
			bSelectionIsVisible = sal_False;
			if( GetBackground().IsScrollable() )
			{

				Rectangle aScrRect( nX + std::min( (sal_uLong)nOldWidth, nWidth ), 0,
									GetSizePixel().Width() , // the header is longer than the datawin
									pDataWin->GetPosPixel().Y() - 1 );
				Control::Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
				aScrRect.Bottom() = pDataWin->GetSizePixel().Height();
				getDataWindow()->Scroll( nWidth-nOldWidth, 0, aScrRect, SCROLL_FLAGS );
				Rectangle aInvRect( nX, 0, nX + std::max( nWidth, (sal_uLong)nOldWidth ), USHRT_MAX );
				Control::Invalidate( aInvRect, INVALIDATE_NOCHILDREN );
				( (BrowserDataWin*)pDataWin )->Invalidate( aInvRect );
			}
			else
			{
				Control::Invalidate( INVALIDATE_NOCHILDREN );
				getDataWindow()->Window::Invalidate( INVALIDATE_NOCHILDREN );
			}


			//!getDataWindow()->Update();
			//!Control::Update();
			bSelectionIsVisible = bSelVis;
			ToggleSelection();
			DoShowCursor( "SetColumnWidth" );
		}
		UpdateScrollbars();

		// Headerbar-Column anpassen
		if ( getDataWindow()->pHeaderBar )
			getDataWindow()->pHeaderBar->SetItemSize(
					nItemId ? nItemId : USHRT_MAX - 1, nWidth );

		// adjust last column
		if ( nItemPos != pCols->Count() - 1 )
			AutoSizeLastColumn();

	}
}

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

void BrowseBox::AutoSizeLastColumn()
{
	if ( getDataWindow()->bAutoSizeLastCol &&
		 getDataWindow()->GetUpdateMode() )
	{
		sal_uInt16 nId = GetColumnId( (sal_uInt16)pCols->Count() - 1 );
		SetColumnWidth( nId, LONG_MAX );
		ColumnResized( nId );
	}
}

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

void BrowseBox::RemoveColumn( sal_uInt16 nItemId )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// Spaltenposition ermitteln
	sal_uInt16 nPos = GetColumnPos(nItemId);
	if ( nPos >= ColCount() )
		// nicht vorhanden
		return;

	// Spaltenselektion korrigieren
	if ( pColSel )
		pColSel->Remove( nPos );

	// Spaltencursor korrigieren
	if ( nCurColId == nItemId )
		nCurColId = 0;

	// Spalte entfernen
	delete( pCols->Remove( (sal_uLong) nPos ));
	// OJ #93534#
	if ( nFirstCol >= nPos && nFirstCol > FrozenColCount() )
	{
		OSL_ENSURE(nFirstCol > 0,"FirstCol must be greater zero!");
		--nFirstCol;
	}

	// Handlecolumn nicht in der Headerbar
	if (nItemId)
	{
		if ( getDataWindow()->pHeaderBar )
			getDataWindow()->pHeaderBar->RemoveItem( nItemId );
	}
	else
	{
		// Headerbar anpassen
		if ( getDataWindow()->pHeaderBar )
		{
			getDataWindow()->pHeaderBar->SetPosSizePixel(
						Point(0, 0),
                        Size( GetOutputSizePixel().Width(), GetTitleHeight() )
                        );
		}
	}

	// vertikalen Scrollbar korrigieren
	UpdateScrollbars();

	// ggf. Repaint ausl"osen
	if ( GetUpdateMode() )
	{
		getDataWindow()->Invalidate();
		Control::Invalidate();
		if ( getDataWindow()->bAutoSizeLastCol && nPos ==ColCount() )
			SetColumnWidth( GetColumnId( nPos - 1 ), LONG_MAX );
	}

    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            TABLE_MODEL_CHANGED,
			makeAny( AccessibleTableModelChange(	DELETE,
													0,
													GetRowCount(),
													nPos,
													nPos
                                               )
            ),
            Any()
        );

		commitHeaderBarEvent(
            CHILD,
			Any(),
			makeAny( CreateAccessibleColumnHeader( nPos ) ),
            sal_True
        );
	}
}

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

void BrowseBox::RemoveColumns()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	unsigned int nOldCount = pCols->Count();
	// alle Spalten entfernen
	while ( pCols->Count() )
		delete ( pCols->Remove( (sal_uLong) 0 ));

	// Spaltenselektion korrigieren
	if ( pColSel )
	{
		pColSel->SelectAll(sal_False);
		pColSel->SetTotalRange( Range( 0, 0 ) );
	}

	// Spaltencursor korrigieren
	nCurColId = 0;
	nFirstCol = 0;

	if ( getDataWindow()->pHeaderBar )
		getDataWindow()->pHeaderBar->Clear( );

	// vertikalen Scrollbar korrigieren
	UpdateScrollbars();

	// ggf. Repaint ausl"osen
	if ( GetUpdateMode() )
	{
		getDataWindow()->Invalidate();
		Control::Invalidate();
	}

    if ( isAccessibleAlive() )
	{
        if ( pCols->Count() != nOldCount )
        {
		    // all columns should be removed, so we remove the column header bar and append it again
		    // to avoid to notify every column remove
		    commitBrowseBoxEvent(
                CHILD,
                Any(),
                makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_COLUMNHEADERBAR))
            );

            // and now append it again
		    commitBrowseBoxEvent(
                CHILD,
				makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_COLUMNHEADERBAR)),
				Any()
            );

            // notify a table model change
            commitTableEvent(
                TABLE_MODEL_CHANGED,
				makeAny ( AccessibleTableModelChange( DELETE,
                                0,
					            GetRowCount(),
					            0,
					            nOldCount
                            )
                        ),
				Any()
            );
        }
	}
}

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

String BrowseBox::GetColumnTitle( sal_uInt16 nId ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	sal_uInt16 nItemPos = GetColumnPos( nId );
	if ( nItemPos >= pCols->Count() )
		return String();
	return pCols->GetObject(nItemPos)->Title();
}

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

long BrowseBox::GetRowCount() const
{
	return nRowCount;
}

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

sal_uInt16 BrowseBox::ColCount() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return (sal_uInt16) pCols->Count();
}

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

long BrowseBox::ImpGetDataRowHeight() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	BrowseBox *pThis = (BrowseBox*)this;
	pThis->nDataRowHeight = pThis->CalcReverseZoom(pDataWin->GetTextHeight() + 2);
	pThis->Resize();
	getDataWindow()->Invalidate();
	return nDataRowHeight;
}

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

void BrowseBox::SetDataRowHeight( long nPixel )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	nDataRowHeight = CalcReverseZoom(nPixel);
	Resize();
	getDataWindow()->Invalidate();
}

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

void BrowseBox::SetTitleLines( sal_uInt16 nLines )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	nTitleLines = nLines;
}

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

long BrowseBox::ScrollColumns( long nCols )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( nFirstCol + nCols < 0 ||
		 nFirstCol + nCols >= (long)pCols->Count() )
		 //?MI: pCols->GetObject( nFirstCol + nCols )->IsFrozen() )
		return 0;

	// implicitly hides cursor while scrolling
	StartScroll();
	bScrolling = sal_True;
	sal_Bool bScrollable = pDataWin->GetBackground().IsScrollable();
	sal_Bool bInvalidateView = sal_False;

	// scrolling one column to the right?
	if ( nCols == 1 )
	{
		// update internal value and scrollbar
		++nFirstCol;
		aHScroll.SetThumbPos( nFirstCol - FrozenColCount() );

		if ( !bScrollable )
        {
            bInvalidateView = sal_True;
        }
        else
        {
		    long nDelta = pCols->GetObject(nFirstCol-1)->Width();
		    long nFrozenWidth = GetFrozenWidth();

            Rectangle aScrollRect(  Point( nFrozenWidth + nDelta, 0 ),
                                    Size ( GetOutputSizePixel().Width() - nFrozenWidth - nDelta,
                                           GetTitleHeight() - 1
                                         ) );

		    // scroll the header bar area (if there is no dedicated HeaderBar control)
		    if ( !getDataWindow()->pHeaderBar && nTitleLines )
		    {
                // actually scroll
                Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );

                // invalidate the area of the column which was scrolled out to the left hand side
                Rectangle aInvalidateRect( aScrollRect );
                aInvalidateRect.Left() = nFrozenWidth;
                aInvalidateRect.Right() = nFrozenWidth + nDelta - 1;
                Invalidate( aInvalidateRect );
		    }

		    // scroll the data-area
            aScrollRect.Bottom() = pDataWin->GetOutputSizePixel().Height();

            // actually scroll
		    pDataWin->Scroll( -nDelta, 0, aScrollRect, SCROLL_FLAGS );

            // invalidate the area of the column which was scrolled out to the left hand side
	        aScrollRect.Left() = nFrozenWidth;
	        aScrollRect.Right() = nFrozenWidth + nDelta - 1;
	        getDataWindow()->Invalidate( aScrollRect );
        }
	}

	// scrolling one column to the left?
	else if ( nCols == -1 )
	{
		--nFirstCol;
		aHScroll.SetThumbPos( nFirstCol - FrozenColCount() );

		if ( !bScrollable )
		{
			bInvalidateView = sal_True;
        }
        else
        {
		    long nDelta = pCols->GetObject(nFirstCol)->Width();
		    long nFrozenWidth = GetFrozenWidth();

            Rectangle aScrollRect(  Point(  nFrozenWidth, 0 ),
			                        Size (  GetOutputSizePixel().Width() - nFrozenWidth,
				                            GetTitleHeight() - 1
                                         ) );

		    // scroll the header bar area (if there is no dedicated HeaderBar control)
		    if ( !getDataWindow()->pHeaderBar && nTitleLines )
		    {
			    Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
		    }

		    // scroll the data-area
            aScrollRect.Bottom() = pDataWin->GetOutputSizePixel().Height();
		    pDataWin->Scroll( nDelta, 0, aScrollRect, SCROLL_FLAGS );
        }
	}
	else
	{
		if ( GetUpdateMode() )
		{
			Invalidate( Rectangle(
				Point( GetFrozenWidth(), 0 ),
				Size( GetOutputSizePixel().Width(), GetTitleHeight() ) ) );
			getDataWindow()->Invalidate( Rectangle(
				Point( GetFrozenWidth(), 0 ),
				pDataWin->GetSizePixel() ) );
		}

		nFirstCol = nFirstCol + (sal_uInt16)nCols;
		aHScroll.SetThumbPos( nFirstCol - FrozenColCount() );
	}

	// ggf. externe Headerbar anpassen
	if ( getDataWindow()->pHeaderBar )
	{
		long nWidth = 0;
		for ( sal_uInt16 nCol = 0;
			  nCol < pCols->Count() && nCol < nFirstCol;
			  ++nCol )
		{
			// HandleColumn nicht
			if ( pCols->GetObject(nCol)->GetId() )
				nWidth += pCols->GetObject(nCol)->Width();
		}

		getDataWindow()->pHeaderBar->SetOffset( nWidth );
	}

	if( bInvalidateView )
	{
		Control::Invalidate( INVALIDATE_NOCHILDREN );
		pDataWin->Window::Invalidate( INVALIDATE_NOCHILDREN );
	}

	// implicitly show cursor after scrolling
	if ( nCols )
	{
		getDataWindow()->Update();
		Update();
	}
	bScrolling = sal_False;
	EndScroll();

	return nCols;
}

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

long BrowseBox::ScrollRows( long nRows )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// out of range?
	if ( getDataWindow()->bNoScrollBack && nRows < 0 )
		return 0;

	// compute new top row
	long nTmpMin = Min( (long)(nTopRow + nRows), (long)(nRowCount - 1) );

	long nNewTopRow = Max( (long)nTmpMin, (long)0 );

	if ( nNewTopRow == nTopRow )
		return 0;

	sal_uInt16 nVisibleRows =
		(sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);

	VisibleRowsChanged(nNewTopRow, nVisibleRows);

	// compute new top row again (nTopRow might have changed!)
	nTmpMin = Min( (long)(nTopRow + nRows), (long)(nRowCount - 1) );

	nNewTopRow = Max( (long)nTmpMin, (long)0 );

	StartScroll();

	// scroll area on screen and/or repaint
	long nDeltaY = GetDataRowHeight() * ( nNewTopRow - nTopRow );
	long nOldTopRow = nTopRow;
	nTopRow = nNewTopRow;

	if ( GetUpdateMode() )
	{
		pVScroll->SetRange( Range( 0L, nRowCount ) );
		pVScroll->SetThumbPos( nTopRow );

		if( pDataWin->GetBackground().IsScrollable() &&
			Abs( nDeltaY ) > 0 &&
			Abs( nDeltaY ) < pDataWin->GetSizePixel().Height() )
		{
			pDataWin->Scroll( 0, (short)-nDeltaY, SCROLL_FLAGS );
		}
		else
			getDataWindow()->Invalidate();

		if ( nTopRow - nOldTopRow )
			getDataWindow()->Update();
	}

	EndScroll();

	return nTopRow - nOldTopRow;
}

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

long BrowseBox::ScrollPages( long )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return ScrollRows( pDataWin->GetSizePixel().Height() / GetDataRowHeight() );
}

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

void BrowseBox::RowModified( long nRow, sal_uInt16 nColId )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( !GetUpdateMode() )
		return;

	Rectangle aRect;
	if ( nColId == USHRT_MAX )
		// invalidate the whole row
		aRect = Rectangle( Point( 0, (nRow-nTopRow) * GetDataRowHeight() ),
					Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
	else
	{
		// invalidate the specific field
		aRect = GetFieldRectPixel( nRow, nColId, sal_False );
	}
	getDataWindow()->Invalidate( aRect );
}

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

void BrowseBox::Clear()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// adjust the total number of rows
	DoHideCursor( "Clear" );
	long nOldRowCount = nRowCount;
	nRowCount = 0;
	nCurRow = BROWSER_ENDOFSELECTION;
	nTopRow = 0;
	nCurColId = 0;

	// nFirstCol darf nicht zurueckgesetzt werden, da ansonsten das Scrollen
	// total durcheinander kommt
	// nFirstCol darf nur beim Hinzufuegen oder Loeschen von Spalten geaendert werden
	// nFirstCol = 0; ->Falsch!!!!
	aHScroll.SetThumbPos( 0 );
	pVScroll->SetThumbPos( 0 );

	Invalidate();
	UpdateScrollbars();
	SetNoSelection();
	DoShowCursor( "Clear" );
	CursorMoved();

    if ( isAccessibleAlive() )
	{
		// all rows should be removed, so we remove the row header bar and append it again
		// to avoid to notify every row remove
        if ( nOldRowCount != nRowCount )
        {
		    commitBrowseBoxEvent(
                CHILD,
				Any(),
				makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) )
            );

		    // and now append it again
		    commitBrowseBoxEvent(
                CHILD,
				makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) ),
				Any()
            );

            // notify a table model change
            commitTableEvent(
                TABLE_MODEL_CHANGED,
				makeAny( AccessibleTableModelChange( DELETE,
                    0,
					nOldRowCount,
					0,
					GetColumnCount())
                ),
				Any()
            );
        }
	}
}
// -----------------------------------------------------------------------------
void BrowseBox::RowInserted( long nRow, long nNumRows, sal_Bool bDoPaint, sal_Bool bKeepSelection )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if (nRow < 0)
		nRow = 0;
	else if (nRow > nRowCount) // maximal = nRowCount
		nRow = nRowCount;

	if ( nNumRows <= 0 )
		return;

#if 0
	// Zerlegung in einzelne RowInserted-Aufrufe:
	if (nNumRows > 1)
	{
		for (long i = 0; i < nNumRows; i++)
			RowInserted(nRow + i,1,bDoPaint);
		return;
	}
#endif

	// adjust total row count
	sal_Bool bLastRow = nRow >= nRowCount;
	nRowCount += nNumRows;

	DoHideCursor( "RowInserted" );

	// must we paint the new rows?
	long nOldCurRow = nCurRow;
	Size aSz = pDataWin->GetOutputSizePixel();
	if ( bDoPaint && nRow >= nTopRow &&
		 nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
	{
		long nY = (nRow-nTopRow) * GetDataRowHeight();
		if ( !bLastRow )
		{
			// scroll down the rows behind the new row
			pDataWin->SetClipRegion();
			if( pDataWin->GetBackground().IsScrollable() )
			{
				pDataWin->Scroll( 0, GetDataRowHeight() * nNumRows,
								Rectangle( Point( 0, nY ),
										Size( aSz.Width(), aSz.Height() - nY ) ),
								SCROLL_FLAGS );
			}
			else
				pDataWin->Window::Invalidate( INVALIDATE_NOCHILDREN );
		}
		else
			// scroll would cause a repaint, so we must explicitly invalidate
			pDataWin->Invalidate( Rectangle( Point( 0, nY ),
						 Size( aSz.Width(), nNumRows * GetDataRowHeight() ) ) );
	}

	// ggf. Top-Row korrigieren
	if ( nRow < nTopRow )
		nTopRow += nNumRows;

	// adjust the selection
	if ( bMultiSelection )
		uRow.pSel->Insert( nRow, nNumRows );
	else if ( uRow.nSel != BROWSER_ENDOFSELECTION && nRow <= uRow.nSel )
		uRow.nSel += nNumRows;

	// adjust the cursor
	if ( nCurRow == BROWSER_ENDOFSELECTION )
		GoToRow( 0, sal_False, bKeepSelection );
	else if ( nRow <= nCurRow )
		GoToRow( nCurRow += nNumRows, sal_False, bKeepSelection );

	// adjust the vertical scrollbar
	if ( bDoPaint )
	{
		UpdateScrollbars();
		AutoSizeLastColumn();
	}

	DoShowCursor( "RowInserted" );
	// notify accessible that rows were inserted
    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            TABLE_MODEL_CHANGED,
			makeAny( AccessibleTableModelChange(
                        INSERT,
						nRow,
						nRow + nNumRows,
						0,
						GetColumnCount()
                    )
            ),
			Any()
        );

		for (sal_Int32 i = nRow+1 ; i <= nRowCount ; ++i)
		{
			commitHeaderBarEvent(
                CHILD,
				makeAny( CreateAccessibleRowHeader( i ) ),
				Any(),
				sal_False
            );
		}
	}

	if ( nCurRow != nOldCurRow )
		CursorMoved();

	DBG_ASSERT(nRowCount > 0,"BrowseBox: nRowCount <= 0");
	DBG_ASSERT(nCurRow >= 0,"BrowseBox: nCurRow < 0");
	DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
}

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

void BrowseBox::RowRemoved( long nRow, long nNumRows, sal_Bool bDoPaint )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( nRow < 0 )
		nRow = 0;
	else if ( nRow >= nRowCount )
		nRow = nRowCount - 1;

	if ( nNumRows <= 0 )
		return;

	if ( nRowCount <= 0 )
		return;

	if ( bDoPaint )
	{
		// hide cursor and selection
		DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
		ToggleSelection();
		DoHideCursor( "RowRemoved" );
	}

	// adjust total row count
	nRowCount -= nNumRows;
	if (nRowCount < 0) nRowCount = 0;
	long nOldCurRow = nCurRow;

	// adjust the selection
	if ( bMultiSelection )
		// uRow.pSel->Remove( nRow, nNumRows );
		for ( long i = 0; i < nNumRows; i++ )
			uRow.pSel->Remove( nRow );
	else if ( nRow < uRow.nSel && uRow.nSel >= nNumRows )
		uRow.nSel -= nNumRows;
	else if ( nRow <= uRow.nSel )
		uRow.nSel = BROWSER_ENDOFSELECTION;

	// adjust the cursor
	if ( nRowCount == 0 )	// don't compare nRowCount with nNumRows as nNumRows already was subtracted from nRowCount
		nCurRow = BROWSER_ENDOFSELECTION;
	else if ( nRow < nCurRow )
	{
		nCurRow -= Min( nCurRow - nRow, nNumRows );
		// with the above nCurRow points a) to the first row after the removed block or b) to the same line
		// as before, but moved up nNumRows
		// case a) needs an additional correction if the last n lines were deleted, as 'the first row after the
		// removed block' is an invalid position then
		// FS - 09/28/99 - 68429
		if (nCurRow == nRowCount)
			--nCurRow;
	}
	else if( nRow == nCurRow && nCurRow == nRowCount )
		nCurRow = nRowCount-1;

	// is the deleted row visible?
	Size aSz = pDataWin->GetOutputSizePixel();
	if ( nRow >= nTopRow &&
		 nRow <= nTopRow + aSz.Height() / GetDataRowHeight() )
	{
		if ( bDoPaint )
		{
			// scroll up the rows behind the deleted row
			// if there are Rows behind
			if (nRow < nRowCount)
			{
				long nY = (nRow-nTopRow) * GetDataRowHeight();
				pDataWin->SetClipRegion();
				if( pDataWin->GetBackground().IsScrollable() )
				{
					pDataWin->Scroll( 0, - (short) GetDataRowHeight() * nNumRows,
						Rectangle( Point( 0, nY ), Size( aSz.Width(),
							aSz.Height() - nY + nNumRows*GetDataRowHeight() ) ),
							SCROLL_FLAGS );
				}
				else
					pDataWin->Window::Invalidate( INVALIDATE_NOCHILDREN );
			}
			else
			{
				// Repaint the Rect of the deleted row
				Rectangle aRect(
						Point( 0, (nRow-nTopRow)*GetDataRowHeight() ),
						Size( pDataWin->GetSizePixel().Width(),
							  nNumRows * GetDataRowHeight() ) );
				pDataWin->Invalidate( aRect );
			}
		}
	}
	// is the deleted row above of the visible area?
	else if ( nRow < nTopRow )
		nTopRow = nTopRow >= nNumRows ? nTopRow-nNumRows : 0;

	if ( bDoPaint )
	{
		// reshow cursor and selection
		ToggleSelection();
		DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );
		DoShowCursor( "RowRemoved" );

		// adjust the vertical scrollbar
		UpdateScrollbars();
		AutoSizeLastColumn();
	}

    if ( isAccessibleAlive() )
	{
		if ( nRowCount == 0 )
		{
			// all columns should be removed, so we remove the column header bar and append it again
			// to avoid to notify every column remove
			commitBrowseBoxEvent(
                CHILD,
				Any(),
				makeAny( m_pImpl->getAccessibleHeaderBar( BBTYPE_ROWHEADERBAR ) )
            );

            // and now append it again
			commitBrowseBoxEvent(
                CHILD,
				makeAny(m_pImpl->getAccessibleHeaderBar(BBTYPE_ROWHEADERBAR)),
				Any()
            );
			commitBrowseBoxEvent(
                CHILD,
				Any(),
				makeAny( m_pImpl->getAccessibleTable() )
            );

            // and now append it again
			commitBrowseBoxEvent(
                CHILD,
				makeAny( m_pImpl->getAccessibleTable() ),
				Any()
            );
		}
		else
		{
			commitTableEvent(
                TABLE_MODEL_CHANGED,
				makeAny( AccessibleTableModelChange(
                            DELETE,
							nRow,
							nRow + nNumRows,
							0,
							GetColumnCount()
                            )
                ),
				Any()
            );

            for (sal_Int32 i = nRow+1 ; i <= (nRow+nNumRows) ; ++i)
			{
				commitHeaderBarEvent(
                    CHILD,
					Any(),
					makeAny( CreateAccessibleRowHeader( i ) ),
                    sal_False
                );
			}
		}
	}

	if ( nOldCurRow != nCurRow )
		CursorMoved();

	DBG_ASSERT(nRowCount >= 0,"BrowseBox: nRowCount < 0");
	DBG_ASSERT(nCurRow >= 0 || nRowCount == 0,"BrowseBox: nCurRow < 0 && nRowCount != 0");
	DBG_ASSERT(nCurRow < nRowCount,"nCurRow >= nRowCount");
}

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

sal_Bool BrowseBox::GoToRow( long nRow)
{
	return GoToRow(nRow, sal_False, sal_False);
}

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

sal_Bool BrowseBox::GoToRowAndDoNotModifySelection( long nRow )
{
	return GoToRow( nRow, sal_False, sal_True );
}

//-------------------------------------------------------------------
sal_Bool BrowseBox::GoToRow( long nRow, sal_Bool bRowColMove, sal_Bool bKeepSelection )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	long nOldCurRow = nCurRow;

	// nothing to do?
	if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) )
		return sal_True;

	// out of range?
	if ( nRow < 0 || nRow >= nRowCount )
		return sal_False;

	// nicht erlaubt?
	if ( ( !bRowColMove && !IsCursorMoveAllowed( nRow, nCurColId ) ) )
		return sal_False;

	if ( getDataWindow()->bNoScrollBack && nRow < nTopRow )
		nRow = nTopRow;

	// compute the last visible row
	Size aSz( pDataWin->GetSizePixel() );
	sal_uInt16 nVisibleRows = sal_uInt16( aSz.Height() / GetDataRowHeight() - 1 );
	long nLastRow = nTopRow + nVisibleRows;

	// suspend Updates
	getDataWindow()->EnterUpdateLock();

	// ggf. altes Highlight weg
	if ( !bMultiSelection && !bKeepSelection )
		ToggleSelection();
	DoHideCursor( "GoToRow" );

	// must we scroll?
	sal_Bool bWasVisible = bSelectionIsVisible;
	if (! bMultiSelection)
	{
		if( !bKeepSelection )
			bSelectionIsVisible = sal_False;
	}
	if ( nRow < nTopRow )
		ScrollRows( nRow - nTopRow );
	else if ( nRow > nLastRow )
		ScrollRows( nRow - nLastRow );
	bSelectionIsVisible = bWasVisible;

	// adjust cursor (selection) and thumb
	if ( GetUpdateMode() )
		pVScroll->SetThumbPos( nTopRow );

	// relative positioning (because nCurRow might have changed in the meantime)!
	if (nCurRow != BROWSER_ENDOFSELECTION )
		nCurRow = nCurRow + (nRow - nOldCurRow);

	// make sure that the current position is valid
	if (nCurRow == BROWSER_ENDOFSELECTION && nRowCount > 0)
		nCurRow = 0;
	else if ( nCurRow >= nRowCount )
		nCurRow = nRowCount - 1;
	aSelRange = Range( nCurRow, nCurRow );

	// ggf. neues Highlight anzeigen
	if ( !bMultiSelection && !bKeepSelection )
		uRow.nSel = nRow;

	// resume Updates
	getDataWindow()->LeaveUpdateLock();

	// Cursor+Highlight
	if ( !bMultiSelection && !bKeepSelection)
		ToggleSelection();
	DoShowCursor( "GoToRow" );
	if ( !bRowColMove  && nOldCurRow != nCurRow )
		CursorMoved();

	if ( !bMultiSelection && !bKeepSelection )
	{
		if ( !bSelecting )
			Select();
		else
			bSelect = sal_True;
	}
	return sal_True;
}

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

sal_Bool BrowseBox::GoToColumnId( sal_uInt16 nColId)
{
	return GoToColumnId(nColId,sal_True,sal_False);
}


sal_Bool BrowseBox::GoToColumnId( sal_uInt16 nColId, sal_Bool bMakeVisible, sal_Bool bRowColMove)
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if (!bColumnCursor)
		return sal_False;

	// erlaubt?
	if (!bRowColMove && !IsCursorMoveAllowed( nCurRow, nColId ) )
		return sal_False;

	if ( nColId != nCurColId || (bMakeVisible && !IsFieldVisible(nCurRow, nColId, sal_True)))
	{
        sal_uInt16 nNewPos = GetColumnPos(nColId);
        BrowserColumn* pColumn = pCols->GetObject( nNewPos );
        DBG_ASSERT( pColumn, "no column object - invalid id?" );
        if ( !pColumn )
            return sal_False;

		DoHideCursor( "GoToColumnId" );
		nCurColId = nColId;

		sal_uInt16 nFirstPos = nFirstCol;
        sal_uInt16 nWidth = (sal_uInt16)pColumn->Width();
		sal_uInt16 nLastPos = GetColumnAtXPosPixel(
							pDataWin->GetSizePixel().Width()-nWidth, sal_False );
		sal_uInt16 nFrozen = FrozenColCount();
		if ( bMakeVisible && nLastPos &&
			 nNewPos >= nFrozen && ( nNewPos < nFirstPos || nNewPos > nLastPos ) )
		{
			if ( nNewPos < nFirstPos )
				ScrollColumns( nNewPos-nFirstPos );
			else if ( nNewPos > nLastPos )
				ScrollColumns( nNewPos-nLastPos );
		}

		DoShowCursor( "GoToColumnId" );
		if (!bRowColMove)
			CursorMoved();
		return sal_True;
	}
	return sal_True;
}

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

sal_Bool BrowseBox::GoToRowColumnId( long nRow, sal_uInt16 nColId )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// out of range?
	if ( nRow < 0 || nRow >= nRowCount )
		return sal_False;

	if (!bColumnCursor)
		return sal_False;

	// nothing to do ?
	if ( nRow == nCurRow && ( bMultiSelection || uRow.nSel == nRow ) &&
		 nColId == nCurColId && IsFieldVisible(nCurRow, nColId, sal_True))
		return sal_True;

	// erlaubt?
	if (!IsCursorMoveAllowed(nRow, nColId))
		return sal_False;

	DoHideCursor( "GoToRowColumnId" );
	sal_Bool bMoved = GoToRow(nRow, sal_True) && GoToColumnId(nColId, sal_True, sal_True);
	DoShowCursor( "GoToRowColumnId" );

	if (bMoved)
		CursorMoved();

	return bMoved;
}

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

void BrowseBox::SetNoSelection()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// is there no selection
	if ( ( !pColSel || !pColSel->GetSelectCount() ) &&
		 ( ( !bMultiSelection && uRow.nSel == BROWSER_ENDOFSELECTION ) ||
		   ( bMultiSelection && !uRow.pSel->GetSelectCount() ) ) )
		// nothing to do
		return;

	DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
	ToggleSelection();

	// unselect all
	if ( bMultiSelection )
		uRow.pSel->SelectAll(sal_False);
	else
		uRow.nSel = BROWSER_ENDOFSELECTION;
	if ( pColSel )
		pColSel->SelectAll(sal_False);
	if ( !bSelecting )
		Select();
	else
		bSelect = sal_True;

	// restore screen
	DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );

    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            SELECTION_CHANGED,
			Any(),
			Any()
        );
	}
}

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

void BrowseBox::SetSelection( const MultiSelection &rSel )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);
	DBG_ASSERT( bMultiSelection, "SetSelection only allowed with Multi-Selection-Mode" );

	// prepare inverted areas
	DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
	ToggleSelection();

	// assign Selection
	*uRow.pSel = rSel;

	// only highlight painted areas
	pDataWin->Update();

	// notify derived class
	if ( !bSelecting )
		Select();
	else
		bSelect = sal_True;

	// restore screen
	ToggleSelection();
	DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );

    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            SELECTION_CHANGED,
			Any(),
			Any()
        );
	}
}

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

void BrowseBox::SelectAll()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( !bMultiSelection )
		return;

	DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
	ToggleSelection();

	// select all rows
	if ( pColSel )
		pColSel->SelectAll(sal_False);
	uRow.pSel->SelectAll(sal_True);

	// Handle-Column nicht highlighten
	BrowserColumn *pFirstCol = pCols->GetObject(0);
	long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();

	// highlight the row selection
	if ( !bHideSelect )
	{
		Rectangle aHighlightRect;
		sal_uInt16 nVisibleRows =
			(sal_uInt16)(pDataWin->GetOutputSizePixel().Height() / GetDataRowHeight() + 1);
		for ( long nRow = Max( nTopRow, uRow.pSel->FirstSelected() );
			  nRow != BROWSER_ENDOFSELECTION && nRow < nTopRow + nVisibleRows;
			  nRow = uRow.pSel->NextSelected() )
			aHighlightRect.Union( Rectangle(
				Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
				Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) ) );
		pDataWin->Invalidate( aHighlightRect );
	}

	if ( !bSelecting )
		Select();
	else
		bSelect = sal_True;

	// restore screen
	DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );

    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            SELECTION_CHANGED,
			Any(),
			Any()
        );
		commitHeaderBarEvent(
            SELECTION_CHANGED,
			Any(),
			Any(),
			sal_True
        ); // column header event

        commitHeaderBarEvent(
            SELECTION_CHANGED,
			Any(),
			Any(),
			sal_False
        ); // row header event
	}
}

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

void BrowseBox::SelectRow( long nRow, sal_Bool _bSelect, sal_Bool bExpand )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( !bMultiSelection )
	{
		// deselecting is impossible, selecting via cursor
		if ( _bSelect )
			GoToRow(nRow, sal_False);
		return;
	}

	DBG_TRACE1( "BrowseBox: %p->HideCursor", this );

	// remove old selection?
	if ( !bExpand || !bMultiSelection )
	{
		ToggleSelection();
		if ( bMultiSelection )
			uRow.pSel->SelectAll(sal_False);
		else
			uRow.nSel = BROWSER_ENDOFSELECTION;
		if ( pColSel )
			pColSel->SelectAll(sal_False);
	}

	// set new selection
	if	(	!bHideSelect
		&&	(	(	bMultiSelection
				&&	uRow.pSel->GetTotalRange().Max() >= nRow
				&&	uRow.pSel->Select( nRow, _bSelect )
				)
			||	(	!bMultiSelection
				&&	( uRow.nSel = nRow ) != BROWSER_ENDOFSELECTION )
				)
			)
	{
		// Handle-Column nicht highlighten
		BrowserColumn *pFirstCol = pCols->GetObject(0);
		long nOfsX = pFirstCol->GetId() ? 0 : pFirstCol->Width();

		// highlight only newly selected part
		Rectangle aRect(
			Point( nOfsX, (nRow-nTopRow)*GetDataRowHeight() ),
			Size( pDataWin->GetSizePixel().Width(), GetDataRowHeight() ) );
		pDataWin->Invalidate( aRect );
	}

	if ( !bSelecting )
		Select();
	else
		bSelect = sal_True;

	// restore screen
	DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );

    if ( isAccessibleAlive() )
	{
		commitTableEvent(
            SELECTION_CHANGED,
			Any(),
			Any()
        );
		commitHeaderBarEvent(
            SELECTION_CHANGED,
			Any(),
			Any(),
			sal_False
        ); // row header event
	}
}

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

long BrowseBox::GetSelectRowCount() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->GetSelectCount() :
		   uRow.nSel == BROWSER_ENDOFSELECTION ? 0 : 1;
}

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

void BrowseBox::SelectColumnPos( sal_uInt16 nNewColPos, sal_Bool _bSelect, sal_Bool bMakeVisible )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( !bColumnCursor || nNewColPos == BROWSER_INVALIDID )
		return;

	if ( !bMultiSelection )
	{
		if ( _bSelect )
			GoToColumnId( pCols->GetObject(nNewColPos)->GetId(), bMakeVisible );
		return;
	}
	else
	{
		if ( !GoToColumnId( pCols->GetObject( nNewColPos )->GetId(), bMakeVisible ) )
			return;
	}

	DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
	ToggleSelection();
	if ( bMultiSelection )
		uRow.pSel->SelectAll(sal_False);
	else
		uRow.nSel = BROWSER_ENDOFSELECTION;
	pColSel->SelectAll(sal_False);

	if ( pColSel->Select( nNewColPos, _bSelect ) )
	{
		// GoToColumnId( pCols->GetObject(nNewColPos)->GetId(), bMakeVisible );

		// only highlight painted areas
		pDataWin->Update();
		Rectangle aFieldRectPix( GetFieldRectPixel( nCurRow, nCurColId, sal_False ) );
		Rectangle aRect(
			Point( aFieldRectPix.Left() - MIN_COLUMNWIDTH, 0 ),
			Size( pCols->GetObject(nNewColPos)->Width(),
				  pDataWin->GetOutputSizePixel().Height() ) );
		pDataWin->Invalidate( aRect );
		if ( !bSelecting )
			Select();
		else
			bSelect = sal_True;

        if ( isAccessibleAlive() )
		{
			commitTableEvent(
                SELECTION_CHANGED,
				Any(),
				Any()
            );
			commitHeaderBarEvent(
                SELECTION_CHANGED,
				Any(),
				Any(),
				sal_True
            ); // column header event
		}
	}

	// restore screen
	DBG_TRACE1( "BrowseBox: %p->ShowCursor", this );
}

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

sal_uInt16 BrowseBox::GetSelectColumnCount() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// while bAutoSelect (==!pColSel), 1 if any rows (yes rows!) else none
	return pColSel ? (sal_uInt16) pColSel->GetSelectCount() :
		   nCurRow >= 0 ? 1 : 0;
}

//-------------------------------------------------------------------
long BrowseBox::FirstSelectedColumn( ) const
{
	return pColSel ? pColSel->FirstSelected() : BROWSER_ENDOFSELECTION;
}

//-------------------------------------------------------------------
long BrowseBox::NextSelectedColumn( ) const
{
	return pColSel ? pColSel->NextSelected() : BROWSER_ENDOFSELECTION;
}

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

long BrowseBox::FirstSelectedRow( sal_Bool bInverse )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->FirstSelected(bInverse) : uRow.nSel;
}

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

long BrowseBox::NextSelectedRow()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->NextSelected() : BROWSER_ENDOFSELECTION;
}

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

long BrowseBox::PrevSelectedRow()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->PrevSelected() : BROWSER_ENDOFSELECTION;
}

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

long BrowseBox::LastSelectedRow()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->LastSelected() : uRow.nSel;
}

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

bool BrowseBox::IsRowSelected( long nRow ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return bMultiSelection ? uRow.pSel->IsSelected(nRow) : nRow == uRow.nSel;
}

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

bool BrowseBox::IsColumnSelected( sal_uInt16 nColumnId ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return pColSel ? pColSel->IsSelected( GetColumnPos(nColumnId) ) :
					 nCurColId == nColumnId;
}

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

sal_Bool BrowseBox::IsAllSelected() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

    return bMultiSelection && uRow.pSel->IsAllSelected();
}

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

sal_Bool BrowseBox::MakeFieldVisible
(
	long	nRow,		// Zeilen-Nr des Feldes (beginnend mit 0)
	sal_uInt16	nColId, 	// Spalten-Id des Feldes
	sal_Bool	bComplete	// (== sal_False), sal_True => vollst"andig sichtbar machen
)

/*	[Beschreibung]

	Macht das durch 'nRow' und 'nColId' beschriebene Feld durch
	entsprechendes scrollen sichtbar. Ist 'bComplete' gesetzt, dann wird
	gefordert, da\s das Feld ganz sichtbar wird.

	[R"uckgabewert]

	sal_Bool			sal_True
					Das angegebene Feld wurde sichtbar gemacht, bzw. war
					bereits sichtbar.

					sal_False
					Das angegebene Feld konnte nicht sichtbar bzw. bei
					'bComplete' nicht vollst"andig sichtbar gemacht werden.
*/

{
	Size aTestSize = pDataWin->GetSizePixel();

	if ( !bBootstrapped ||
		 ( aTestSize.Width() == 0 && aTestSize.Height() == 0 ) )
		return sal_False;

	// ist es schon sichtbar?
	sal_Bool bVisible = IsFieldVisible( nRow, nColId, bComplete );
	if ( bVisible )
		return sal_True;

	// Spaltenposition und Feld-Rechteck und Ausgabebereich berechnen
	sal_uInt16 nColPos = GetColumnPos( nColId );
	Rectangle aFieldRect = GetFieldRectPixel( nRow, nColId, sal_False );
	Rectangle aDataRect = Rectangle( Point(0, 0), pDataWin->GetSizePixel() );

	// links au\serhalb?
	if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
		// => nach rechts scrollen
		ScrollColumns( nColPos - nFirstCol );

	// solange rechts au\serhalb
	while ( aDataRect.Right() < ( bComplete
				? aFieldRect.Right()
				: aFieldRect.Left()+aFieldRect.GetWidth()/2 ) )
	{
		// => nach links scrollen
		if ( ScrollColumns( 1 ) != 1 )
			// nichts mehr zu scrollen
			break;
		aFieldRect = GetFieldRectPixel( nRow, nColId, sal_False );
	}

	// oben au\serhalb?
	if ( nRow < nTopRow )
		// nach unten scrollen
		ScrollRows( nRow - nTopRow );

	// unten au\serhalb?
	long nBottomRow = nTopRow + GetVisibleRows();
	// OV: damit nBottomRow die Nummer der letzten sichtbaren Zeile ist
	// (Zaehlung ab Null!), muss sie dekrementiert werden.
	// Beispiel: BrowseBox enthaelt genau einen Eintrag. nBottomRow := 0 + 1 - 1
	if( nBottomRow )
		nBottomRow--;

	if ( nRow > nBottomRow )
		// nach oben scrollen
		ScrollRows( nRow - nBottomRow );

	// jetzt kann es immer noch nicht passen, z.B. weil Window zu klein
	return IsFieldVisible( nRow, nColId, bComplete );
}

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

sal_Bool BrowseBox::IsFieldVisible( long nRow, sal_uInt16 nColumnId,
								sal_Bool bCompletely ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// durch frozen-Column verdeckt?
	sal_uInt16 nColPos = GetColumnPos( nColumnId );
	if ( nColPos >= FrozenColCount() && nColPos < nFirstCol )
		return sal_False;

	Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
	if ( aRect.IsEmpty() )
		return sal_False;

	// get the visible area
	Rectangle aOutRect( Point(0, 0), pDataWin->GetOutputSizePixel() );

	if ( bCompletely )
		// test if the field is completely visible
		return aOutRect.IsInside( aRect );
	else
		// test if the field is partly of completely visible
		return !aOutRect.Intersection( aRect ).IsEmpty();
}

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

Rectangle BrowseBox::GetFieldRectPixel( long nRow, sal_uInt16 nColumnId,
										sal_Bool bRelToBrowser) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// get the rectangle relative to DataWin
	Rectangle aRect( ImplFieldRectPixel( nRow, nColumnId ) );
	if ( aRect.IsEmpty() )
		return aRect;

	// adjust relative to BrowseBox's output area
	Point aTopLeft( aRect.TopLeft() );
	if ( bRelToBrowser )
	{
		aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
		aTopLeft = ScreenToOutputPixel( aTopLeft );
	}

	return Rectangle( aTopLeft, aRect.GetSize() );
}

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

Rectangle BrowseBox::GetRowRectPixel( long nRow, sal_Bool bRelToBrowser  ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// get the rectangle relative to DataWin
	Rectangle aRect;
	if ( nTopRow > nRow )
		// row is above visible area
		return aRect;
	aRect = Rectangle(
		Point( 0, GetDataRowHeight() * (nRow-nTopRow) ),
		Size( pDataWin->GetOutputSizePixel().Width(), GetDataRowHeight() ) );
	if ( aRect.TopLeft().Y() > pDataWin->GetOutputSizePixel().Height() )
		// row is below visible area
		return aRect;

	// adjust relative to BrowseBox's output area
	Point aTopLeft( aRect.TopLeft() );
	if ( bRelToBrowser )
	{
		aTopLeft = pDataWin->OutputToScreenPixel( aTopLeft );
		aTopLeft = ScreenToOutputPixel( aTopLeft );
	}

	return Rectangle( aTopLeft, aRect.GetSize() );
}

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

Rectangle BrowseBox::ImplFieldRectPixel( long nRow, sal_uInt16 nColumnId ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// compute the X-coordinte realtiv to DataWin by accumulation
	long nColX = 0;
	sal_uInt16 nFrozenCols = FrozenColCount();
	sal_uInt16 nCol;
	for ( nCol = 0;
		  nCol < pCols->Count() && pCols->GetObject(nCol)->GetId() != nColumnId;
		  ++nCol )
		if ( pCols->GetObject(nCol)->IsFrozen() || nCol >= nFirstCol )
			nColX += pCols->GetObject(nCol)->Width();

	if ( nCol >= pCols->Count() || ( nCol >= nFrozenCols && nCol < nFirstCol ) )
		return Rectangle();

	// compute the Y-coordinate relative to DataWin
	long nRowY = GetDataRowHeight();
	if ( nRow != BROWSER_ENDOFSELECTION ) // #105497# OJ
		nRowY = ( nRow - nTopRow ) * GetDataRowHeight();

	// assemble the Rectangle relative to DataWin
	return Rectangle(
		Point( nColX + MIN_COLUMNWIDTH, nRowY ),
		Size( pCols->GetObject(nCol)->Width() - 2*MIN_COLUMNWIDTH,
			  GetDataRowHeight() - 1 ) );
}

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

long BrowseBox::GetRowAtYPosPixel( long nY, sal_Bool bRelToBrowser ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// compute the Y-coord
	if ( bRelToBrowser )
	{
		Point aDataTopLeft = pDataWin->OutputToScreenPixel( Point(0, 0) );
		Point aTopLeft = OutputToScreenPixel( Point(0, 0) );
		nY -= aDataTopLeft.Y() - aTopLeft.Y();
	}

	// no row there (e.g. in the header)
	if ( nY < 0 || nY >= pDataWin->GetOutputSizePixel().Height() )
		return -1;

	return nY / GetDataRowHeight() + nTopRow;
}

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

Rectangle BrowseBox::GetFieldRect( sal_uInt16 nColumnId ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return GetFieldRectPixel( nCurRow, nColumnId );
}

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

sal_uInt16 BrowseBox::GetColumnAtXPosPixel( long nX, sal_Bool ) const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// accumulate the withds of the visible columns
	long nColX = 0;
	sal_uInt16 nCol;
	for ( nCol = 0; nCol < sal_uInt16(pCols->Count()); ++nCol )
	{
		BrowserColumn *pCol = pCols->GetObject(nCol);
		if ( pCol->IsFrozen() || nCol >= nFirstCol )
			nColX += pCol->Width();

		if ( nColX > nX )
			return nCol;
	}

	return BROWSER_INVALIDID;
}

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

void BrowseBox::ReserveControlArea( sal_uInt16 nWidth )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	if ( nWidth != nControlAreaWidth )
	{
        OSL_ENSURE(nWidth,"Control aera of 0 is not allowed, Use USHRT_MAX instead!");
		nControlAreaWidth = nWidth;
		UpdateScrollbars();
	}
}

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

Rectangle BrowseBox::GetControlArea() const
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	return Rectangle(
		Point( 0, GetOutputSizePixel().Height() - aHScroll.GetSizePixel().Height() ),
		Size( GetOutputSizePixel().Width() - aHScroll.GetSizePixel().Width(),
			 aHScroll.GetSizePixel().Height() ) );
}

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

void BrowseBox::SetMode( BrowserMode nMode )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

#ifdef DBG_MIx
	Sound::Beep();
	nMode =
//  		BROWSER_COLUMNSELECTION |
//  		BROWSER_MULTISELECTION |
			BROWSER_THUMBDRAGGING |
			BROWSER_KEEPHIGHLIGHT |
			BROWSER_HLINES |
			BROWSER_VLINES |
// 			BROWSER_HIDECURSOR |
//  		BROWSER_NO_HSCROLL |
//  		BROWSER_NO_SCROLLBACK |
			BROWSER_AUTO_VSCROLL |
			BROWSER_AUTO_HSCROLL |
			BROWSER_TRACKING_TIPS |
//  		BROWSER_HIGHLIGHT_NONE |
			BROWSER_HEADERBAR_NEW |
//			BROWSER_AUTOSIZE_LASTCOL |
			0;
#endif

	getDataWindow()->bAutoHScroll = BROWSER_AUTO_HSCROLL == ( nMode & BROWSER_AUTO_HSCROLL );
	getDataWindow()->bAutoVScroll = BROWSER_AUTO_VSCROLL == ( nMode & BROWSER_AUTO_VSCROLL );
	getDataWindow()->bNoHScroll   = BROWSER_NO_HSCROLL   == ( nMode & BROWSER_NO_HSCROLL );
    getDataWindow()->bNoVScroll   = BROWSER_NO_VSCROLL   == ( nMode & BROWSER_NO_VSCROLL );

    DBG_ASSERT( !( getDataWindow()->bAutoHScroll && getDataWindow()->bNoHScroll ),
        "BrowseBox::SetMode: AutoHScroll *and* NoHScroll?" );
    DBG_ASSERT( !( getDataWindow()->bAutoVScroll && getDataWindow()->bNoVScroll ),
        "BrowseBox::SetMode: AutoVScroll *and* NoVScroll?" );
    if ( getDataWindow()->bAutoHScroll )
        getDataWindow()->bNoHScroll = sal_False;
    if ( getDataWindow()->bAutoVScroll )
        getDataWindow()->bNoVScroll = sal_False;

    if ( getDataWindow()->bNoHScroll )
		aHScroll.Hide();

    nControlAreaWidth = USHRT_MAX;

	getDataWindow()->bNoScrollBack =
			BROWSER_NO_SCROLLBACK == ( nMode & BROWSER_NO_SCROLLBACK);

	long nOldRowSel = bMultiSelection ? uRow.pSel->FirstSelected() : uRow.nSel;
	MultiSelection *pOldRowSel = bMultiSelection ? uRow.pSel : 0;
	MultiSelection *pOldColSel = pColSel;

	delete pVScroll;

	bThumbDragging = ( nMode & BROWSER_THUMBDRAGGING ) == BROWSER_THUMBDRAGGING;
	bMultiSelection = ( nMode & BROWSER_MULTISELECTION ) == BROWSER_MULTISELECTION;
	bColumnCursor = ( nMode & BROWSER_COLUMNSELECTION ) == BROWSER_COLUMNSELECTION;
	bKeepHighlight = ( nMode & BROWSER_KEEPSELECTION ) == BROWSER_KEEPSELECTION;

	bHideSelect = ((nMode & BROWSER_HIDESELECT) == BROWSER_HIDESELECT);
	// default: do not hide the cursor at all (untaken scrolling and such)
	bHideCursor = NO_CURSOR_HIDE;

	if ( BROWSER_SMART_HIDECURSOR == ( nMode & BROWSER_SMART_HIDECURSOR ) )
	{	// smart cursor hide overrules hard cursor hide
		bHideCursor = SMART_CURSOR_HIDE;
	}
	else if ( BROWSER_HIDECURSOR == ( nMode & BROWSER_HIDECURSOR ) )
	{
		bHideCursor = HARD_CURSOR_HIDE;
	}

	m_bFocusOnlyCursor = ((nMode & BROWSER_CURSOR_WO_FOCUS) == 0);

	bHLines = ( nMode & BROWSER_HLINESFULL ) == BROWSER_HLINESFULL;
	bVLines = ( nMode & BROWSER_VLINESFULL ) == BROWSER_VLINESFULL;
	bHDots  = ( nMode & BROWSER_HLINESDOTS ) == BROWSER_HLINESDOTS;
	bVDots  = ( nMode & BROWSER_VLINESDOTS ) == BROWSER_VLINESDOTS;

	WinBits nVScrollWinBits =
		WB_VSCROLL | ( ( nMode & BROWSER_THUMBDRAGGING ) ? WB_DRAG : 0 );
	pVScroll = ( nMode & BROWSER_TRACKING_TIPS ) == BROWSER_TRACKING_TIPS
				? new BrowserScrollBar( this, nVScrollWinBits,
										(BrowserDataWin*) pDataWin )
				: new ScrollBar( this, nVScrollWinBits );
	pVScroll->SetLineSize( 1 );
	pVScroll->SetPageSize(1);
	pVScroll->SetScrollHdl( LINK( this, BrowseBox, ScrollHdl ) );
	pVScroll->SetEndScrollHdl( LINK( this, BrowseBox, EndScrollHdl ) );

	getDataWindow()->bAutoSizeLastCol =
			BROWSER_AUTOSIZE_LASTCOL == ( nMode & BROWSER_AUTOSIZE_LASTCOL );
	getDataWindow()->bOwnDataChangedHdl =
			BROWSER_OWN_DATACHANGED == ( nMode & BROWSER_OWN_DATACHANGED );

	// Headerbar erzeugen, was passiert, wenn eine erzeugt werden mu� und schon Spalten bestehen ?
	if ( BROWSER_HEADERBAR_NEW == ( nMode & BROWSER_HEADERBAR_NEW ) )
	{
		if (!getDataWindow()->pHeaderBar)
			getDataWindow()->pHeaderBar = CreateHeaderBar( this );
	}
	else
	{
		DELETEZ(getDataWindow()->pHeaderBar);
	}



	if ( bColumnCursor )
	{
		pColSel = pOldColSel ? pOldColSel : new MultiSelection;
		pColSel->SetTotalRange( Range( 0, pCols->Count()-1 ) );
	}
	else
	{
		pColSel = 0;
		delete pColSel;
	}

	if ( bMultiSelection )
	{
		if ( pOldRowSel )
			uRow.pSel = pOldRowSel;
		else
			uRow.pSel = new MultiSelection;
	}
	else
	{
		uRow.nSel = nOldRowSel;
		delete pOldRowSel;
	}

	if ( bBootstrapped )
	{
		StateChanged( STATE_CHANGE_INITSHOW );
		if ( bMultiSelection && !pOldRowSel &&
			 nOldRowSel != BROWSER_ENDOFSELECTION )
			uRow.pSel->Select( nOldRowSel );
	}

	if ( pDataWin )
		pDataWin->Invalidate();

	// kein Cursor auf Handle-Column
	if ( nCurColId == 0 )
		nCurColId = GetColumnId( 1 );

	m_nCurrentMode = nMode;
}

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

void BrowseBox::VisibleRowsChanged( long, sal_uInt16 )
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

	// Das alte Verhalten: NumRows automatisch korrigieren:
	if ( nRowCount < GetRowCount() )
	{
		RowInserted(nRowCount,GetRowCount() - nRowCount,sal_False);
	}
	else if ( nRowCount > GetRowCount() )
	{
		RowRemoved(nRowCount-(nRowCount - GetRowCount()),nRowCount - GetRowCount(),sal_False);
	}
}

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

sal_Bool BrowseBox::IsCursorMoveAllowed( long, sal_uInt16 ) const

/*	[Beschreibung]

	Diese virtuelle Methode wird immer gerufen bevor der Cursor direkt
	bewegt werden soll. Durch 'return sal_False' kann verhindert werden, da\s
	dies geschieht, wenn z.B. ein Datensatz irgendwelchen Rules widerspricht.

	Diese Methode wird nicht gerufen, wenn die Cursorbewegung durch
	ein L"oschen oder Einf"ugen (einer Zeile/Spalte) ausgel"ost wird, also
	genaugenommen nur eine Cursor-Korrektur vorliegt.

	Die Basisimplementierung liefert derzeit immer sal_True.
*/

{
	return sal_True;
}

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

long BrowseBox::GetDataRowHeight() const
{
	return CalcZoom(nDataRowHeight ? nDataRowHeight : ImpGetDataRowHeight());
}

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

Window& BrowseBox::GetEventWindow() const
{
	return *getDataWindow()->pEventWin;
}

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

BrowserHeader* BrowseBox::CreateHeaderBar( BrowseBox* pParent )
{
	BrowserHeader* pNewBar = new BrowserHeader( pParent );
	pNewBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
	return pNewBar;
}

void BrowseBox::SetHeaderBar( BrowserHeader* pHeaderBar )
{
	delete ( (BrowserDataWin*)pDataWin )->pHeaderBar;
	( (BrowserDataWin*)pDataWin )->pHeaderBar = pHeaderBar;
	( (BrowserDataWin*)pDataWin )->pHeaderBar->SetStartDragHdl( LINK( this, BrowseBox, StartDragHdl ) );
}
//-------------------------------------------------------------------

#ifdef DBG_UTIL
const char* BrowseBoxCheckInvariants( const void * pVoid )
{
	const BrowseBox * p = (const BrowseBox *)pVoid;

	if (p->nRowCount < 0) return "BrowseBox: nRowCount < 0";
	if (p->nTopRow < 0) return "BrowseBox: nTopRow < 0";
	if (p->nTopRow >= p->nRowCount && p->nRowCount != 0) return "BrowseBox: nTopRow >= nRowCount && nRowCount != 0";
	if (p->nCurRow < -1) return "BrowseBox: nCurRow < -1";
	if (p->nCurRow > p->nRowCount) return "BrowseBox: nCurRow > nRowCount";

	// Leider waehrend der Bearbeitung nicht immer der Fall:
	//if (p->nCurRow < 0 && p->nRowCount != 0) return "nCurRow < 0 && nRowCount != 0";
	//if (p->nCurRow >= p->nRowCount && p->nRowCount != 0) return "nCurRow >= nRowCount && nRowCount != 0";

	return NULL;
}
#endif

//-------------------------------------------------------------------
long BrowseBox::GetTitleHeight() const
{
	long nHeight;
	// ask the header bar for the text height (if possible), as the header bar's font is adjusted with
	// our (and the header's) zoom factor
	HeaderBar* pHeaderBar = ( (BrowserDataWin*)pDataWin )->pHeaderBar;
	if ( pHeaderBar )
		nHeight = pHeaderBar->GetTextHeight();
	else
		nHeight = GetTextHeight();

	return nTitleLines ? nTitleLines * nHeight + 4 : 0;
}

//-------------------------------------------------------------------
long BrowseBox::CalcReverseZoom(long nVal)
{
	if (IsZoom())
	{
		const Fraction& rZoom = GetZoom();
		double n = (double)nVal;
		n *= (double)rZoom.GetDenominator();
		n /= (double)rZoom.GetNumerator();
		nVal = n>0 ? (long)(n + 0.5) : -(long)(-n + 0.5);
	}

	return nVal;
}

//-------------------------------------------------------------------
HeaderBar* BrowseBox::GetHeaderBar() const
{
	return getDataWindow()->pHeaderBar;
}
//-------------------------------------------------------------------

void BrowseBox::CursorMoved()
{
	// before implementing more here, please adjust the EditBrowseBox
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);

    if ( isAccessibleAlive() && HasFocus() )
		commitTableEvent(
            ACTIVE_DESCENDANT_CHANGED,
            makeAny( CreateAccessibleCell( GetCurRow(),GetColumnPos( GetCurColumnId() ) ) ),
            Any()
        );
}

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

void BrowseBox::LoseFocus()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);
	DBG_TRACE1( "BrowseBox: %p->LoseFocus", this );

	if ( bHasFocus )
	{
		DBG_TRACE1( "BrowseBox: %p->HideCursor", this );
		DoHideCursor( "LoseFocus" );

		if ( !bKeepHighlight )
		{
			ToggleSelection();
			bSelectionIsVisible = sal_False;
		}

		bHasFocus = sal_False;
	}
	Control::LoseFocus();
}

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

void BrowseBox::GetFocus()
{
	DBG_CHKTHIS(BrowseBox,BrowseBoxCheckInvariants);
	DBG_TRACE1( "BrowseBox: %p->GetFocus", this );

	if ( !bHasFocus )
	{
		if ( !bSelectionIsVisible )
		{
			bSelectionIsVisible = sal_True;
			if ( bBootstrapped )
				ToggleSelection();
		}

		bHasFocus = sal_True;
		DoShowCursor( "GetFocus" );
	}
	Control::GetFocus();
}