--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/aknhlist/src/akntreeiterator.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,227 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation for the TAknTreeIterator class.
+*
+*/
+
+
+#include "akntreeiterator.h"
+#include "akntreenode.h"
+
+/** Flag indicating that the next item is stored in the iterator. */
+const TUint KNextItemCached = 0x8000;
+
+/** Flag indicating that the previous item is stored in the iterator. */
+const TUint KPreviousItemCached = 0x4000;
+
+/** Bitmask specifying which flags can be given as parameters. */
+const TUint KAllowedParameters = KAknSkipCollapsedNodeContents;
+
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Copy constructor.
+// ---------------------------------------------------------------------------
+//
+TAknTreeIterator::TAknTreeIterator( const TAknTreeIterator& aIterator )
+ : iCurrent( aIterator.iCurrent ),
+ iRoot( aIterator.iRoot ),
+ iNext( aIterator.iNext ),
+ iPrevious( aIterator.iPrevious ),
+ iFlags( aIterator.iFlags )
+ {
+ }
+
+
+TBool TAknTreeIterator::HasNext() const
+ {
+ return FindNext() ? ETrue : EFalse;
+ }
+
+
+CAknTreeItem* TAknTreeIterator::Next()
+ {
+ CAknTreeItem* next = FindNext();
+
+ iPrevious = iCurrent;
+ iCurrent = next;
+ iFlags = ( iFlags & KAllowedParameters ) | KPreviousItemCached;
+
+ return next;
+ }
+
+
+TBool TAknTreeIterator::HasPrevious() const
+ {
+ return FindPrevious() ? ETrue : EFalse;
+ }
+
+
+CAknTreeItem* TAknTreeIterator::Previous()
+ {
+ CAknTreeItem* previous = FindPrevious();
+
+ iNext = iCurrent;
+ iCurrent = previous;
+ iFlags = ( iFlags & KAllowedParameters ) | KNextItemCached;
+
+ return previous;
+ }
+
+
+CAknTreeItem* TAknTreeIterator::First() const
+ {
+ CAknTreeItem* first = NULL;
+ if ( iRoot && iRoot->ChildCount() )
+ {
+ first = iRoot->Child( 0 );
+ }
+ return first;
+ }
+
+
+CAknTreeItem* TAknTreeIterator::Last() const
+ {
+ CAknTreeItem* last = NULL;
+ if ( iRoot && iRoot->ChildCount() )
+ {
+ CAknTreeItem* child = iRoot->Child( iRoot->ChildCount() - 1 );
+ while ( child->IsNode() && child->Node()->ChildCount() &&
+ ( !( iFlags & KAknSkipCollapsedNodeContents ) ||
+ child->Node()->IsExpanded() ) )
+ {
+ child = child->Node()->Child( child->Node()->ChildCount() - 1 );
+ }
+ last = child;
+ }
+ return last;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Changes the item iterator is currently pointing at.
+// Note: This method does not check that the item is in the iterated subtree!
+// ---------------------------------------------------------------------------
+//
+void TAknTreeIterator::SetCurrent( CAknTreeItem* aCurrent )
+ {
+ iCurrent = aCurrent;
+ // The cached next and previous items are no longer valid.
+ iFlags = iFlags & KAllowedParameters;
+ }
+
+
+TAknTreeIterator::TAknTreeIterator( CAknTreeNode* aRoot, TUint aFlags )
+ : iCurrent( aRoot ),
+ iRoot( aRoot ),
+ iNext( NULL ),
+ iPrevious( NULL ),
+ iFlags( ( aFlags & KAllowedParameters ) | KPreviousItemCached )
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// TAknTreeIterator::FindNext()
+// Non-recursive algorithm for searching the next item from the tree.
+// The returned value is NULL, if the next item is not found.
+// ---------------------------------------------------------------------------
+//
+CAknTreeItem* TAknTreeIterator::FindNext() const
+ {
+ CAknTreeItem* next = NULL;
+ if ( iFlags & KNextItemCached )
+ {
+ next = iNext;
+ }
+ else
+ {
+ CAknTreeNode* node = iCurrent ? iCurrent->Node() : NULL;
+ if ( node && node->ChildCount() &&
+ ( node->IsExpanded() || !( iFlags & KAknSkipCollapsedNodeContents ) ) )
+ {
+ next = node->Child( 0 );
+ }
+ else
+ {
+ CAknTreeItem* item = iCurrent;
+ TBool found = EFalse;
+ while ( item && item != iRoot && !found )
+ {
+ CAknTreeNode* parent = item->Parent();
+ if ( parent )
+ {
+ TInt index = parent->Index( item );
+ if ( index >= 0 && index < parent->ChildCount() - 1 )
+ {
+ next = parent->Child( index + 1 );
+ found = ETrue;
+ }
+ }
+
+ item = parent;
+ }
+ }
+ iNext = next;
+ iFlags |= KNextItemCached;
+ }
+ return next;
+ }
+
+
+// ---------------------------------------------------------------------------
+// TAknTreeIterator::FindPrevious()
+// Non-recursive algorithm for searching the previous item for the tree.
+// The returned value is NULL, if the previous item is not found.
+// ---------------------------------------------------------------------------
+//
+CAknTreeItem* TAknTreeIterator::FindPrevious() const
+ {
+ CAknTreeItem* previous = NULL;
+ if ( iFlags & KPreviousItemCached )
+ {
+ previous = iPrevious;
+ }
+ else if ( iCurrent )
+ {
+ CAknTreeItem* item = iCurrent;
+ CAknTreeNode* parent = item->Parent();
+ if ( parent )
+ {
+ TInt index = parent->Index( item );
+ if ( index > 0 )
+ {
+ CAknTreeItem* tmp = parent->Child( index - 1 );
+ while ( tmp->Node() && tmp->Node()->ChildCount() &&
+ ( tmp->Node()->IsExpanded() ||
+ !( iFlags & KAknSkipCollapsedNodeContents ) ) )
+ {
+ tmp = tmp->Node()->Child( tmp->Node()->ChildCount() - 1 );
+ }
+ previous = tmp;
+ }
+ else
+ {
+ if ( parent != iRoot )
+ {
+ previous = parent;
+ }
+ }
+ }
+ iPrevious = previous;
+ iFlags |= KPreviousItemCached;
+ }
+ return previous;
+ }