svtools/source/contnr/treelist.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "svtools/treelist.hxx"
  21 #include "svtools/treelistentry.hxx"
  22 #include "svtools/viewdataentry.hxx"
  23 #include "osl/diagnose.h"
  24
  25 #include <stdio.h>
  26
  27 SvTreeList::SvTreeList()
  28 {
  29     nEntryCount = 0;
  30     bAbsPositionsValid = sal_False;
  31     nRefCount = 1;
  32     pRootItem = new SvTreeListEntry;
  33     eSortMode = SortNone;
  34 }
  35
  36 SvTreeList::~SvTreeList()
  37 {
  38     Clear();
  39     delete pRootItem;
  40 #ifdef DBG_UTIL
  41     pRootItem = 0;
  42 #endif
  43 }
  44
  45 void SvTreeList::Broadcast(
  46     sal_uInt16 nActionId,
  47     SvTreeListEntry* pEntry1,
  48     SvTreeListEntry* pEntry2,
  49     sal_uLong nPos
  50 ) {
  51     sal_uLong nViewCount = aViewList.size();
  52     for( sal_uLong nCurView = 0; nCurView < nViewCount; nCurView++ )
  53     {
  54         SvListView* pView = aViewList[ nCurView ];
  55         if( pView )
  56             pView->ModelNotification( nActionId, pEntry1, pEntry2, nPos );
  57     }
  58 }
  59
  60 void SvTreeList::InsertView( SvListView* pView )
  61 {
  62     for ( sal_uLong i = 0, n = aViewList.size(); i < n; ++i ) {
  63         if ( aViewList[ i ] == pView ) {
  64             return;
  65         }
  66     }
  67     aViewList.push_back( pView );
  68     nRefCount++;
  69 }
  70
  71 void SvTreeList::RemoveView( SvListView* pView )
  72 {
  73     for ( ListViewsType::iterator it = aViewList.begin(); it != aViewList.end(); ++it )
  74     {
  75         if ( *it == pView )
  76         {
  77             aViewList.erase( it );
  78             --nRefCount;
  79             break;
  80         }
  81     }
  82 }
  83
  84
  85 // an entry is visible if all parents are expanded
  86 sal_Bool SvTreeList::IsEntryVisible( const SvListView* pView, SvTreeListEntry* pEntry ) const
  87 {
  88     DBG_ASSERT(pView&&pEntry,"IsVisible:Invalid Params");
  89     sal_Bool bRetVal=sal_False;
  90     do
  91     {
  92         if ( pEntry == pRootItem )
  93         {
  94             bRetVal=sal_True;
  95             break;
  96         }
  97         pEntry = pEntry->pParent;
  98     }  while( pView->IsExpanded( pEntry ) );
  99     return bRetVal;
 100 }
 101
 102 sal_uInt16 SvTreeList::GetDepth( const SvTreeListEntry* pEntry ) const
 103 {
 104     DBG_ASSERT(pEntry&&pEntry!=pRootItem,"GetDepth:Bad Entry");
 105     sal_uInt16 nDepth = 0;
 106     while( pEntry->pParent != pRootItem )
 107     {
 108         nDepth++;
 109         pEntry = pEntry->pParent;
 110     }
 111     return nDepth;
 112 }
 113
 114 bool SvTreeList::IsAtRootDepth( const SvTreeListEntry* pEntry ) const
 115 {
 116     return pEntry->pParent == pRootItem;
 117 }
 118
 119 void SvTreeList::Clear()
 120 {
 121     Broadcast( LISTACTION_CLEARING );
 122     pRootItem->ClearChildren();
 123     nEntryCount = 0;
 124     Broadcast( LISTACTION_CLEARED );
 125 }
 126
 127 bool SvTreeList::IsChild(const SvTreeListEntry* pParent, const SvTreeListEntry* pChild) const
 128 {
 129     if ( !pParent )
 130         pParent = pRootItem;
 131
 132     if (pParent->maChildren.empty())
 133         return false;
 134
 135     SvTreeListEntries::const_iterator it = pParent->maChildren.begin(), itEnd = pParent->maChildren.end();
 136     for (; it != itEnd; ++it)
 137     {
 138         const SvTreeListEntry* pThis = &(*it);
 139         if (pThis == pChild)
 140             return true;
 141         else
 142         {
 143             bool bIsChild = IsChild(pThis, pChild);
 144             if (bIsChild)
 145                 return true;
 146         }
 147     }
 148     return false;
 149 }
 150
 151 namespace {
 152
 153 class FindByPointer : std::unary_function<SvTreeListEntry, bool>
 154 {
 155     const SvTreeListEntry* mpEntry;
 156 public:
 157     FindByPointer(const SvTreeListEntry* p) : mpEntry(p) {}
 158
 159     bool operator() (const SvTreeListEntry& rEntry) const
 160     {
 161         return mpEntry == &rEntry;
 162     }
 163 };
 164
 165 sal_uLong findEntryPosition(const SvTreeListEntries& rDst, const SvTreeListEntry* pEntry)
 166 {
 167     SvTreeListEntries::const_iterator itPos = std::find_if(rDst.begin(), rDst.end(), FindByPointer(pEntry));
 168     if (itPos == rDst.end())
 169         return static_cast<sal_uLong>(~0);
 170
 171     return static_cast<sal_uLong>(std::distance(rDst.begin(), itPos));
 172 }
 173
 174 }
 175
 176 sal_uLong SvTreeList::Move(SvTreeListEntry* pSrcEntry,SvTreeListEntry* pTargetParent,sal_uLong nListPos)
 177 {
 178     // pDest may be 0!
 179     DBG_ASSERT(pSrcEntry,"Entry?");
 180     if ( !pTargetParent )
 181         pTargetParent = pRootItem;
 182     DBG_ASSERT(pSrcEntry!=pTargetParent,"Move:Source=Target");
 183
 184     Broadcast( LISTACTION_MOVING, pSrcEntry, pTargetParent, nListPos );
 185
 186     if ( pSrcEntry == pTargetParent )
 187         // You can't move an entry onto itself as the parent. Just return its
 188         // position and bail out.
 189         return pSrcEntry->GetChildListPos();
 190
 191     bAbsPositionsValid = false;
 192
 193     SvTreeListEntries& rDst = pTargetParent->maChildren;
 194     SvTreeListEntries& rSrc = pSrcEntry->pParent->maChildren;
 195
 196     bool bSameParent = pTargetParent == pSrcEntry->pParent;
 197
 198     // Find the position of the entry being moved in the source container.
 199     SvTreeListEntries::iterator itSrcPos = rSrc.begin(), itEnd = rSrc.end();
 200     for (; itSrcPos != itEnd; ++itSrcPos)
 201     {
 202         const SvTreeListEntry* p = &(*itSrcPos);
 203         if (p == pSrcEntry)
 204             // Found
 205             break;
 206     }
 207
 208     if (itSrcPos == itEnd)
 209     {
 210         OSL_FAIL("Source entry not found! This should never happen.");
 211         return pSrcEntry->GetChildListPos();
 212     }
 213
 214     if (bSameParent)
 215     {
 216         // Moving within the same parent.
 217
 218         size_t nSrcPos = std::distance(rSrc.begin(), itSrcPos);
 219         if (nSrcPos == nListPos)
 220             // Nothing to move here.
 221             return pSrcEntry->GetChildListPos();
 222
 223         if (nSrcPos < nListPos)
 224             // Destination position shifts left after removing the original.
 225             --nListPos;
 226
 227         // Release the original.
 228         SvTreeListEntries::auto_type p = rSrc.release(itSrcPos);
 229         // Determine the insertion position.
 230         SvTreeListEntries::iterator itDstPos = rSrc.end();
 231         if (nListPos < rSrc.size())
 232         {
 233             itDstPos = rSrc.begin();
 234             std::advance(itDstPos, nListPos);
 235         }
 236         rSrc.insert(itDstPos, p.release());
 237     }
 238     else
 239     {
 240         // Moving from one parent to another.
 241         SvTreeListEntries::iterator itDstPos = rDst.end();
 242         if (nListPos < rDst.size())
 243         {
 244             itDstPos = rDst.begin();
 245             std::advance(itDstPos, nListPos);
 246         }
 247         SvTreeListEntries::auto_type p = rSrc.release(itSrcPos);
 248         rDst.insert(itDstPos, p.release());
 249     }
 250
 251     // move parent umsetzen (do this only now, because we need the parent for
 252     // deleting the old child list!)
 253     pSrcEntry->pParent = pTargetParent;
 254
 255     // correct list position in target list
 256     SetListPositions(rDst);
 257     if (!bSameParent)
 258         SetListPositions(rSrc);
 259
 260     sal_uLong nRetVal = findEntryPosition(rDst, pSrcEntry);
 261     OSL_ENSURE(nRetVal == pSrcEntry->GetChildListPos(), "ListPos not valid");
 262     Broadcast( LISTACTION_MOVED,pSrcEntry,pTargetParent,nRetVal);
 263     return nRetVal;
 264 }
 265
 266 sal_uLong SvTreeList::Copy(SvTreeListEntry* pSrcEntry,SvTreeListEntry* pTargetParent,sal_uLong nListPos)
 267 {
 268     // pDest may be 0!
 269     DBG_ASSERT(pSrcEntry,"Entry?");
 270     if ( !pTargetParent )
 271         pTargetParent = pRootItem;
 272
 273     bAbsPositionsValid = sal_False;
 274
 275     sal_uLong nCloneCount = 0;
 276     SvTreeListEntry* pClonedEntry = Clone( pSrcEntry, nCloneCount );
 277     nEntryCount += nCloneCount;
 278
 279     SvTreeListEntries& rDst = pTargetParent->maChildren;
 280
 281     pClonedEntry->pParent = pTargetParent;      // move parent
 282
 283     if (nListPos < rDst.size())
 284     {
 285         SvTreeListEntries::iterator itPos = rDst.begin(); // insertion position.
 286         std::advance(itPos, nListPos);
 287         rDst.insert(itPos, pClonedEntry);
 288     }
 289     else
 290         rDst.push_back(pClonedEntry);
 291
 292     SetListPositions(rDst); // correct list position in target list
 293
 294     Broadcast( LISTACTION_INSERTED_TREE, pClonedEntry );
 295     sal_uLong nRetVal = findEntryPosition(rDst, pClonedEntry);
 296     return nRetVal;
 297 }
 298
 299 void SvTreeList::Move( SvTreeListEntry* pSrcEntry, SvTreeListEntry* pDstEntry )
 300 {
 301     SvTreeListEntry* pParent;
 302     sal_uLong nPos;
 303
 304     if ( !pDstEntry )
 305     {
 306         pParent = pRootItem;
 307         nPos = 0UL;
 308     }
 309     else
 310     {
 311         pParent = pDstEntry->pParent;
 312         nPos = pDstEntry->GetChildListPos();
 313         nPos++;  // (On screen:) insert _below_ pDstEntry
 314     }
 315     Move( pSrcEntry, pParent, nPos );
 316 }
 317
 318 void SvTreeList::InsertTree(SvTreeListEntry* pSrcEntry,
 319     SvTreeListEntry* pTargetParent,sal_uLong nListPos)
 320 {
 321     DBG_ASSERT(pSrcEntry,"InsertTree:Entry?");
 322     if ( !pSrcEntry )
 323         return;
 324
 325     if ( !pTargetParent )
 326         pTargetParent = pRootItem;
 327
 328     // take sorting into account
 329     GetInsertionPos( pSrcEntry, pTargetParent, nListPos );
 330
 331     bAbsPositionsValid = false;
 332
 333     pSrcEntry->pParent = pTargetParent; // move parent
 334     SvTreeListEntries& rDst = pTargetParent->maChildren;
 335
 336     if (nListPos < rDst.size())
 337     {
 338         SvTreeListEntries::iterator itPos = rDst.begin();
 339         std::advance(itPos, nListPos);
 340         rDst.insert(itPos, pSrcEntry);
 341     }
 342     else
 343         rDst.push_back(pSrcEntry);
 344
 345     SetListPositions(rDst); // correct list position in target list
 346     nEntryCount += GetChildCount( pSrcEntry );
 347     nEntryCount++; // the parent is new, too
 348
 349     Broadcast(LISTACTION_INSERTED_TREE, pSrcEntry );
 350 }
 351
 352 SvTreeListEntry* SvTreeList::CloneEntry( SvTreeListEntry* pSource ) const
 353 {
 354     if( aCloneLink.IsSet() )
 355         return (SvTreeListEntry*)aCloneLink.Call( pSource );
 356     SvTreeListEntry* pEntry = CreateEntry();
 357     pSource->Clone( pEntry );
 358     return pSource;
 359 }
 360
 361 SvTreeListEntry* SvTreeList::CreateEntry() const
 362 {
 363     return new SvTreeListEntry;
 364 }
 365
 366 SvTreeListEntry* SvTreeList::Clone( SvTreeListEntry* pEntry, sal_uLong& nCloneCount ) const
 367 {
 368     SvTreeListEntry* pClonedEntry = CloneEntry( pEntry );
 369     nCloneCount = 1;
 370     if (!pEntry->maChildren.empty())
 371         // Clone the child entries.
 372         CloneChildren(pClonedEntry->maChildren, nCloneCount, pEntry->maChildren, pClonedEntry);
 373
 374     return pClonedEntry;
 375 }
 376
 377 void SvTreeList::CloneChildren(
 378         SvTreeListEntries& rDst, sal_uLong& rCloneCount, SvTreeListEntries& rSrc, SvTreeListEntry* pNewParent) const
 379 {
 380     SvTreeListEntries aClone;
 381     SvTreeListEntries::iterator it = rSrc.begin(), itEnd = rSrc.end();
 382     for (; it != itEnd; ++it)
 383     {
 384         SvTreeListEntry& rEntry = *it;
 385         SvTreeListEntry* pNewEntry = CloneEntry(&rEntry);
 386         ++rCloneCount;
 387         pNewEntry->pParent = pNewParent;
 388         if (!rEntry.maChildren.empty())
 389             // Clone entries recursively.
 390             CloneChildren(pNewEntry->maChildren, rCloneCount, rEntry.maChildren, pNewEntry);
 391
 392         aClone.push_back(pNewEntry);
 393     }
 394
 395     rDst.swap(aClone);
 396 }
 397
 398 sal_uLong SvTreeList::GetChildCount( const SvTreeListEntry* pParent ) const
 399 {
 400     if ( !pParent )
 401         return GetEntryCount();
 402
 403     if (!pParent || pParent->maChildren.empty())
 404         return 0;
 405
 406     sal_uLong nCount = 0;
 407     sal_uInt16 nRefDepth = GetDepth( pParent );
 408     sal_uInt16 nActDepth = nRefDepth;
 409     do
 410     {
 411         pParent = Next(const_cast<SvTreeListEntry*>(pParent), &nActDepth);
 412         nCount++;
 413     } while( pParent && nRefDepth < nActDepth );
 414     nCount--;
 415     return nCount;
 416 }
 417
 418 sal_uLong SvTreeList::GetVisibleChildCount(const SvListView* pView, SvTreeListEntry* pParent) const
 419 {
 420     DBG_ASSERT(pView,"GetVisChildCount:No View");
 421     if ( !pParent )
 422         pParent = pRootItem;
 423
 424     if (!pParent || !pView->IsExpanded(pParent) || pParent->maChildren.empty())
 425         return 0;
 426
 427     sal_uLong nCount = 0;
 428     sal_uInt16 nRefDepth = GetDepth( pParent );
 429     sal_uInt16 nActDepth = nRefDepth;
 430     do
 431     {
 432         pParent = NextVisible( pView, pParent, &nActDepth );
 433         nCount++;
 434     } while( pParent && nRefDepth < nActDepth );
 435     nCount--;
 436     return nCount;
 437 }
 438
 439 sal_uLong SvTreeList::GetChildSelectionCount(const SvListView* pView,SvTreeListEntry* pParent) const
 440 {
 441     DBG_ASSERT(pView,"GetChildSelCount:No View");
 442     if ( !pParent )
 443         pParent = pRootItem;
 444
 445     if (!pParent || pParent->maChildren.empty())
 446         return 0;
 447
 448     sal_uLong nCount = 0;
 449     sal_uInt16 nRefDepth = GetDepth( pParent );
 450     sal_uInt16 nActDepth = nRefDepth;
 451     do
 452     {
 453         pParent = Next( pParent, &nActDepth );
 454         if( pParent && pView->IsSelected( pParent ) && nRefDepth < nActDepth)
 455             nCount++;
 456     } while( pParent && nRefDepth < nActDepth );
 457 //  nCount--;
 458     return nCount;
 459 }
 460
 461 SvTreeListEntry* SvTreeList::First() const
 462 {
 463     if ( nEntryCount )
 464         return &pRootItem->maChildren[0];
 465     else
 466         return 0;
 467 }
 468
 469 SvTreeListEntry* SvTreeList::Next( SvTreeListEntry* pActEntry, sal_uInt16* pDepth ) const
 470 {
 471     DBG_ASSERT( pActEntry && pActEntry->pParent, "SvTreeList::Next: invalid entry/parent!" );
 472     if ( !pActEntry || !pActEntry->pParent )
 473         return NULL;
 474
 475     sal_uInt16 nDepth = 0;
 476     bool bWithDepth = false;
 477     if ( pDepth )
 478     {
 479         nDepth = *pDepth;
 480         bWithDepth = true;
 481     }
 482
 483     // Get the list where the current entry belongs to (from its parent).
 484     SvTreeListEntries* pActualList = &pActEntry->pParent->maChildren;
 485     sal_uLong nActualPos = pActEntry->GetChildListPos();
 486
 487     if (!pActEntry->maChildren.empty())
 488     {
 489         // The current entry has children. Get its first child entry.
 490         nDepth++;
 491         pActEntry = &pActEntry->maChildren[0];
 492         if ( bWithDepth )
 493             *pDepth = nDepth;
 494         return pActEntry;
 495     }
 496
 497     if (pActualList->size() > (nActualPos+1))
 498     {
 499         // Get the next sibling of the current entry.
 500         pActEntry = &(*pActualList)[nActualPos+1];
 501         if ( bWithDepth )
 502             *pDepth = nDepth;
 503         return pActEntry;
 504     }
 505
 506     // Move up level(s) until we find the level where the next sibling exists.
 507     SvTreeListEntry* pParent = pActEntry->pParent;
 508     nDepth--;
 509     while( pParent != pRootItem && pParent != 0 )
 510     {
 511         DBG_ASSERT(pParent!=0,"TreeData corrupt!");
 512         pActualList = &pParent->pParent->maChildren;
 513         nActualPos = pParent->GetChildListPos();
 514         if (pActualList->size() > (nActualPos+1))
 515         {
 516             pActEntry = &(*pActualList)[nActualPos+1];
 517             if ( bWithDepth )
 518                 *pDepth = nDepth;
 519             return pActEntry;
 520         }
 521         pParent = pParent->pParent;
 522         nDepth--;
 523     }
 524     return 0;
 525 }
 526
 527 SvTreeListEntry* SvTreeList::Prev( SvTreeListEntry* pActEntry, sal_uInt16* pDepth ) const
 528 {
 529     DBG_ASSERT(pActEntry!=0,"Entry?");
 530
 531     sal_uInt16 nDepth = 0;
 532     int bWithDepth = sal_False;
 533     if ( pDepth )
 534     {
 535         nDepth = *pDepth;
 536         bWithDepth = sal_True;
 537     }
 538
 539     SvTreeListEntries* pActualList = &pActEntry->pParent->maChildren;
 540     sal_uLong nActualPos = pActEntry->GetChildListPos();
 541
 542     if ( nActualPos > 0 )
 543     {
 544         pActEntry = &(*pActualList)[nActualPos-1];
 545         while (!pActEntry->maChildren.empty())
 546         {
 547             pActualList = &pActEntry->maChildren;
 548             nDepth++;
 549             pActEntry = &pActualList->back();
 550         }
 551         if ( bWithDepth )
 552             *pDepth = nDepth;
 553         return pActEntry;
 554     }
 555     if ( pActEntry->pParent == pRootItem )
 556         return 0;
 557
 558     pActEntry = pActEntry->pParent;
 559
 560     if ( pActEntry )
 561     {
 562         nDepth--;
 563         if ( bWithDepth )
 564             *pDepth = nDepth;
 565         return pActEntry;
 566     }
 567     return 0;
 568 }
 569
 570 SvTreeListEntry* SvTreeList::Last() const
 571 {
 572     SvTreeListEntries* pActList = &pRootItem->maChildren;
 573     SvTreeListEntry* pEntry = NULL;
 574     while (!pActList->empty())
 575     {
 576         pEntry = &pActList->back();
 577         pActList = &pEntry->maChildren;
 578     }
 579     return pEntry;
 580 }
 581
 582 sal_uLong SvTreeList::GetVisiblePos( const SvListView* pView, SvTreeListEntry* pEntry ) const
 583 {
 584     DBG_ASSERT(pView&&pEntry,"View/Entry?");
 585
 586     if ( !pView->bVisPositionsValid )
 587     {
 588         // to make GetVisibleCount refresh the positions
 589         ((SvListView*)pView)->nVisibleCount = 0;
 590         GetVisibleCount( const_cast<SvListView*>(pView) );
 591     }
 592     const SvViewDataEntry* pViewData = pView->GetViewData( pEntry );
 593     return pViewData->nVisPos;
 594 }
 595
 596 sal_uLong SvTreeList::GetVisibleCount( SvListView* pView ) const
 597 {
 598     DBG_ASSERT(pView,"GetVisCount:No View");
 599     if( !pView->HasViewData() )
 600         return 0;
 601     if ( pView->nVisibleCount )
 602         return pView->nVisibleCount;
 603
 604     sal_uLong nPos = 0;
 605     SvTreeListEntry* pEntry = First();  // first entry is always visible
 606     while ( pEntry )
 607     {
 608         SvViewDataEntry* pViewData = pView->GetViewData( pEntry );
 609         pViewData->nVisPos = nPos;
 610         nPos++;
 611         pEntry = NextVisible( pView, pEntry );
 612     }
 613 #ifdef DBG_UTIL
 614     if( nPos > 10000000 )
 615     {
 616         OSL_FAIL("nVisibleCount bad");
 617     }
 618 #endif
 619     ((SvListView*)pView)->nVisibleCount = nPos;
 620     ((SvListView*)pView)->bVisPositionsValid = sal_True;
 621     return nPos;
 622 }
 623
 624
 625 // For performance reasons, this function assumes that the passed entry is
 626 // already visible.
 627 SvTreeListEntry* SvTreeList::NextVisible(const SvListView* pView,SvTreeListEntry* pActEntry,sal_uInt16* pActDepth) const
 628 {
 629     DBG_ASSERT(pView,"NextVisible:No View");
 630     if ( !pActEntry )
 631         return 0;
 632
 633     sal_uInt16 nDepth = 0;
 634     int bWithDepth = sal_False;
 635     if ( pActDepth )
 636     {
 637         nDepth = *pActDepth;
 638         bWithDepth = sal_True;
 639     }
 640
 641     SvTreeListEntries* pActualList = &pActEntry->pParent->maChildren;
 642     sal_uLong nActualPos = pActEntry->GetChildListPos();
 643
 644     if ( pView->IsExpanded(pActEntry) )
 645     {
 646         OSL_ENSURE(!pActEntry->maChildren.empty(), "Pass entry is supposed to have child entries.");
 647
 648         nDepth++;
 649         pActEntry = &pActEntry->maChildren[0];
 650         if ( bWithDepth )
 651             *pActDepth = nDepth;
 652         return pActEntry;
 653     }
 654
 655     nActualPos++;
 656     if ( pActualList->size() > nActualPos  )
 657     {
 658         pActEntry = &(*pActualList)[nActualPos];
 659         if ( bWithDepth )
 660             *pActDepth = nDepth;
 661         return pActEntry;
 662     }
 663
 664     SvTreeListEntry* pParent = pActEntry->pParent;
 665     nDepth--;
 666     while( pParent != pRootItem )
 667     {
 668         pActualList = &pParent->pParent->maChildren;
 669         nActualPos = pParent->GetChildListPos();
 670         nActualPos++;
 671         if ( pActualList->size() > nActualPos )
 672         {
 673             pActEntry = &(*pActualList)[nActualPos];
 674             if ( bWithDepth )
 675                 *pActDepth = nDepth;
 676             return pActEntry;
 677         }
 678         pParent = pParent->pParent;
 679         nDepth--;
 680     }
 681     return 0;
 682 }
 683
 684
 685 // For performance reasons, this function assumes that the passed entry is
 686 // already visible.
 687
 688 SvTreeListEntry* SvTreeList::PrevVisible(const SvListView* pView, SvTreeListEntry* pActEntry, sal_uInt16* pActDepth) const
 689 {
 690     DBG_ASSERT(pView&&pActEntry,"PrevVis:View/Entry?");
 691
 692     sal_uInt16 nDepth = 0;
 693     int bWithDepth = sal_False;
 694     if ( pActDepth )
 695     {
 696         nDepth = *pActDepth;
 697         bWithDepth = sal_True;
 698     }
 699
 700     SvTreeListEntries* pActualList = &pActEntry->pParent->maChildren;
 701     sal_uLong nActualPos = pActEntry->GetChildListPos();
 702
 703     if ( nActualPos > 0 )
 704     {
 705         pActEntry = &(*pActualList)[nActualPos-1];
 706         while( pView->IsExpanded(pActEntry) )
 707         {
 708             pActualList = &pActEntry->maChildren;
 709             nDepth++;
 710             pActEntry = &pActualList->back();
 711         }
 712         if ( bWithDepth )
 713             *pActDepth = nDepth;
 714         return pActEntry;
 715     }
 716
 717     if ( pActEntry->pParent == pRootItem )
 718         return 0;
 719
 720     pActEntry = pActEntry->pParent;
 721     if ( pActEntry )
 722     {
 723         nDepth--;
 724         if ( bWithDepth )
 725             *pActDepth = nDepth;
 726         return pActEntry;
 727     }
 728     return 0;
 729 }
 730
 731 SvTreeListEntry* SvTreeList::LastVisible( const SvListView* pView, sal_uInt16* pDepth) const
 732 {
 733     DBG_ASSERT(pView,"LastVis:No View");
 734     SvTreeListEntry* pEntry = Last();
 735     while( pEntry && !IsEntryVisible( pView, pEntry ) )
 736         pEntry = PrevVisible( pView, pEntry );
 737     if ( pEntry && pDepth )
 738         *pDepth = GetDepth( pEntry );
 739     return pEntry;
 740 }
 741
 742 SvTreeListEntry* SvTreeList::NextVisible(const SvListView* pView,SvTreeListEntry* pEntry,sal_uInt16& nDelta) const
 743 {
 744     DBG_ASSERT(pView&&pEntry&&IsEntryVisible(pView,pEntry),"NextVis:Wrong Prms/!Vis");
 745
 746     sal_uLong nVisPos = GetVisiblePos( pView, pEntry );
 747     // nDelta entries existent?
 748     // example: 0,1,2,3,4,5,6,7,8,9 nVisPos=5 nDelta=7
 749     //           nNewDelta = 10-nVisPos-1 == 4
 750     if (  nVisPos+nDelta >= pView->nVisibleCount )
 751     {
 752         nDelta = (sal_uInt16)(pView->nVisibleCount-nVisPos);
 753         nDelta--;
 754     }
 755     sal_uInt16 nDeltaTmp = nDelta;
 756     while( nDeltaTmp )
 757     {
 758         pEntry = NextVisible( pView, pEntry );
 759         nDeltaTmp--;
 760         DBG_ASSERT(pEntry,"Entry?");
 761     }
 762     return pEntry;
 763 }
 764
 765 SvTreeListEntry* SvTreeList::PrevVisible( const SvListView* pView, SvTreeListEntry* pEntry, sal_uInt16& nDelta ) const
 766 {
 767     DBG_ASSERT(pView&&pEntry&&IsEntryVisible(pView,pEntry),"PrevVis:Parms/!Vis");
 768
 769     sal_uLong nVisPos = GetVisiblePos( pView, pEntry );
 770     // nDelta entries existent?
 771     // example: 0,1,2,3,4,5,6,7,8,9 nVisPos=8 nDelta=20
 772     //           nNewDelta = nNewVisPos
 773     if (  nDelta > nVisPos )
 774         nDelta = (sal_uInt16)nVisPos;
 775     sal_uInt16 nDeltaTmp = nDelta;
 776     while( nDeltaTmp )
 777     {
 778         pEntry = PrevVisible( pView, pEntry );
 779         nDeltaTmp--;
 780         DBG_ASSERT(pEntry,"Entry?");
 781     }
 782     return pEntry;
 783 }
 784
 785 SvTreeListEntry* SvTreeList::FirstSelected( const SvListView* pView) const
 786 {
 787     DBG_ASSERT(pView,"FirstSel:No View");
 788     if( !pView )
 789         return 0;
 790     SvTreeListEntry* pActSelEntry = First();
 791     while( pActSelEntry && !pView->IsSelected(pActSelEntry) )
 792         pActSelEntry = NextVisible( pView, pActSelEntry );
 793     return pActSelEntry;
 794 }
 795
 796
 797 SvTreeListEntry* SvTreeList::FirstChild( SvTreeListEntry* pParent ) const
 798 {
 799     if ( !pParent )
 800         pParent = pRootItem;
 801     SvTreeListEntry* pResult;
 802     if (!pParent->maChildren.empty())
 803         pResult = &pParent->maChildren[0];
 804     else
 805         pResult = 0;
 806     return pResult;
 807 }
 808
 809 SvTreeListEntry* SvTreeList::NextSibling( SvTreeListEntry* pEntry ) const
 810 {
 811     DBG_ASSERT(pEntry,"Entry?");
 812     if( !pEntry )
 813         return 0;
 814
 815     SvTreeListEntries& rList = pEntry->pParent->maChildren;
 816     sal_uLong nPos = pEntry->GetChildListPos();
 817     nPos++;
 818     return nPos < rList.size() ? &rList[nPos] : NULL;
 819 }
 820
 821 SvTreeListEntry* SvTreeList::PrevSibling( SvTreeListEntry* pEntry ) const
 822 {
 823     DBG_ASSERT(pEntry,"Entry?");
 824     if( !pEntry )
 825         return 0;
 826
 827     SvTreeListEntries& rList = pEntry->pParent->maChildren;
 828     sal_uLong nPos = pEntry->GetChildListPos();
 829     if ( nPos == 0 )
 830         return 0;
 831     nPos--;
 832     pEntry = &rList[nPos];
 833     return pEntry;
 834 }
 835
 836
 837 SvTreeListEntry* SvTreeList::LastSibling( SvTreeListEntry* pEntry ) const
 838 {
 839     DBG_ASSERT(pEntry,"LastSibling:Entry?");
 840     if( !pEntry )
 841         return 0;
 842
 843     SvTreeListEntries& rChildren = pEntry->pParent->maChildren;
 844     return rChildren.empty() ? NULL : &rChildren.back();
 845 }
 846
 847 SvTreeListEntry* SvTreeList::NextSelected( const SvListView* pView, SvTreeListEntry* pEntry ) const
 848 {
 849     DBG_ASSERT(pView&&pEntry,"NextSel:View/Entry?");
 850     pEntry = Next( pEntry );
 851     while( pEntry && !pView->IsSelected(pEntry) )
 852         pEntry = Next( pEntry );
 853     return pEntry;
 854 }
 855
 856 SvTreeListEntry* SvTreeList::PrevSelected( const SvListView* pView, SvTreeListEntry* pEntry) const
 857 {
 858     DBG_ASSERT(pView&&pEntry,"PrevSel:View/Entry?");
 859     pEntry = Prev( pEntry );
 860     while( pEntry && !pView->IsSelected(pEntry) )
 861         pEntry = Prev( pEntry );
 862
 863     return pEntry;
 864 }
 865
 866 SvTreeListEntry* SvTreeList::LastSelected( const SvListView* pView ) const
 867 {
 868     DBG_ASSERT(pView,"LastSel:No View");
 869     SvTreeListEntry* pEntry = Last();
 870     while( pEntry && !pView->IsSelected(pEntry) )
 871         pEntry = Prev( pEntry );
 872     return pEntry;
 873 }
 874
 875 sal_uLong SvTreeList::Insert( SvTreeListEntry* pEntry,SvTreeListEntry* pParent,sal_uLong nPos )
 876 {
 877     DBG_ASSERT( pEntry,"Entry?");
 878
 879     if ( !pParent )
 880         pParent = pRootItem;
 881
 882
 883     SvTreeListEntries& rList = pParent->maChildren;
 884
 885     // take sorting into account
 886     GetInsertionPos( pEntry, pParent, nPos );
 887
 888     bAbsPositionsValid = false;
 889     pEntry->pParent = pParent;
 890
 891     if (nPos < rList.size())
 892     {
 893         SvTreeListEntries::iterator itPos = rList.begin();
 894         std::advance(itPos, nPos);
 895         rList.insert(itPos, pEntry);
 896     }
 897     else
 898         rList.push_back(pEntry);
 899
 900     nEntryCount++;
 901     if (nPos != ULONG_MAX && (nPos != (rList.size()-1)))
 902         SetListPositions(rList);
 903     else
 904         pEntry->nListPos = rList.size()-1;
 905
 906     Broadcast( LISTACTION_INSERTED, pEntry );
 907     return nPos; // pEntry->nListPos;
 908 }
 909
 910 sal_uLong SvTreeList::GetAbsPos( const SvTreeListEntry* pEntry) const
 911 {
 912     if ( !bAbsPositionsValid )
 913         ((SvTreeList*)this)->SetAbsolutePositions();
 914     return pEntry->nAbsPos;
 915 }
 916
 917 sal_uLong SvTreeList::GetRelPos( const SvTreeListEntry* pChild ) const
 918 {
 919     return pChild->GetChildListPos();
 920 }
 921
 922 void SvTreeList::SetAbsolutePositions()
 923 {
 924     sal_uLong nPos = 0;
 925     SvTreeListEntry* pEntry = First();
 926     while ( pEntry )
 927     {
 928         pEntry->nAbsPos = nPos;
 929         nPos++;
 930         pEntry = Next( pEntry );
 931     }
 932     bAbsPositionsValid = true;
 933 }
 934
 935 void SvTreeList::Expand( SvListView* pView, SvTreeListEntry* pEntry )
 936 {
 937     DBG_ASSERT(pEntry&&pView,"Expand:View/Entry?");
 938     if ( pView->IsExpanded(pEntry) )
 939         return;
 940
 941     DBG_ASSERT(!pEntry->maChildren.empty(), "SvTreeList::Expand: We expected to have child entries.");
 942
 943     SvViewDataEntry* pViewData = pView->GetViewData(pEntry);
 944     pViewData->SetExpanded(true);
 945     SvTreeListEntry* pParent = pEntry->pParent;
 946     // if parent is visible, invalidate status data
 947     if ( pView->IsExpanded( pParent ) )
 948     {
 949         pView->bVisPositionsValid = sal_False;
 950         pView->nVisibleCount = 0;
 951     }
 952 }
 953
 954 void SvTreeList::Collapse( SvListView* pView, SvTreeListEntry* pEntry )
 955 {
 956     DBG_ASSERT(pView&&pEntry,"Collapse:View/Entry?");
 957     if ( !pView->IsExpanded(pEntry) )
 958         return;
 959
 960     DBG_ASSERT(!pEntry->maChildren.empty(), "SvTreeList::Collapse: We expected have child entries.");
 961
 962     SvViewDataEntry* pViewData = pView->GetViewData( pEntry );
 963     pViewData->SetExpanded(false);
 964
 965     SvTreeListEntry* pParent = pEntry->pParent;
 966     if ( pView->IsExpanded(pParent) )
 967     {
 968         pView->nVisibleCount = 0;
 969         pView->bVisPositionsValid = sal_False;
 970     }
 971 }
 972
 973 sal_Bool SvTreeList::Select( SvListView* pView, SvTreeListEntry* pEntry, sal_Bool bSelect )
 974 {
 975     DBG_ASSERT(pView&&pEntry,"Select:View/Entry?");
 976     SvViewDataEntry* pViewData = pView->GetViewData( pEntry );
 977     if ( bSelect )
 978     {
 979         if ( pViewData->IsSelected() || !pViewData->IsSelectable() )
 980             return sal_False;
 981         else
 982         {
 983             pViewData->SetSelected(true);
 984             pView->nSelectionCount++;
 985         }
 986     }
 987     else
 988     {
 989         if ( !pViewData->IsSelected() )
 990             return sal_False;
 991         else
 992         {
 993             pViewData->SetSelected(false);
 994             pView->nSelectionCount--;
 995         }
 996     }
 997     return sal_True;
 998 }
 999
