xref: /AOO41X/main/svtools/source/contnr/treelist.cxx (revision 5900e8ec128faec89519683efce668ccd8cc6084)

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

#define _TREELIST_CXX

#ifndef GCC
#endif

#include <svtools/treelist.hxx>

#ifdef DBG_UTIL
// Prueft Integritaet der Liste nach jeder Operation
//#define CHECK_INTEGRITY
#endif


DBG_NAME(SvListEntry);

SvListEntry::SvListEntry()
{
	DBG_CTOR(SvListEntry,0);
	pChilds     = 0;
	pParent     = 0;
	nListPos    = 0;
	nAbsPos     = 0;
}

SvListEntry::SvListEntry( const SvListEntry& rEntry )
{
	DBG_CTOR(SvListEntry,0);
	pChilds  = 0;
	pParent  = 0;
	nListPos &= 0x80000000;
	nListPos |= ( rEntry.nListPos & 0x7fffffff);
	nAbsPos  = rEntry.nAbsPos;
}

SvListEntry::~SvListEntry()
{
	DBG_DTOR(SvListEntry,0);
	if ( pChilds )
	{
		pChilds->DestroyAll();
		delete pChilds;
	}
#ifdef DBG_UTIL
	pChilds     = 0;
	pParent     = 0;
#endif
}

void SvListEntry::Clone( SvListEntry* pSource)
{
	DBG_CHKTHIS(SvListEntry,0);
	nListPos &= 0x80000000;
	nListPos |= ( pSource->nListPos & 0x7fffffff);
	nAbsPos		= pSource->nAbsPos;
}

void SvListEntry::SetListPositions()
{
	if( pChilds )
	{
		SvListEntry	*pEntry = (SvListEntry*)pChilds->First();
		sal_uLong		nCur = 0;
		while ( pEntry )
		{
			pEntry->nListPos &= 0x80000000;
			pEntry->nListPos |= nCur;
			nCur++;
			pEntry = (SvListEntry*)pChilds->Next();
		}
	}
	nListPos &= (~0x80000000);
}


DBG_NAME(SvViewData);

SvViewData::SvViewData()
{
	DBG_CTOR(SvViewData,0);
	nFlags = 0;
	nVisPos = 0;
}

SvViewData::SvViewData( const SvViewData& rData )
{
	DBG_CTOR(SvViewData,0);
	nFlags	= rData.nFlags;
	nFlags &= ~( SVLISTENTRYFLAG_SELECTED | SVLISTENTRYFLAG_FOCUSED );
	nVisPos	= rData.nVisPos;
}

SvViewData::~SvViewData()
{
	DBG_DTOR(SvViewData,0);
#ifdef DBG_UTIL
	nVisPos = 0x12345678;
	nFlags = 0x1234;
#endif
}

void SvTreeEntryList::DestroyAll()
{
	SvListEntry* pPtr = (SvListEntry*)First();
	while( pPtr )
	{
		delete pPtr;
		pPtr = (SvListEntry*)Next();
	}
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvTreeList::SvTreeList()
{
	nEntryCount = 0;
	bAbsPositionsValid = sal_False;
	nRefCount = 1;
	pRootItem = new SvListEntry;
	eSortMode = SortNone;
}


/*************************************************************************
|*
|*    SvTreeList::~SvTreeList
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvTreeList::~SvTreeList()
{
	Clear();
	delete pRootItem;
#ifdef DBG_UTIL
	pRootItem = 0;
#endif
}

/*************************************************************************
|*
|*    SvTreeList::Broadcast
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Broadcast( sal_uInt16 nActionId, SvListEntry* pEntry1,
	SvListEntry* pEntry2, sal_uLong nPos )
{
	sal_uLong nViewCount = aViewList.Count();
	for( sal_uLong nCurView = 0; nCurView < nViewCount; nCurView++ )
	{
		SvListView* pView = (SvListView*)aViewList.GetObject( nCurView );
		if( pView )
			pView->ModelNotification( nActionId, pEntry1, pEntry2, nPos );
	}
}

void SvTreeList::InsertView( SvListView* pView)
{
	sal_uLong nPos = aViewList.GetPos( pView );
	if ( nPos == LIST_ENTRY_NOTFOUND )
	{
		aViewList.Insert( pView, LIST_APPEND );
		nRefCount++;
	}
}

void SvTreeList::RemoveView( SvListView* pView )
{
	sal_uLong nPos = aViewList.GetPos( pView );
	if ( nPos != LIST_ENTRY_NOTFOUND )
	{
		aViewList.Remove( pView );
		nRefCount--;
	}
}


// Ein Entry ist sichtbar, wenn alle Parents expandiert sind
sal_Bool SvTreeList::IsEntryVisible( const SvListView* pView, SvListEntry* pEntry ) const
{
	DBG_ASSERT(pView&&pEntry,"IsVisible:Invalid Params");
	sal_Bool bRetVal=sal_False;
	do
	{
		if ( pEntry == pRootItem )
		{
			bRetVal=sal_True;
			break;
		}
		pEntry = pEntry->pParent;
	}  while( pView->IsExpanded( pEntry ) );
	return bRetVal;
}

sal_uInt16 SvTreeList::GetDepth( SvListEntry* pEntry ) const
{
	DBG_ASSERT(pEntry&&pEntry!=pRootItem,"GetDepth:Bad Entry");
	sal_uInt16 nDepth = 0;
	while( pEntry->pParent != pRootItem )
	{
		nDepth++;
		pEntry = pEntry->pParent;
	}
	return nDepth;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Clear()
{
	Broadcast( LISTACTION_CLEARING );
	SvTreeEntryList* pRootList = pRootItem->pChilds;
	if ( pRootList )
	{
		SvListEntry* pEntry = (SvListEntry*)(pRootList->First());
		while( pEntry )
		{
			delete pEntry;
			pEntry = (SvListEntry*)(pRootList->Next());
		}
		delete pRootItem->pChilds;
		pRootItem->pChilds = 0;
	}
	nEntryCount = 0;
	Broadcast( LISTACTION_CLEARED );
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_Bool SvTreeList::IsChild( SvListEntry* pParent, SvListEntry* pChild ) const
{
	if ( !pParent )
		pParent = pRootItem;

	sal_Bool bIsChild = sal_False;
	SvTreeEntryList* pList = pParent->pChilds;
	if ( !pList )
		return sal_False;
	SvListEntry* pActualChild = (SvListEntry*)(pList->First());
	while( !bIsChild && pActualChild )
	{
		if ( pActualChild == pChild )
			bIsChild = sal_True;
		else
		{
			if ( pActualChild->pChilds )
				bIsChild = IsChild( pActualChild, pChild );
			pActualChild = (SvListEntry*)(pList->Next());
		}
	}
	return bIsChild;
}

sal_uLong SvTreeList::Move(SvListEntry* pSrcEntry,SvListEntry* pTargetParent,sal_uLong nListPos)
{
	// pDest darf Null sein!
	DBG_ASSERT(pSrcEntry,"Entry?");
	if ( !pTargetParent )
		pTargetParent = pRootItem;
	DBG_ASSERT(pSrcEntry!=pTargetParent,"Move:Source=Target");

	Broadcast( LISTACTION_MOVING, pSrcEntry, pTargetParent, nListPos );

	if ( !pTargetParent->pChilds )
		pTargetParent->pChilds = new SvTreeEntryList;
	if ( pSrcEntry == pTargetParent )
		return pSrcEntry->GetChildListPos();

	bAbsPositionsValid = sal_False;

	SvTreeEntryList* pDstList = pTargetParent->pChilds;
	SvTreeEntryList* pSrcList = pSrcEntry->pParent->pChilds;

	// Dummy-Ptr einfuegen, weil nListPos durch das
	// folgende Remove ungueltig werden koennte
	SvListEntry* pDummy = 0; pDstList->Insert( pDummy, nListPos );

	// loeschen
	pSrcList->Remove( pSrcEntry );
	// Hat Parent noch Childs ?
	if ( pSrcList->Count() == 0 )
	{
		// Keine Childs, deshalb Child-List loeschen
		SvListEntry* pParent = pSrcEntry->pParent;
		pParent->pChilds = 0;
		delete pSrcList;
		pSrcList = 0;
	}

	// Parent umsetzen (erst hier, weil wir zum Loeschen
	// der ChildList den alten Parent noch benoetigen!)
	pSrcEntry->pParent = pTargetParent;

	pDstList->Replace( pSrcEntry, pDummy );

	// Listenpositionen in Zielliste korrigieren
	SetListPositions( pDstList );
	if ( pSrcList && (sal_uLong)pSrcList != (sal_uLong)pDstList )
		SetListPositions( pSrcList );

#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif

	sal_uLong nRetVal = pDstList->GetPos( pSrcEntry );
	DBG_ASSERT(nRetVal==pSrcEntry->GetChildListPos(),"ListPos not valid");
	Broadcast( LISTACTION_MOVED,pSrcEntry,pTargetParent,nRetVal);
	return nRetVal;
}

sal_uLong SvTreeList::Copy(SvListEntry* pSrcEntry,SvListEntry* pTargetParent,sal_uLong nListPos)
{
	// pDest darf Null sein!
	DBG_ASSERT(pSrcEntry,"Entry?");
	if ( !pTargetParent )
		pTargetParent = pRootItem;
	if ( !pTargetParent->pChilds )
		pTargetParent->pChilds = new SvTreeEntryList;

	bAbsPositionsValid = sal_False;

	sal_uLong nCloneCount = 0;
	SvListEntry* pClonedEntry = Clone( pSrcEntry, nCloneCount );
	nEntryCount += nCloneCount;

	SvTreeEntryList* pDstList = pTargetParent->pChilds;
	pClonedEntry->pParent = pTargetParent;		// Parent umsetzen
	pDstList->Insert( pClonedEntry, nListPos ); // Einfuegen
	SetListPositions( pDstList ); // Listenpositionen in Zielliste korrigieren

#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	Broadcast( LISTACTION_INSERTED_TREE, pClonedEntry );
	sal_uLong nRetVal = pDstList->GetPos( pClonedEntry );
	return nRetVal;
}



/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Move( SvListEntry* pSrcEntry, SvListEntry* pDstEntry )
{
	SvListEntry* pParent;
	sal_uLong nPos;

	if ( !pDstEntry )
	{
		pParent = pRootItem;
		nPos = 0UL;
	}
	else
	{
		pParent = pDstEntry->pParent;
		nPos = pDstEntry->GetChildListPos();
		nPos++;  // UNTER (Bildschirm) pDstEntry einfuegen
	}
	Move( pSrcEntry, pParent, nPos );
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Copy( SvListEntry* pSrcEntry, SvListEntry* pDstEntry )
{
	SvListEntry* pParent;
	sal_uLong nPos;

	if ( !pDstEntry )
	{
		pParent = pRootItem;
		nPos = 0UL;
	}
	else
	{
		pParent = pDstEntry->pParent;
		nPos = pDstEntry->GetChildListPos()+1;
	}
	Copy( pSrcEntry, pParent, nPos );
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/
void SvTreeList::InsertTree( SvListEntry* pSrcEntry, SvListEntry* pDstEntry)
{
	SvListEntry* pParent;
	sal_uLong nPos;

	if ( !pDstEntry )
	{
		pParent = pRootItem;
		nPos = 0UL;
	}
	else
	{
		pParent = pDstEntry->pParent;
		nPos = pDstEntry->GetChildListPos()+1;
	}
	InsertTree( pSrcEntry, pParent, nPos );
}


void SvTreeList::InsertTree(SvListEntry* pSrcEntry,
	SvListEntry* pTargetParent,sal_uLong nListPos)
{
	DBG_ASSERT(pSrcEntry,"InsertTree:Entry?");
	if ( !pSrcEntry )
		return;

	if ( !pTargetParent )
		pTargetParent = pRootItem;
	if ( !pTargetParent->pChilds )
		pTargetParent->pChilds = new SvTreeEntryList;

	// Sortierung beruecksichtigen
	GetInsertionPos( pSrcEntry, pTargetParent, nListPos );

	bAbsPositionsValid = sal_False;

	pSrcEntry->pParent = pTargetParent; // Parent umsetzen
	SvTreeEntryList* pDstList = pTargetParent->pChilds;
	pDstList->Insert( pSrcEntry, nListPos ); // einfuegen
	SetListPositions(pDstList); // Listenpositionen in Zielliste korrigieren
	nEntryCount += GetChildCount( pSrcEntry );
	nEntryCount++; // der Parent ist ja auch neu

#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	Broadcast(LISTACTION_INSERTED_TREE, pSrcEntry );
}

SvListEntry* SvTreeList::CloneEntry( SvListEntry* pSource ) const
{
	if( aCloneLink.IsSet() )
		return (SvListEntry*)aCloneLink.Call( pSource );
	SvListEntry* pEntry = CreateEntry();
	pSource->Clone( pEntry );
	return pSource;
}

SvListEntry* SvTreeList::CreateEntry() const
{
	return new SvListEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::Clone( SvListEntry* pEntry, sal_uLong& nCloneCount ) const
{
	SvListEntry* pClonedEntry = CloneEntry( pEntry );
	nCloneCount = 1;
	SvTreeEntryList* pChilds = pEntry->pChilds;
	if ( pChilds )
		pClonedEntry->pChilds=CloneChilds(pChilds,pClonedEntry,nCloneCount);
	return pClonedEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvTreeEntryList* SvTreeList::CloneChilds( SvTreeEntryList* pChilds,
									  SvListEntry* pNewParent,
									  sal_uLong& nCloneCount ) const
{
	DBG_ASSERT(pChilds->Count(),"Childs?");
	SvTreeEntryList* pClonedChilds = new SvTreeEntryList;
	SvListEntry* pChild = (SvListEntry*)pChilds->First();
	while ( pChild )
	{
		SvListEntry* pNewChild = CloneEntry( pChild );
		nCloneCount++;
		pNewChild->pParent = pNewParent;
		SvTreeEntryList* pSubChilds = pChild->pChilds;
		if ( pSubChilds )
		{
			pSubChilds = CloneChilds( pSubChilds, pNewChild, nCloneCount );
			pNewChild->pChilds = pSubChilds;
		}

		pClonedChilds->Insert( pNewChild, LIST_APPEND );
		pChild = (SvListEntry*)pChilds->Next();
	}
	return pClonedChilds;
}


/*************************************************************************
|*
|*    SvTreeList::GetChildCount
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::GetChildCount( SvListEntry* pParent ) const
{
	if ( !pParent )
		return GetEntryCount();

	if ( !pParent || !pParent->pChilds)
		return 0;
	sal_uLong nCount = 0;
	sal_uInt16 nRefDepth = GetDepth( pParent );
	sal_uInt16 nActDepth = nRefDepth;
	do
	{
		pParent = Next( pParent, &nActDepth );
		nCount++;
	} while( pParent && nRefDepth < nActDepth );
	nCount--;
	return nCount;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::GetVisibleChildCount(const SvListView* pView, SvListEntry* pParent) const
{
	DBG_ASSERT(pView,"GetVisChildCount:No View");
	if ( !pParent )
		pParent = pRootItem;
	if ( !pParent || !pView->IsExpanded(pParent) || !pParent->pChilds )
		return 0;
	sal_uLong nCount = 0;
	sal_uInt16 nRefDepth = GetDepth( pParent );
	sal_uInt16 nActDepth = nRefDepth;
	do
	{
		pParent = NextVisible( pView, pParent, &nActDepth );
		nCount++;
	} while( pParent && nRefDepth < nActDepth );
	nCount--;
	return nCount;
}

sal_uLong SvTreeList::GetChildSelectionCount(const SvListView* pView,SvListEntry* pParent) const
{
	DBG_ASSERT(pView,"GetChildSelCount:No View");
	if ( !pParent )
		pParent = pRootItem;
	if ( !pParent || !pParent->pChilds)
		return 0;
	sal_uLong nCount = 0;
	sal_uInt16 nRefDepth = GetDepth( pParent );
	sal_uInt16 nActDepth = nRefDepth;
	do
	{
		pParent = Next( pParent, &nActDepth );
		if( pParent && pView->IsSelected( pParent ) && nRefDepth < nActDepth)
			nCount++;
	} while( pParent && nRefDepth < nActDepth );
//	nCount--;
	return nCount;
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::First() const
{
	if ( nEntryCount )
		return (SvListEntry*)(pRootItem->pChilds->GetObject(0));
	else
		return 0;
}

/*************************************************************************
|*
|*    SvTreeList::Next
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/
SvListEntry* SvTreeList::Next( SvListEntry* pActEntry, sal_uInt16* pDepth ) const
{
    DBG_ASSERT( pActEntry && pActEntry->pParent, "SvTreeList::Next: invalid entry/parent!" );
    if ( !pActEntry || !pActEntry->pParent )
        return NULL;

	sal_uInt16 nDepth = 0;
	int bWithDepth = sal_False;
	if ( pDepth )
	{
		nDepth = *pDepth;
		bWithDepth = sal_True;
	}

	SvTreeEntryList* pActualList = pActEntry->pParent->pChilds;
	sal_uLong nActualPos = pActEntry->GetChildListPos();

	if ( pActEntry->pChilds /* && pActEntry->pChilds->Count() */ )
	{
		nDepth++;
		pActEntry = (SvListEntry*)(pActEntry->pChilds->GetObject(0));
		if ( bWithDepth )
			*pDepth = nDepth;
		return pActEntry;
	}

	if ( pActualList->Count() > ( nActualPos + 1 ) )
	{
		pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos + 1 ));
		if ( bWithDepth )
			*pDepth = nDepth;
		return pActEntry;
	}

	SvListEntry* pParent = pActEntry->pParent;
	nDepth--;
	while( pParent != pRootItem && pParent != 0 )
	{
		DBG_ASSERT(pParent!=0,"TreeData corrupt!");
		pActualList = pParent->pParent->pChilds;
		DBG_ASSERT(pActualList,"TreeData corrupt!");
		nActualPos = pParent->GetChildListPos();
		if ( pActualList->Count() > ( nActualPos + 1 ) )
		{
			pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos + 1 ));
			if ( bWithDepth )
				*pDepth = nDepth;
			return pActEntry;
		}
		pParent = pParent->pParent;
		nDepth--;
	}
	return 0;
}

/*************************************************************************
|*
|*    SvTreeList::Prev
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/
SvListEntry* SvTreeList::Prev( SvListEntry* pActEntry, sal_uInt16* pDepth ) const
{
	DBG_ASSERT(pActEntry!=0,"Entry?");

	sal_uInt16 nDepth = 0;
	int bWithDepth = sal_False;
	if ( pDepth )
	{
		nDepth = *pDepth;
		bWithDepth = sal_True;
	}

	SvTreeEntryList* pActualList = pActEntry->pParent->pChilds;
	sal_uLong nActualPos = pActEntry->GetChildListPos();

	if ( nActualPos > 0 )
	{
		pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos - 1 ));
		while( pActEntry->pChilds /* && pActEntry->pChilds->Count() */ )
		{
			pActualList = pActEntry->pChilds;
			nDepth++;
			pActEntry = (SvListEntry*)(pActualList->Last());
		}
		if ( bWithDepth )
			*pDepth = nDepth;
		return pActEntry;
	}
	if ( pActEntry->pParent == pRootItem )
		return 0;

	pActEntry = pActEntry->pParent;

	if ( pActEntry )
	{
		nDepth--;
		if ( bWithDepth )
			*pDepth = nDepth;
		return pActEntry;
	}
	return 0;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::Last( sal_uInt16* /* nDepth */ ) const
{
	SvTreeEntryList* pActList = pRootItem->pChilds;
//	if ( pActList->Count() == 0 )
//		return 0;
	SvListEntry* pEntry = 0;
	while( pActList )
	{
		pEntry = (SvListEntry*)(pActList->Last());
		pActList = pEntry->pChilds;
//		if ( pActList->Count() == 0 )
//			pActList = 0;
	}
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::GetVisiblePos( const SvListView* pView, SvListEntry* pEntry ) const
{
	DBG_ASSERT(pView&&pEntry,"View/Entry?");

	if ( !pView->bVisPositionsValid )
	{
		// damit GetVisibleCount die Positionen aktualisiert
		((SvListView*)pView)->nVisibleCount = 0;
		GetVisibleCount( pView );
	}
	SvViewData* pViewData = pView->GetViewData( pEntry );
	return pViewData->nVisPos;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::GetVisibleCount( const SvListView* pView ) const
{
	DBG_ASSERT(pView,"GetVisCount:No View");
	if( !pView->HasViewData() )
		return 0;
	if ( pView->nVisibleCount )
		return pView->nVisibleCount;

	sal_uLong nPos = 0;
	SvListEntry* pEntry = First();  // erster Eintrag immer sichtbar
	while ( pEntry )
	{
		SvViewData* pViewData = pView->GetViewData( pEntry );
		pViewData->nVisPos = nPos;
		nPos++;
		pEntry = NextVisible( pView, pEntry );
	}
#ifdef DBG_UTIL
	if( nPos > 10000000 )
	{
		DBG_ERROR("nVisibleCount bad");
	}
#endif
	((SvListView*)pView)->nVisibleCount = nPos;
	((SvListView*)pView)->bVisPositionsValid = sal_True;
	return nPos;
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

// Funktion geht aus Geschwindigkeitsgruenden davon aus,
// das der uebergebene Eintrag bereits sichtbar ist

SvListEntry* SvTreeList::NextVisible(const SvListView* pView,SvListEntry* pActEntry,sal_uInt16* pActDepth) const
{
	DBG_ASSERT(pView,"NextVisible:No View");
	if ( !pActEntry )
		return 0;

	sal_uInt16 nDepth = 0;
	int bWithDepth = sal_False;
	if ( pActDepth )
	{
		nDepth = *pActDepth;
		bWithDepth = sal_True;
	}

	SvTreeEntryList* pActualList = pActEntry->pParent->pChilds;
	sal_uLong nActualPos = pActEntry->GetChildListPos();

	if ( pView->IsExpanded(pActEntry) )
	{
		DBG_ASSERT(pActEntry->pChilds,"Childs?");
		nDepth++;
		pActEntry = (SvListEntry*)(pActEntry->pChilds->GetObject(0));
		if ( bWithDepth )
			*pActDepth = nDepth;
		return pActEntry;
	}

	nActualPos++;
	if ( pActualList->Count() > nActualPos  )
	{
		pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos ));
		if ( bWithDepth )
			*pActDepth = nDepth;
		return pActEntry;
	}

	SvListEntry* pParent = pActEntry->pParent;
	nDepth--;
	while( pParent != pRootItem )
	{
		pActualList = pParent->pParent->pChilds;
		nActualPos = pParent->GetChildListPos();
		nActualPos++;
		if ( pActualList->Count() > nActualPos )
		{
			pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos ));
			if ( bWithDepth )
				*pActDepth = nDepth;
			return pActEntry;
		}
		pParent = pParent->pParent;
		nDepth--;
	}
	return 0;
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

// Funktion geht aus Geschwindigkeitsgruenden davon aus,
// das der uebergebene Eintrag bereits sichtbar ist

SvListEntry* SvTreeList::PrevVisible(const SvListView* pView, SvListEntry* pActEntry, sal_uInt16* pActDepth) const
{
	DBG_ASSERT(pView&&pActEntry,"PrevVis:View/Entry?");

	sal_uInt16 nDepth = 0;
	int bWithDepth = sal_False;
	if ( pActDepth )
	{
		nDepth = *pActDepth;
		bWithDepth = sal_True;
	}

	SvTreeEntryList* pActualList = pActEntry->pParent->pChilds;
	sal_uLong nActualPos = pActEntry->GetChildListPos();

	if ( nActualPos > 0 )
	{
		pActEntry = (SvListEntry*)(pActualList->GetObject( nActualPos - 1 ));
		while( pView->IsExpanded(pActEntry) )
		{
			pActualList = pActEntry->pChilds;
			nDepth++;
			pActEntry = (SvListEntry*)(pActualList->Last());
		}
		if ( bWithDepth )
			*pActDepth = nDepth;
		return pActEntry;
	}

	if ( pActEntry->pParent == pRootItem )
		return 0;

	pActEntry = pActEntry->pParent;
	if ( pActEntry )
	{
		nDepth--;
		if ( bWithDepth )
			*pActDepth = nDepth;
		return pActEntry;
	}
	return 0;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::LastVisible( const SvListView* pView, sal_uInt16* pDepth) const
{
	DBG_ASSERT(pView,"LastVis:No View");
	SvListEntry* pEntry = Last();
	while( pEntry && !IsEntryVisible( pView, pEntry ) )
		pEntry = PrevVisible( pView, pEntry );
	if ( pEntry && pDepth )
		*pDepth = GetDepth( pEntry );
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::NextVisible(const SvListView* pView,SvListEntry* pEntry,sal_uInt16& nDelta) const
{
	DBG_ASSERT(pView&&pEntry&&IsEntryVisible(pView,pEntry),"NextVis:Wrong Prms/!Vis");

	sal_uLong nVisPos = GetVisiblePos( pView, pEntry );
	// nDelta Eintraege vorhanden ?
	// Beispiel: 0,1,2,3,4,5,6,7,8,9 nVisPos=5 nDelta=7
	//           nNewDelta = 10-nVisPos-1 == 4
	if (  nVisPos+nDelta >= pView->nVisibleCount )
	{
		nDelta = (sal_uInt16)(pView->nVisibleCount-nVisPos);
		nDelta--;
	}
	sal_uInt16 nDeltaTmp = nDelta;
	while( nDeltaTmp )
	{
		pEntry = NextVisible( pView, pEntry );
		nDeltaTmp--;
		DBG_ASSERT(pEntry,"Entry?");
	}
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::PrevVisible( const SvListView* pView, SvListEntry* pEntry, sal_uInt16& nDelta ) const
{
	DBG_ASSERT(pView&&pEntry&&IsEntryVisible(pView,pEntry),"PrevVis:Parms/!Vis");

	sal_uLong nVisPos = GetVisiblePos( pView, pEntry );
	// nDelta Eintraege vorhanden ?
	// Beispiel: 0,1,2,3,4,5,6,7,8,9 nVisPos=8 nDelta=20
	//           nNewDelta = nNewVisPos
	if (  nDelta > nVisPos )
		nDelta = (sal_uInt16)nVisPos;
	sal_uInt16 nDeltaTmp = nDelta;
	while( nDeltaTmp )
	{
		pEntry = PrevVisible( pView, pEntry );
		nDeltaTmp--;
		DBG_ASSERT(pEntry,"Entry?");
	}
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::FirstSelected( const SvListView* pView) const
{
	DBG_ASSERT(pView,"FirstSel:No View");
	if( !pView )
		return 0;
	SvListEntry* pActSelEntry = First();
	while( pActSelEntry && !pView->IsSelected(pActSelEntry) )
		pActSelEntry = NextVisible( pView, pActSelEntry );
	return pActSelEntry;
}


SvListEntry* SvTreeList::FirstChild( SvListEntry* pParent ) const
{
	if ( !pParent )
		pParent = pRootItem;
	SvListEntry* pResult;
	if ( pParent->pChilds )
		pResult = (SvListEntry*)(pParent->pChilds->GetObject( 0 ));
	else
		pResult = 0;
	return pResult;
}

SvListEntry* SvTreeList::NextSibling( SvListEntry* pEntry ) const
{
	DBG_ASSERT(pEntry,"Entry?");
	if( !pEntry )
		return 0;
	SvTreeEntryList* pList = pEntry->pParent->pChilds;
//	sal_uLong nPos = pList->GetPos( pEntry );
	sal_uLong nPos = pEntry->GetChildListPos();
	nPos++;
	pEntry = (SvListEntry*)(pList->GetObject( nPos ));
	return pEntry;
}

SvListEntry* SvTreeList::PrevSibling( SvListEntry* pEntry ) const
{
	DBG_ASSERT(pEntry,"Entry?");
	if( !pEntry )
		return 0;

	SvTreeEntryList* pList = pEntry->pParent->pChilds;
	// sal_uLong nPos = pList->GetPos( pEntry );
	sal_uLong nPos = pEntry->GetChildListPos();
	if ( nPos == 0 )
		return 0;
	nPos--;
	pEntry = (SvListEntry*)(pList->GetObject( nPos ));
	return pEntry;
}


SvListEntry* SvTreeList::LastSibling( SvListEntry* pEntry ) const
{
	DBG_ASSERT(pEntry,"LastSibling:Entry?");
	if( !pEntry )
		return 0;
	SvListEntry* pSib = 0;
	SvTreeEntryList* pSibs = pEntry->pParent->pChilds;
	if ( pSibs )
		pSib = (SvListEntry*)(pSibs->Last());
	return pSib;
}



/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::NextSelected( const SvListView* pView, SvListEntry* pEntry ) const
{
	DBG_ASSERT(pView&&pEntry,"NextSel:View/Entry?");
	pEntry = Next( pEntry );
	while( pEntry && !pView->IsSelected(pEntry) )
		pEntry = Next( pEntry );
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::PrevSelected( const SvListView* pView, SvListEntry* pEntry) const
{
	DBG_ASSERT(pView&&pEntry,"PrevSel:View/Entry?");
	pEntry = Prev( pEntry );
	while( pEntry && !pView->IsSelected(pEntry) )
		pEntry = Prev( pEntry );

	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

SvListEntry* SvTreeList::LastSelected( const SvListView* pView ) const
{
	DBG_ASSERT(pView,"LastSel:No View");
	SvListEntry* pEntry = Last();
	while( pEntry && !pView->IsSelected(pEntry) )
		pEntry = Prev( pEntry );
	return pEntry;
}

/*************************************************************************
|*
|*    SvTreeList::Insert
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/
sal_uLong SvTreeList::Insert( SvListEntry* pEntry,SvListEntry* pParent,sal_uLong nPos )
{
	DBG_ASSERT( pEntry,"Entry?");

	if ( !pParent )
		pParent = pRootItem;


	SvTreeEntryList* pList = pParent->pChilds;
	if ( !pList )
	{
		// Parent bekommt zum erstenmal ein Kind
		pList = new SvTreeEntryList;
		pParent->pChilds = pList;
	}

	// Sortierung beruecksichtigen
	GetInsertionPos( pEntry, pParent, nPos );

	bAbsPositionsValid = sal_False;
	pEntry->pParent = pParent;

	pList->Insert( pEntry, nPos );
	nEntryCount++;
	if( nPos != LIST_APPEND && (nPos != (pList->Count()-1)) )
		SetListPositions( pList );
	else
		pEntry->nListPos = pList->Count()-1;

#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	Broadcast( LISTACTION_INSERTED, pEntry );
	return nPos; // pEntry->nListPos;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::GetAbsPos( SvListEntry* pEntry) const
{
	if ( !bAbsPositionsValid )
		((SvTreeList*)this)->SetAbsolutePositions();
	return pEntry->nAbsPos;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::SetAbsolutePositions()
{
	sal_uLong nPos = 0;
	SvListEntry* pEntry = First();
	while ( pEntry )
	{
		pEntry->nAbsPos = nPos;
		nPos++;
		pEntry = Next( pEntry );
	}
	bAbsPositionsValid = sal_True;
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
}


/*************************************************************************
|*
|*    SvTreeList::Expand
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Expand( SvListView* pView, SvListEntry* pEntry )
{
	DBG_ASSERT(pEntry&&pView,"Expand:View/Entry?");
	if ( pView->IsExpanded(pEntry) )
		return;

	DBG_ASSERT(pEntry->pChilds,"Expand:No Childs!");

	SvViewData* pViewData = pView->GetViewData(pEntry);
	pViewData->nFlags |= SVLISTENTRYFLAG_EXPANDED;
	SvListEntry* pParent = pEntry->pParent;
	// wenn Parent sichtbar dann Statusdaten invalidieren
	if ( pView->IsExpanded( pParent ) )
	{
		pView->bVisPositionsValid = sal_False;
		pView->nVisibleCount = 0;
	}
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
}

/*************************************************************************
|*
|*    SvTreeList::Collapse
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

void SvTreeList::Collapse( SvListView* pView, SvListEntry* pEntry )
{
	DBG_ASSERT(pView&&pEntry,"Collapse:View/Entry?");
	if ( !pView->IsExpanded(pEntry) )
		return;

	DBG_ASSERT(pEntry->pChilds,"Collapse:No Childs!");

	SvViewData* pViewData = pView->GetViewData( pEntry );
	pViewData->nFlags &=(~SVLISTENTRYFLAG_EXPANDED);

	SvListEntry* pParent = pEntry->pParent;
	if ( pView->IsExpanded(pParent) )
	{
		pView->nVisibleCount = 0;
		pView->bVisPositionsValid = sal_False;
	}
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
}


/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_Bool SvTreeList::Select( SvListView* pView, SvListEntry* pEntry, sal_Bool bSelect )
{
	DBG_ASSERT(pView&&pEntry,"Select:View/Entry?");
	SvViewData* pViewData = pView->GetViewData( pEntry );
	if ( bSelect )
	{
		if ( pViewData->IsSelected() || !pViewData->IsSelectable() )
			return sal_False;
		else
		{
			pViewData->nFlags |= SVLISTENTRYFLAG_SELECTED;
			pView->nSelectionCount++;
		}
	}
	else
	{
		if ( !pViewData->IsSelected() )
			return sal_False;
		else
		{
			pViewData->nFlags &= ~( SVLISTENTRYFLAG_SELECTED );
			pView->nSelectionCount--;
		}
	}
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	return sal_True;
}

/*************************************************************************
|*
|*    SvTreeList::Remove
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  05.04.01
|*
*************************************************************************/
sal_Bool SvTreeList::Remove( SvListEntry* pEntry )
{
	DBG_ASSERT(pEntry,"Cannot remove root, use clear");

	if( !pEntry->pParent )
	{
		DBG_ERROR("Removing entry not in model!");
		// unter gewissen Umstaenden (welche?) loescht der
		// Explorer aus der View Eintraege, die er nicht in die View
		// eingefuegt hat. Da sich der Kunde fuer ein platzendes
		// Office nichts kaufen kann, fange ich diesen Fall ab.
		return sal_False;
	}

	Broadcast( LISTACTION_REMOVING, pEntry );
	sal_uLong nRemoved = 1 + GetChildCount(pEntry);
	bAbsPositionsValid = sal_False;

	SvListEntry* pParent = pEntry->pParent;
	SvTreeEntryList* pList = pParent->pChilds;
	DBG_ASSERT(pList,"Remove:No Childlist");
	sal_Bool bLastEntry = sal_False;

	if ( pEntry->HasChildListPos() )
	{
		sal_uLong nListPos = pEntry->GetChildListPos();
		bLastEntry = (nListPos == (pList->Count()-1) ) ? sal_True : sal_False;
		pList->Remove( nListPos );
	}
	else
	{
		pList->Remove( (void*) pEntry );
	}


	// moved to end of method because it is used later with Broadcast
	// delete pEntry; // loescht auch alle Childs

	if ( pList->Count() == 0 )
	{
		pParent->pChilds = 0;
		delete pList;
	}
	else
	{
		if( !bLastEntry )
			SetListPositions( pList );
	}
	nEntryCount -= nRemoved;

#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	Broadcast( LISTACTION_REMOVED, pEntry );

	delete pEntry; // loescht auch alle Childs
	return sal_True;
}

/*************************************************************************
|*
|*    SvTreeList::
|*
|*    Beschreibung
|*    Ersterstellung    17.08.94
|*    Letzte Aenderung  17.08.94
|*
*************************************************************************/

sal_uLong SvTreeList::SelectChilds(SvListView* pView, SvListEntry* pParent,sal_Bool bSelect )
{
	DBG_ASSERT(pView&&pParent,"SelChilds:View/Parent?");
	if ( !pParent->pChilds )
		return 0;
	if ( pParent->pChilds->Count() == 0 )
		return 0;

	sal_uInt16 nRefDepth = GetDepth( pParent );
	sal_uInt16 nDepth = nRefDepth;
	sal_uLong nCount = 0;
	pParent = Next( pParent );
	do
	{
		if ( Select( pView, pParent, bSelect ) )
			nCount++; // nur die tatsaechlichen Selektierungen zaehlen
		pParent = Next( pParent, &nDepth );
	}
	while( pParent && nDepth > nRefDepth );
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
	return nCount;
}

void SvTreeList::SelectAll( SvListView* pView, sal_Bool bSelect )
{
	DBG_ASSERT(pView,"SelectAll:NoView");
	SvListEntry* pEntry = First();
	while ( pEntry )
	{
		SvViewData* pViewData = pView->GetViewData( pEntry );
		if ( bSelect )
			pViewData->nFlags |= SVLISTENTRYFLAG_SELECTED;
		else
			pViewData->nFlags &= (~SVLISTENTRYFLAG_SELECTED);

		pEntry = Next( pEntry );
	}
	if ( bSelect )
		pView->nSelectionCount = nEntryCount;
	else
		pView->nSelectionCount = 0;
#ifdef CHECK_INTEGRITY
CheckIntegrity();
#endif
}


SvListEntry* SvTreeList::GetEntryAtAbsPos( sal_uLong nAbsPos ) const
{
	SvListEntry* pEntry = First();
	while ( nAbsPos && pEntry )
	{
		pEntry = Next( pEntry );
		nAbsPos--;
	}
	return pEntry;
}

SvListEntry* SvTreeList::GetEntryAtVisPos( const SvListView* pView, sal_uLong nVisPos ) const
{
	DBG_ASSERT(pView,"GetEntryAtVisPos:No View");
	SvListEntry* pEntry = First();
	while ( nVisPos && pEntry )
	{
		pEntry = NextVisible( pView, pEntry );
		nVisPos--;
	}
	return pEntry;
}

void SvTreeList::SetListPositions( SvTreeEntryList* pList )
{
	if( pList->Count() )
	{
		SvListEntry* pEntry = (SvListEntry*)(pList->GetObject(0));
		if( pEntry->pParent )
			pEntry->pParent->InvalidateChildrensListPositions();
	}
	/*
	sal_uLong nListPos = 0;
	SvListEntry* pEntry = (SvListEntry*)(pList->First());
	while( pEntry )
	{
		pEntry->nListPos = nListPos;
		nListPos++;
		pEntry = (SvListEntry*)(pList->Next());
	}
	*/
}


void SvTreeList::InvalidateEntry( SvListEntry* pEntry )
{
	Broadcast( LISTACTION_INVALIDATE_ENTRY, pEntry );
}

sal_Bool SvTreeList::IsInChildList( SvListEntry* pParent, SvListEntry* pChild) const
{
	if ( !pParent )
		pParent = pRootItem;
	sal_Bool bIsChild = sal_False;
	if ( pParent->pChilds )
		bIsChild = (sal_Bool)(pParent->pChilds->GetPos(pChild) != LIST_ENTRY_NOTFOUND);
	return bIsChild;
}


void lcl_CheckList( SvTreeEntryList* pList )
{
	SvListEntry* pEntry = (SvListEntry*)(pList->First());
	sal_uLong nPos = 0;
	while ( pEntry )
	{
		DBG_ASSERT(pEntry->GetChildListPos()==nPos,"Wrong ListPos");
		pEntry = (SvListEntry*)(pList->Next());
		nPos++;
	}
}

void SvTreeList::CheckIntegrity() const
{
	sal_uLong nMyEntryCount = 0;
	if ( pRootItem->pChilds )
	{
		lcl_CheckList( pRootItem->pChilds );
		SvListEntry* pEntry = First();
		while( pEntry )
		{
			nMyEntryCount++;
			if ( pEntry->pChilds )
				lcl_CheckList( pEntry->pChilds );
			pEntry = Next( pEntry );
		}
	}
	DBG_ASSERT(nMyEntryCount==GetEntryCount(),"Entry count invalid");
}

SvListEntry* SvTreeList::GetRootLevelParent( SvListEntry* pEntry ) const
{
	DBG_ASSERT(pEntry,"GetRootLevelParent:No Entry");
	SvListEntry* pCurParent = 0;
	if ( pEntry )
	{
		pCurParent = pEntry->pParent;
		if ( pCurParent == pRootItem )
			return pEntry; // ist sein eigener Parent
		while( pCurParent && pCurParent->pParent != pRootItem )
			pCurParent = pCurParent->pParent;
	}
	return pCurParent;
}




//*************************************************************************
//*************************************************************************
//*************************************************************************
//*************************************************************************
//*************************************************************************
//*************************************************************************
//*************************************************************************
//*************************************************************************

DBG_NAME(SvListView);

SvListView::SvListView( SvTreeList* pModell )
{
	DBG_CTOR(SvListView,0);
	pModel = 0;
	nSelectionCount = 0;
	nVisibleCount = 0;
	bVisPositionsValid = sal_False;
	SetModel( pModell );
}

SvListView::SvListView()
{
	DBG_CTOR(SvListView,0);
	pModel = 0;
	nSelectionCount = 0;
	nVisibleCount = 0;
	bVisPositionsValid = sal_False;
}


SvListView::~SvListView()
{
	DBG_DTOR(SvListView,0);
	ClearTable();
}

void SvListView::InitTable()
{
	DBG_CHKTHIS(SvListView,0);
	DBG_ASSERT(pModel,"InitTable:No Model");
	DBG_ASSERT(!nSelectionCount&&!nVisibleCount&&!bVisPositionsValid,"InitTable: Not cleared!");

	if( aDataTable.Count() )
	{
		DBG_ASSERT(aDataTable.Count()==1,"InitTable: TableCount != 1");
		// die im Clear fuer die Root allozierten View-Daten loeschen
		// Achtung: Das zu dem RootEntry (und damit auch der Entry)
		// gehoerende Model kann bereits geloescht sein!
		SvViewData* pViewData = (SvViewData*)aDataTable.GetObject( 0 );
		delete pViewData;
		aDataTable.Clear();
	}

	SvListEntry* pEntry;
	SvViewData* pViewData;

	// RootEntry einfuegen
	pEntry = pModel->pRootItem;
	pViewData = new SvViewData;
	pViewData->nFlags = SVLISTENTRYFLAG_EXPANDED;
	aDataTable.Insert( (sal_uLong)pEntry, pViewData );
	// Jetzt alle anderen Entries
	pEntry = pModel->First();
	while( pEntry )
	{
		pViewData = CreateViewData( pEntry );
		DBG_ASSERT(pViewData,"InitTable:No ViewData");
		InitViewData( pViewData, pEntry );
		aDataTable.Insert( (sal_uLong)pEntry, pViewData );
		pEntry = pModel->Next( pEntry );
	}
}

SvViewData* SvListView::CreateViewData( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
	return new SvViewData;
}

void SvListView::ClearTable()
{
	DBG_CHKTHIS(SvListView,0);
	SvViewData* pViewData = (SvViewData*)aDataTable.First();
	while( pViewData )
	{
		delete pViewData;
		pViewData = (SvViewData*)aDataTable.Next();
	}
	aDataTable.Clear();
}

void SvListView::Clear()
{
	ClearTable();
	nSelectionCount = 0;
	nVisibleCount = 0;
	bVisPositionsValid = sal_False;
	if( pModel )
	{
		// RootEntry einfuegen
		SvListEntry* pEntry = pModel->pRootItem;
		SvViewData* pViewData = new SvViewData;
		pViewData->nFlags = SVLISTENTRYFLAG_EXPANDED;
		aDataTable.Insert( (sal_uLong)pEntry, pViewData );
	}
}

void SvListView::SetModel( SvTreeList* pNewModel )
{
	DBG_CHKTHIS(SvListView,0);
	sal_Bool bBroadcastCleared = sal_False;
	if ( pModel )
	{
		pModel->RemoveView( this );
		bBroadcastCleared = sal_True;
		ModelNotification( LISTACTION_CLEARING,0,0,0 );
		if ( pModel->GetRefCount() == 0 )
			delete pModel;
	}
	pModel = pNewModel;
	InitTable();
	pNewModel->InsertView( this );
	if( bBroadcastCleared )
		ModelNotification( LISTACTION_CLEARED,0,0,0 );
}


void SvListView::ModelHasCleared()
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelHasInserted( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelHasInsertedTree( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelIsMoving( SvListEntry* /*  pSource */ ,
	SvListEntry* /* pTargetParent */ ,	sal_uLong /* nPos */	)
{
	DBG_CHKTHIS(SvListView,0);
}


void SvListView::ModelHasMoved( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelIsRemoving( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelHasRemoved( SvListEntry* )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ModelHasEntryInvalidated( SvListEntry*)
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ActionMoving( SvListEntry* pEntry,SvListEntry*,sal_uLong)
{
	DBG_CHKTHIS(SvListView,0);
	SvListEntry* pParent = pEntry->pParent;
	DBG_ASSERT(pParent,"Model not consistent");
	if( pParent != pModel->pRootItem && pParent->pChilds->Count() == 1 )
	{
		SvViewData* pViewData = (SvViewData*)aDataTable.Get( (sal_uLong)pParent );
		pViewData->nFlags &= (~SVLISTENTRYFLAG_EXPANDED);
	}
	// vorlaeufig
	nVisibleCount = 0;
	bVisPositionsValid = sal_False;
}

void SvListView::ActionMoved( SvListEntry* /* pEntry */ ,
							SvListEntry* /* pTargetPrnt */ ,
							sal_uLong /* nChildPos */ )
{
	DBG_CHKTHIS(SvListView,0);
	nVisibleCount = 0;
	bVisPositionsValid = sal_False;
}

void SvListView::ActionInserted( SvListEntry* pEntry )
{
	DBG_CHKTHIS(SvListView,0);
	DBG_ASSERT(pEntry,"Insert:No Entry");
	SvViewData* pData = CreateViewData( pEntry );
	InitViewData( pData, pEntry );
    #ifdef DBG_UTIL
	sal_Bool bSuccess =
    #endif
        aDataTable.Insert( (sal_uLong)pEntry, pData );
	DBG_ASSERT(bSuccess,"Entry already in View");
	if ( nVisibleCount && pModel->IsEntryVisible( this, pEntry ))
	{
		nVisibleCount = 0;
		bVisPositionsValid = sal_False;
	}
}

void SvListView::ActionInsertedTree( SvListEntry* pEntry )
{
	DBG_CHKTHIS(SvListView,0);
	if ( pModel->IsEntryVisible( this, pEntry ))
	{
		nVisibleCount = 0;
		bVisPositionsValid = sal_False;
	}
	// ueber Entry und seine Childs iterieren
	SvListEntry* pCurEntry = pEntry;
	sal_uInt16 nRefDepth = pModel->GetDepth( pCurEntry );
	while( pCurEntry )
	{
		DBG_ASSERT(aDataTable.Get((sal_uLong)pCurEntry)==0,"Entry already in Table");
		SvViewData* pViewData = CreateViewData( pCurEntry );
		DBG_ASSERT(pViewData,"No ViewData");
		InitViewData( pViewData, pEntry );
		aDataTable.Insert( (sal_uLong)pCurEntry, pViewData );
		pCurEntry = pModel->Next( pCurEntry );
		if ( pCurEntry && pModel->GetDepth(pCurEntry) <= nRefDepth)
			pCurEntry = 0;
	}
}

void SvListView::RemoveViewData( SvListEntry* pParent )
{
	SvTreeEntryList* pChilds = pParent->pChilds;
	if( pChilds )
	{
		SvListEntry* pCur = (SvListEntry*)pChilds->First();
		while( pCur )
		{
			SvViewData* pViewData = (SvViewData*)aDataTable.Get((sal_uLong)pCur);
			delete pViewData;
			aDataTable.Remove( (sal_uLong)pCur );
			if( pCur->HasChilds())
				RemoveViewData( pCur );
			pCur = (SvListEntry*)pChilds->Next();
		}
	}
}



void SvListView::ActionRemoving( SvListEntry* pEntry )
{
	DBG_CHKTHIS(SvListView,0);
	DBG_ASSERT(pEntry,"Remove:No Entry");

	SvViewData* pViewData = (SvViewData*)aDataTable.Get( (sal_uLong)pEntry );
	sal_uLong nSelRemoved = 0;
	if ( pViewData->IsSelected() )
		nSelRemoved = 1 + pModel->GetChildSelectionCount( this, pEntry );
	nSelectionCount -= nSelRemoved;
	sal_uLong nVisibleRemoved = 0;
	if ( pModel->IsEntryVisible( this, pEntry ) )
		nVisibleRemoved = 1 + pModel->GetVisibleChildCount( this, pEntry );
	if( nVisibleCount )
	{
#ifdef DBG_UTIL
		if( nVisibleCount < nVisibleRemoved )
		{
			DBG_ERROR("nVisibleRemoved bad");
		}
#endif
		nVisibleCount -= nVisibleRemoved;
	}
	bVisPositionsValid = sal_False;

	pViewData = (SvViewData*)aDataTable.Get((sal_uLong)pEntry);
	delete pViewData;
	aDataTable.Remove( (sal_uLong)pEntry );
	RemoveViewData( pEntry );

	SvListEntry* pCurEntry = pEntry->pParent;
	if ( pCurEntry && pCurEntry != pModel->pRootItem &&
		 pCurEntry->pChilds->Count() == 1 )
	{
		pViewData = (SvViewData*)aDataTable.Get((sal_uLong)pCurEntry);
		pViewData->nFlags &= (~SVLISTENTRYFLAG_EXPANDED);
	}
}

void SvListView::ActionRemoved( SvListEntry* /* pEntry  */ )
{
	DBG_CHKTHIS(SvListView,0);
}

void SvListView::ActionClear()
{
	DBG_CHKTHIS(SvListView,0);
	Clear();
}

void SvListView::ModelNotification( sal_uInt16 nActionId, SvListEntry* pEntry1,
						SvListEntry* pEntry2, sal_uLong nPos )
{
	DBG_CHKTHIS(SvListView,0);
	switch( nActionId )
	{
		case LISTACTION_INSERTED:
			ActionInserted( pEntry1 );
			ModelHasInserted( pEntry1 );
			break;
		case LISTACTION_INSERTED_TREE:
			ActionInsertedTree( pEntry1 );
			ModelHasInsertedTree( pEntry1 );
			break;
		case LISTACTION_REMOVING:
			ModelIsRemoving( pEntry1 );
			ActionRemoving( pEntry1 );
			break;
		case LISTACTION_REMOVED:
			ActionRemoved( pEntry1 );
			ModelHasRemoved( pEntry1 );
			break;
		case LISTACTION_MOVING:
			ModelIsMoving( pEntry1, pEntry2, nPos );
			ActionMoving( pEntry1, pEntry2, nPos );
			break;
		case LISTACTION_MOVED:
			ActionMoved( pEntry1, pEntry2, nPos );
			ModelHasMoved( pEntry1 );
			break;
		case LISTACTION_CLEARING:
			ActionClear();
			ModelHasCleared(); //sic! wg. Kompatibilitaet!
			break;
		case LISTACTION_CLEARED:
			break;
		case LISTACTION_INVALIDATE_ENTRY:
			// keine Action fuer die Basisklasse
			ModelHasEntryInvalidated( pEntry1 );
			break;
		case LISTACTION_RESORTED:
			bVisPositionsValid = sal_False;
			break;
		case LISTACTION_RESORTING:
			break;
		default:
			DBG_ERROR("unknown ActionId");
	}
}

void SvListView::InitViewData( SvViewData*, SvListEntry* )
{
}

StringCompare SvTreeList::Compare( SvListEntry* pLeft, SvListEntry* pRight) const
{
	if( aCompareLink.IsSet())
	{
		SvSortData aSortData;
		aSortData.pLeft = pLeft;
		aSortData.pRight = pRight;
		return (StringCompare)aCompareLink.Call( &aSortData );
	}
	return COMPARE_EQUAL;
}

void SvTreeList::Resort()
{
	Broadcast( LISTACTION_RESORTING );
	bAbsPositionsValid = sal_False;
	ResortChilds( pRootItem );
	Broadcast( LISTACTION_RESORTED );
}

void SvTreeList::ResortChilds( SvListEntry* pParent )
{
	DBG_ASSERT(pParent,"Parent not set");
	List* pChildList = pParent->pChilds;
	if( !pChildList )
		return;
	List aList( *pChildList );
	pChildList->Clear();

	sal_uLong nCount = aList.Count();
	for( sal_uLong nCur = 0; nCur < nCount; nCur++ )
	{
		SvListEntry* pCurEntry = (SvListEntry*)aList.GetObject( nCur );
		sal_uLong nListPos = LIST_APPEND;
		GetInsertionPos( pCurEntry, pParent, nListPos );
		pChildList->Insert( pCurEntry, nListPos );
		if( pCurEntry->pChilds )
			ResortChilds( pCurEntry );
	}
	SetListPositions( (SvTreeEntryList*)pChildList );
}

void SvTreeList::GetInsertionPos( SvListEntry* pEntry, SvListEntry* pParent,
	sal_uLong& rPos )
{
	DBG_ASSERT(pEntry,"No Entry");

	if( eSortMode == SortNone )
		return;

	rPos = LIST_APPEND;
	SvTreeEntryList* pChildList = GetChildList( pParent );

	if( pChildList && pChildList->Count() )
	{
		long i = 0;
		long j = pChildList->Count()-1;
		long k;
		StringCompare eCompare = COMPARE_GREATER;

		do
		{
			k = (i+j)/2;
			SvListEntry* pTempEntry = (SvListEntry*)(pChildList->GetObject(k));
			eCompare = Compare( pEntry, pTempEntry );
			if( eSortMode == SortDescending && eCompare != COMPARE_EQUAL )
			{
				if( eCompare == COMPARE_LESS )
					eCompare = COMPARE_GREATER;
				else
					eCompare = COMPARE_LESS;
			}
			if( eCompare == COMPARE_GREATER )
				i = k + 1;
			else
				j = k - 1;
		} while( (eCompare != COMPARE_EQUAL) && (i <= j) );

		if( eCompare != COMPARE_EQUAL )
		{
			if(i > ((long)pChildList->Count() - 1)) // nicht gefunden, Ende der Liste
				rPos = LIST_APPEND;
			else
				rPos = i;              // nicht gefunden, Mitte
		}
		else
			rPos = k;
	}
}