1000 bool SvTreeList::Remove( const SvTreeListEntry* pEntry )
1001 {
1002     DBG_ASSERT(pEntry,"Cannot remove root, use clear");
1003
1004     if( !pEntry->pParent )
1005     {
1006         OSL_FAIL("Removing entry not in model!");
1007         // Under certain circumstances (which?), the explorer deletes entries
1008         // from the view that it hasn't inserted into the view. We don't want
1009         // to crash, so we catch this case here.
1010         return sal_False;
1011     }
1012
1013     Broadcast(LISTACTION_REMOVING, const_cast<SvTreeListEntry*>(pEntry));
1014     sal_uLong nRemoved = 1 + GetChildCount(pEntry);
1015     bAbsPositionsValid = false;
1016
1017     SvTreeListEntry* pParent = pEntry->pParent;
1018     SvTreeListEntries& rList = pParent->maChildren;
1019     bool bLastEntry = false;
1020
1021     // Since we need the live instance of SvTreeListEntry for broadcasting,
1022     // we first need to pop it from the container, broadcast it, then delete
1023     // the instance manually at the end.
1024
1025     if ( pEntry->HasChildListPos() )
1026     {
1027         size_t nListPos = pEntry->GetChildListPos();
1028         bLastEntry = (nListPos == (rList.size()-1)) ? true : false;
1029         SvTreeListEntries::iterator it = rList.begin();
1030         std::advance(it, nListPos);
1031         rList.release(it).release();
1032     }
1033     else
1034     {
1035         SvTreeListEntries::iterator it =
1036             std::find_if(rList.begin(), rList.end(), FindByPointer(pEntry));
1037         if (it != rList.end())
1038             rList.release(it).release();
1039     }
1040
1041     if (!rList.empty() && !bLastEntry)
1042         SetListPositions(rList);
1043
1044     nEntryCount -= nRemoved;
1045     Broadcast(LISTACTION_REMOVED, const_cast<SvTreeListEntry*>(pEntry));
1046     delete pEntry;
1047
1048     return true;
1049 }
1050
1051 void SvTreeList::SelectAll( SvListView* pView, sal_Bool bSelect )
1052 {
1053     DBG_ASSERT(pView,"SelectAll:NoView");
1054     SvTreeListEntry* pEntry = First();
1055     while ( pEntry )
1056     {
1057         SvViewDataEntry* pViewData = pView->GetViewData( pEntry );
1058         pViewData->SetSelected(bSelect);
1059         pEntry = Next( pEntry );
1060     }
1061     if ( bSelect )
1062         pView->nSelectionCount = nEntryCount;
1063     else
1064         pView->nSelectionCount = 0;
1065 }
1066
1067
1068 SvTreeListEntry* SvTreeList::GetEntryAtAbsPos( sal_uLong nAbsPos ) const
1069 {
1070     SvTreeListEntry* pEntry = First();
1071     while ( nAbsPos && pEntry )
1072     {
1073         pEntry = Next( pEntry );
1074         nAbsPos--;
1075     }
1076     return pEntry;
1077 }
1078
1079 SvTreeListEntry* SvTreeList::GetEntryAtVisPos( const SvListView* pView, sal_uLong nVisPos ) const
1080 {
1081     DBG_ASSERT(pView,"GetEntryAtVisPos:No View");
1082     SvTreeListEntry* pEntry = First();
1083     while ( nVisPos && pEntry )
1084     {
1085         pEntry = NextVisible( pView, pEntry );
1086         nVisPos--;
1087     }
1088     return pEntry;
1089 }
1090
1091 void SvTreeList::SetListPositions( SvTreeListEntries& rEntries )
1092 {
1093     if (rEntries.empty())
1094         return;
1095
1096     SvTreeListEntry& rFirst = rEntries.front();
1097     if (rFirst.pParent)
1098         rFirst.pParent->InvalidateChildrensListPositions();
1099 }
1100
1101 void SvTreeList::InvalidateEntry( SvTreeListEntry* pEntry )
1102 {
1103     Broadcast( LISTACTION_INVALIDATE_ENTRY, pEntry );
1104 }
1105
1106 SvTreeListEntry* SvTreeList::GetRootLevelParent( SvTreeListEntry* pEntry ) const
1107 {
1108     DBG_ASSERT(pEntry,"GetRootLevelParent:No Entry");
1109     SvTreeListEntry* pCurParent = 0;
1110     if ( pEntry )
1111     {
1112         pCurParent = pEntry->pParent;
1113         if ( pCurParent == pRootItem )
1114             return pEntry; // is its own parent
1115         while( pCurParent && pCurParent->pParent != pRootItem )
1116             pCurParent = pCurParent->pParent;
1117     }
1118     return pCurParent;
1119 }
1120
1121 std::pair<SvTreeListEntries::iterator, SvTreeListEntries::iterator>
1122     SvTreeList::GetChildIterators(SvTreeListEntry* pParent)
1123 {
1124     typedef std::pair<SvTreeListEntries::iterator, SvTreeListEntries::iterator> IteratorPair;
1125
1126     static SvTreeListEntries dummy; // prevent singular iterator asserts
1127     IteratorPair aRet(dummy.begin(), dummy.end());
1128
1129     if (!pParent)
1130         pParent = pRootItem;
1131
1132     if (pParent->maChildren.empty())
1133         // This entry has no children.
1134         return aRet;
1135
1136     aRet.first = pParent->maChildren.begin();
1137     aRet.second = pParent->maChildren.end();
1138
1139     return aRet;
1140 }
1141
1142 DBG_NAME(SvListView);
1143
1144 SvListView::SvListView()
1145 {
1146     DBG_CTOR(SvListView,0);
1147     pModel = 0;
1148     nSelectionCount = 0;
1149     nVisibleCount = 0;
1150     bVisPositionsValid = sal_False;
1151 }
1152
1153
1154 SvListView::~SvListView()
1155 {
1156     DBG_DTOR(SvListView,0);
1157     maDataTable.clear();
1158 }
1159
1160 void SvListView::InitTable()
1161 {
1162     DBG_CHKTHIS(SvListView,0);
1163     DBG_ASSERT(pModel,"InitTable:No Model");
1164     DBG_ASSERT(!nSelectionCount&&!nVisibleCount&&!bVisPositionsValid,"InitTable: Not cleared!");
1165
1166     if( maDataTable.size() )
1167     {
1168         DBG_ASSERT(maDataTable.size()==1,"InitTable: TableCount != 1");
1169         // Delete the view data allocated to the Clear in the root.
1170         // Attention: The model belonging to the root entry (and thus the entry
1171         // itself) might already be deleted.
1172         maDataTable.clear();
1173     }
1174
1175     SvTreeListEntry* pEntry;
1176     SvViewDataEntry* pViewData;
1177
1178     // insert root entry
1179     pEntry = pModel->pRootItem;
1180     pViewData = new SvViewDataEntry;
1181     pViewData->SetExpanded(true);
1182     maDataTable.insert( pEntry, pViewData );
1183     // now all the other entries
1184     pEntry = pModel->First();
1185     while( pEntry )
1186     {
1187         pViewData = CreateViewData( pEntry );
1188         DBG_ASSERT(pViewData,"InitTable:No ViewData");
1189         InitViewData( pViewData, pEntry );
1190         maDataTable.insert( pEntry, pViewData );
1191         pEntry = pModel->Next( pEntry );
1192     }
1193 }
1194
1195 SvViewDataEntry* SvListView::CreateViewData( SvTreeListEntry* )
1196 {
1197     DBG_CHKTHIS(SvListView,0);
1198     return new SvViewDataEntry;
1199 }
1200
1201 void SvListView::Clear()
1202 {
1203     maDataTable.clear();
1204     nSelectionCount = 0;
1205     nVisibleCount = 0;
1206     bVisPositionsValid = sal_False;
1207     if( pModel )
1208     {
1209         // insert root entry
1210         SvTreeListEntry* pEntry = pModel->pRootItem;
1211         SvViewDataEntry* pViewData = new SvViewDataEntry;
1212         pViewData->SetExpanded(true);
1213         maDataTable.insert( pEntry, pViewData );
1214     }
1215 }
1216
1217 void SvListView::SetModel( SvTreeList* pNewModel )
1218 {
1219     DBG_CHKTHIS(SvListView,0);
1220     sal_Bool bBroadcastCleared = sal_False;
1221     if ( pModel )
1222     {
1223         pModel->RemoveView( this );
1224         bBroadcastCleared = sal_True;
1225         ModelNotification( LISTACTION_CLEARING,0,0,0 );
1226         if ( pModel->GetRefCount() == 0 )
1227             delete pModel;
1228     }
1229     pModel = pNewModel;
1230     InitTable();
1231     pNewModel->InsertView( this );
1232     if( bBroadcastCleared )
1233         ModelNotification( LISTACTION_CLEARED,0,0,0 );
1234 }
1235
1236
1237 void SvListView::ModelHasCleared()
1238 {
1239     DBG_CHKTHIS(SvListView,0);
1240 }
1241
1242 void SvListView::ModelHasInserted( SvTreeListEntry* )
1243 {
1244     DBG_CHKTHIS(SvListView,0);
1245 }
1246
1247 void SvListView::ModelHasInsertedTree( SvTreeListEntry* )
1248 {
1249     DBG_CHKTHIS(SvListView,0);
1250 }
1251
1252 void SvListView::ModelIsMoving( SvTreeListEntry* /*  pSource */ ,
1253     SvTreeListEntry* /* pTargetParent */ ,  sal_uLong /* nPos */    )
1254 {
1255     DBG_CHKTHIS(SvListView,0);
1256 }
1257
1258
1259 void SvListView::ModelHasMoved( SvTreeListEntry* )
1260 {
1261     DBG_CHKTHIS(SvListView,0);
1262 }
1263
1264 void SvListView::ModelIsRemoving( SvTreeListEntry* )
1265 {
1266     DBG_CHKTHIS(SvListView,0);
1267 }
1268
1269 void SvListView::ModelHasRemoved( SvTreeListEntry* )
1270 {
1271     //WARNING WARNING WARNING
1272     //The supplied pointer should have been deleted
1273     //before this call. Be careful not to use it!!!
1274     DBG_CHKTHIS(SvListView,0);
1275 }
1276
1277 void SvListView::ModelHasEntryInvalidated( SvTreeListEntry*)
1278 {
1279     DBG_CHKTHIS(SvListView,0);
1280 }
1281
1282 void SvListView::ActionMoving( SvTreeListEntry* pEntry,SvTreeListEntry*,sal_uLong)
1283 {
1284     DBG_CHKTHIS(SvListView,0);
1285     SvTreeListEntry* pParent = pEntry->pParent;
1286     DBG_ASSERT(pParent,"Model not consistent");
1287     if (pParent != pModel->pRootItem && pParent->maChildren.size() == 1)
1288     {
1289         SvViewDataEntry* pViewData = maDataTable.find( pParent )->second;
1290         pViewData->SetExpanded(false);
1291     }
1292     // vorlaeufig
1293     nVisibleCount = 0;
1294     bVisPositionsValid = sal_False;
1295 }
1296
1297 void SvListView::ActionMoved( SvTreeListEntry* /* pEntry */ ,
1298                             SvTreeListEntry* /* pTargetPrnt */ ,
1299                             sal_uLong /* nChildPos */ )
1300 {
1301     DBG_CHKTHIS(SvListView,0);
1302     nVisibleCount = 0;
1303     bVisPositionsValid = sal_False;
1304 }
1305
1306 void SvListView::ActionInserted( SvTreeListEntry* pEntry )
1307 {
1308     DBG_CHKTHIS(SvListView,0);
1309     DBG_ASSERT(pEntry,"Insert:No Entry");
1310     SvViewDataEntry* pData = CreateViewData( pEntry );
1311     InitViewData( pData, pEntry );
1312     #ifdef DBG_UTIL
1313     std::pair<SvDataTable::iterator, bool> aSuccess =
1314     #endif
1315         maDataTable.insert( pEntry, pData );
1316     DBG_ASSERT(aSuccess.second,"Entry already in View");
1317     if ( nVisibleCount && pModel->IsEntryVisible( this, pEntry ))
1318     {
1319         nVisibleCount = 0;
1320         bVisPositionsValid = sal_False;
1321     }
1322 }
1323
1324 void SvListView::ActionInsertedTree( SvTreeListEntry* pEntry )
1325 {
1326     DBG_CHKTHIS(SvListView,0);
1327     if ( pModel->IsEntryVisible( this, pEntry ))
1328     {
1329         nVisibleCount = 0;
1330         bVisPositionsValid = sal_False;
1331     }
1332     // iterate over entry and its children
1333     SvTreeListEntry* pCurEntry = pEntry;
1334     sal_uInt16 nRefDepth = pModel->GetDepth( pCurEntry );
1335     while( pCurEntry )
1336     {
1337         DBG_ASSERT(maDataTable.find(pCurEntry) != maDataTable.end(),"Entry already in Table");
1338         SvViewDataEntry* pViewData = CreateViewData( pCurEntry );
1339         DBG_ASSERT(pViewData,"No ViewData");
1340         InitViewData( pViewData, pEntry );
1341         maDataTable.insert( pCurEntry, pViewData );
1342         pCurEntry = pModel->Next( pCurEntry );
1343         if ( pCurEntry && pModel->GetDepth(pCurEntry) <= nRefDepth)
1344             pCurEntry = 0;
1345     }
1346 }
1347
1348 void SvListView::RemoveViewData( SvTreeListEntry* pParent )
1349 {
1350     SvTreeListEntries::iterator it = pParent->maChildren.begin(), itEnd = pParent->maChildren.end();
1351     for (; it != itEnd; ++it)
1352     {
1353         SvTreeListEntry& rEntry = *it;
1354         maDataTable.erase(&rEntry);
1355         if (rEntry.HasChildren())
1356             RemoveViewData(&rEntry);
1357     }
1358 }
1359
1360
1361
1362 void SvListView::ActionRemoving( SvTreeListEntry* pEntry )
1363 {
1364     DBG_CHKTHIS(SvListView,0);
1365     DBG_ASSERT(pEntry,"Remove:No Entry");
1366
1367     SvViewDataEntry* pViewData = maDataTable.find( pEntry )->second;
1368     sal_uLong nSelRemoved = 0;
1369     if ( pViewData->IsSelected() )
1370         nSelRemoved = 1 + pModel->GetChildSelectionCount( this, pEntry );
1371     nSelectionCount -= nSelRemoved;
1372     sal_uLong nVisibleRemoved = 0;
1373     if ( pModel->IsEntryVisible( this, pEntry ) )
1374         nVisibleRemoved = 1 + pModel->GetVisibleChildCount( this, pEntry );
1375     if( nVisibleCount )
1376     {
1377 #ifdef DBG_UTIL
1378         if( nVisibleCount < nVisibleRemoved )
1379         {
1380             OSL_FAIL("nVisibleRemoved bad");
1381         }
1382 #endif
1383         nVisibleCount -= nVisibleRemoved;
1384     }
1385     bVisPositionsValid = sal_False;
1386
1387     maDataTable.erase(pEntry);
1388     RemoveViewData( pEntry );
1389
1390     SvTreeListEntry* pCurEntry = pEntry->pParent;
1391     if (pCurEntry && pCurEntry != pModel->pRootItem && pCurEntry->maChildren.size() == 1)
1392     {
1393         pViewData = maDataTable.find(pCurEntry)->second;
1394         pViewData->SetExpanded(false);
1395     }
1396 }
1397
1398 void SvListView::ActionRemoved( SvTreeListEntry* /* pEntry  */ )
1399 {
1400     DBG_CHKTHIS(SvListView,0);
1401 }
1402
1403 void SvListView::ActionClear()
1404 {
1405     DBG_CHKTHIS(SvListView,0);
1406     Clear();
1407 }
1408
1409 void SvListView::ModelNotification( sal_uInt16 nActionId, SvTreeListEntry* pEntry1,
1410                         SvTreeListEntry* pEntry2, sal_uLong nPos )
1411 {
1412     DBG_CHKTHIS(SvListView,0);
1413     switch( nActionId )
1414     {
1415         case LISTACTION_INSERTED:
1416             ActionInserted( pEntry1 );
1417             ModelHasInserted( pEntry1 );
1418             break;
1419         case LISTACTION_INSERTED_TREE:
1420             ActionInsertedTree( pEntry1 );
1421             ModelHasInsertedTree( pEntry1 );
1422             break;
1423         case LISTACTION_REMOVING:
1424             ModelIsRemoving( pEntry1 );
1425             ActionRemoving( pEntry1 );
1426             break;
1427         case LISTACTION_REMOVED:
1428             ActionRemoved( pEntry1 );
1429             ModelHasRemoved( pEntry1 );
1430             break;
1431         case LISTACTION_MOVING:
1432             ModelIsMoving( pEntry1, pEntry2, nPos );
1433             ActionMoving( pEntry1, pEntry2, nPos );
1434             break;
1435         case LISTACTION_MOVED:
1436             ActionMoved( pEntry1, pEntry2, nPos );
1437             ModelHasMoved( pEntry1 );
1438             break;
1439         case LISTACTION_CLEARING:
1440             ActionClear();
1441             ModelHasCleared(); // sic! for compatibility reasons!
1442             break;
1443         case LISTACTION_CLEARED:
1444             break;
1445         case LISTACTION_INVALIDATE_ENTRY:
1446             // no action for the base class
1447             ModelHasEntryInvalidated( pEntry1 );
1448             break;
1449         case LISTACTION_RESORTED:
1450             bVisPositionsValid = sal_False;
1451             break;
1452         case LISTACTION_RESORTING:
1453             break;
1454         default:
1455             OSL_FAIL("unknown ActionId");
1456     }
1457 }
1458
1459 void SvListView::InitViewData( SvViewDataEntry*, SvTreeListEntry* )
1460 {
1461 }
1462
1463 sal_Bool SvListView::IsExpanded( SvTreeListEntry* pEntry ) const
1464 {
1465     DBG_ASSERT(pEntry,"IsExpanded:No Entry");
1466     SvDataTable::const_iterator itr = maDataTable.find(pEntry);
1467     DBG_ASSERT(itr != maDataTable.end(),"Entry not in Table");
1468     if (itr == maDataTable.end())
1469         return false;
1470     return itr->second->IsExpanded();
1471 }
1472
1473 sal_Bool SvListView::IsSelected( SvTreeListEntry* pEntry ) const
1474 {
1475     DBG_ASSERT(pEntry,"IsExpanded:No Entry");
1476     SvDataTable::const_iterator itr = maDataTable.find(pEntry );
1477     if (itr == maDataTable.end())
1478         return false;
1479     return itr->second->IsSelected();
1480 }
1481
1482 void SvListView::SetEntryFocus( SvTreeListEntry* pEntry, sal_Bool bFocus )
1483 {
1484     DBG_ASSERT(pEntry,"SetEntryFocus:No Entry");
1485     SvDataTable::iterator itr = maDataTable.find(pEntry);
1486     DBG_ASSERT(itr != maDataTable.end(),"Entry not in Table");
1487     itr->second->SetFocus(bFocus);
1488 }
1489
1490 const SvViewDataEntry* SvListView::GetViewData( const SvTreeListEntry* pEntry ) const
1491 {
1492     SvDataTable::const_iterator itr = maDataTable.find( const_cast<SvTreeListEntry*>(pEntry) );
1493     if (itr == maDataTable.end())
1494         return NULL;
1495     return itr->second;
1496 }
1497
1498 SvViewDataEntry* SvListView::GetViewData( SvTreeListEntry* pEntry )
1499 {
1500     SvDataTable::iterator itr = maDataTable.find( pEntry );
1501     DBG_ASSERT(itr != maDataTable.end(),"Entry not in model or wrong view");
1502     return itr->second;
1503 }
1504
1505 sal_Int32 SvTreeList::Compare(const SvTreeListEntry* pLeft, const SvTreeListEntry* pRight) const
1506 {
1507     if( aCompareLink.IsSet())
1508     {
1509         SvSortData aSortData;
1510         aSortData.pLeft = pLeft;
1511         aSortData.pRight = pRight;
1512         return aCompareLink.Call( &aSortData );
1513     }
1514     return 0;
1515 }
1516
1517 void SvTreeList::Resort()
1518 {
1519     Broadcast( LISTACTION_RESORTING );
1520     bAbsPositionsValid = sal_False;
1521     ResortChildren( pRootItem );
1522     Broadcast( LISTACTION_RESORTED );
1523 }
1524
1525 void SvTreeList::ResortChildren( SvTreeListEntry* pParent )
1526 {
1527     DBG_ASSERT(pParent,"Parent not set");
1528
1529     if (pParent->maChildren.empty())
1530         return;
1531
1532     // TODO: Re-implement this using ptr_vector's sort method.
1533
1534     std::vector<SvTreeListEntry*> aStore; // Temporarily store entries.
1535     aStore.reserve(pParent->maChildren.size());
1536     {
1537         SvTreeListEntries::iterator it = pParent->maChildren.begin(), itEnd = pParent->maChildren.end();
1538         for (; it != itEnd; ++it)
1539         {
1540             SvTreeListEntry* p = &(*it);
1541             aStore.push_back(p);
1542         }
1543     }
1544     pParent->maChildren.release().release(); // Release all stored entries and empty the container.
1545
1546     std::vector<SvTreeListEntry*>::iterator it = aStore.begin(), itEnd = aStore.end();
1547     for (; it != itEnd; ++it)
1548     {
1549         SvTreeListEntry* p = *it;
1550         sal_uLong nListPos = ULONG_MAX;
1551         GetInsertionPos(p, pParent, nListPos);
1552         if (nListPos < pParent->maChildren.size())
1553         {
1554             SvTreeListEntries::iterator itPos = pParent->maChildren.begin();
1555             std::advance(itPos, nListPos);
1556             pParent->maChildren.insert(itPos, p);
1557         }
1558         else
1559             pParent->maChildren.push_back(p);
1560         if (!p->maChildren.empty())
1561             // Recursively sort child entries.
1562             ResortChildren(p);
1563     }
1564     SetListPositions(pParent->maChildren); // correct list position in target list
1565 }
1566
1567 void SvTreeList::GetInsertionPos( SvTreeListEntry* pEntry, SvTreeListEntry* pParent,
1568     sal_uLong& rPos )
1569 {
1570     DBG_ASSERT(pEntry,"No Entry");
1571
1572     if( eSortMode == SortNone )
1573         return;
1574
1575     rPos = ULONG_MAX;
1576     const SvTreeListEntries& rChildList = GetChildList(pParent);
1577
1578     if (!rChildList.empty())
1579     {
1580         long i = 0;
1581         long j = rChildList.size()-1;
1582         long k;
1583         sal_Int32 nCompare = 1;
1584
1585         do
1586         {
1587             k = (i+j)/2;
1588             const SvTreeListEntry* pTempEntry = &rChildList[k];
1589             nCompare = Compare( pEntry, pTempEntry );
1590             if( eSortMode == SortDescending && nCompare != 0 )
1591             {
1592                 if( nCompare < 0 )
1593                     nCompare = 1;
1594                 else
1595                     nCompare = -1;
1596             }
1597             if( nCompare > 0 )
1598                 i = k + 1;
1599             else
1600                 j = k - 1;
1601         } while( (nCompare != 0) && (i <= j) );
1602
1603         if( nCompare != 0 )
1604         {
1605             if (i > static_cast<long>(rChildList.size()-1)) // not found, end of list
1606                 rPos = ULONG_MAX;
1607             else
1608                 rPos = i;              // not found, middle of list
1609         }
1610         else
1611             rPos = k;
1612     }
1613 }
1614
1615 bool SvTreeList::HasChildren( const SvTreeListEntry* pEntry ) const
1616 {
1617     if ( !pEntry )
1618         pEntry = pRootItem;
1619
1620     return !pEntry->maChildren.empty();
1621 }
1622
1623 bool SvTreeList::HasParent( const SvTreeListEntry* pEntry ) const
1624 {
1625     return pEntry->pParent != pRootItem;
1626 }
1627
1628 SvTreeListEntry* SvTreeList::GetEntry( SvTreeListEntry* pParent, sal_uLong nPos ) const
1629 {   if ( !pParent )
1630         pParent = pRootItem;
1631     SvTreeListEntry* pRet = 0;
1632     if (nPos < pParent->maChildren.size())
1633         pRet = &pParent->maChildren[nPos];
1634     return pRet;
1635 }
1636
1637 SvTreeListEntry* SvTreeList::GetEntry( sal_uLong nRootPos ) const
1638 {
1639     SvTreeListEntry* pRet = 0;
1640     if ( nEntryCount && nRootPos < pRootItem->maChildren.size())
1641         pRet = &pRootItem->maChildren[nRootPos];
1642     return pRet;
1643 }
1644
1645 const SvTreeListEntries& SvTreeList::GetChildList( SvTreeListEntry* pParent ) const
1646 {
1647     if ( !pParent )
1648         pParent = pRootItem;
1649     return pParent->maChildren;
1650 }
1651
1652 SvTreeListEntries& SvTreeList::GetChildList( SvTreeListEntry* pParent )
1653 {
1654     if ( !pParent )
1655         pParent = pRootItem;
1656     return pParent->maChildren;
1657 }
1658
1659 const SvTreeListEntry* SvTreeList::GetParent( const SvTreeListEntry* pEntry ) const
1660 {
1661     const SvTreeListEntry* pParent = pEntry->pParent;
1662     if (pParent == pRootItem)
1663         pParent = NULL;
1664     return pParent;
1665 }
1666
1667 SvTreeListEntry* SvTreeList::GetParent( SvTreeListEntry* pEntry )
1668 {
1669     SvTreeListEntry* pParent = pEntry->pParent;
1670     if (pParent == pRootItem)
1671         pParent = NULL;
1672     return pParent;
1673 }
1674
1675 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */