diff -r 4ea6f81c838a -r 0e9bb658ef58 mulwidgets/muldatamodel/inc/multree.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mulwidgets/muldatamodel/inc/multree.h Wed Sep 01 12:23:18 2010 +0100 @@ -0,0 +1,333 @@ +/* +* Copyright (c) 2007-2008 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: Header for MulTree +* +*/ + + +#ifndef MULTREE_H_ +#define MULTREE_H_ + +#include +#include +#include + +namespace Alf + { +//Forward declaration +class MulDataPath; + +class MulTreeNode + { +public: + + /** + * Constuctor + * + * @param aIndex Index of this node + */ + MulTreeNode( int aIndex ) + { + mParent = NULL; + mExpandedState = false; + mIndex = aIndex; + } + + /** + * Constuctor + * + * @param aParent Parent node for this node. Node dosent take ownership of aParent + * @param aIndex Index of this node + */ + MulTreeNode( MulTreeNode* aParent, int aIndex ) + { + mParent = aParent; + mExpandedState = false; + mIndex = aIndex; + } + + /** + * Destructor + */ + ~MulTreeNode() + { + int count = mChilds.size(); + for(int i = 0 ; i < count ; ++i ) + { + delete Child(i); + } + mChilds.clear(); + } + + /** + * Insert child node in this node at given index + * + * @param aChild Child node.Takes ownership of aChild + * @param aIndex index at which child node to be inserted + */ + void InsertChild( std::auto_ptr aChild, int aIndex ) + { + aChild->mParent = this; + mChilds.insert( mChilds.begin() + aIndex, aChild.get() ); + aChild.release(); + } + + /** + * Remove child node from this node. + * + * @param aIndex Index of child that need to be removed + */ + void RemoveChild( int aIndex ) + { + MulTreeNode* childNode = Child(aIndex); + delete childNode; + childNode = NULL; + mChilds.erase( mChilds.begin() + aIndex ); + } + + /** + * Number of child node that this node contains + * + * @return Number of childs + */ + int ChildCount() const + { + return mChilds.size(); + } + + /** + * Return child node at given index + * + * @param aIndex index of child node + * @return Child node at given index + */ + MulTreeNode* Child( int aIndex ) + { + //At checks for out of bound condition we dont need to check again + return mChilds.at(aIndex); + } + + /** + * Check that weather this node is parent node and has any childs + * + * @retrun true if node has cilds false otherwise + */ + bool HasChild() const + { + return ( ChildCount() > 0 ); + } + + /** + * Return parent of this node + * + * @return Parent of node + */ + MulTreeNode* Parent() const + { + return mParent; + } + + /** + * Set Index of node to current path + * + * @param aIndex index of node + */ + void SetIndex( int aIndex ) + { + mIndex = aIndex; + } + + /** + * Return index of node + * + * @return index of node. + */ + int Index() const + { + return mIndex; + } + + /** + * Expand or unexpand node. + * + * @param aExpendedState New state of node + */ + void SetExpanded( bool aExpandedState ) + { + mExpandedState = aExpandedState; + } + + /** + * Return weather this node is expended or not + * + * @return true if expended, false otherwise + */ + bool IsExpanded() const + { + return mExpandedState; + } + +private: + + MulTreeNode* mParent; //not own + int mIndex; + bool mExpandedState; + std::vector mChilds; //owns all children + }; + +class MulTree + { +public: //Constructor and Destructor + + /** + * C++ Constructor + */ + MulTree() + { + //create root node for tree + mRootNode.reset( new (EMM) MulTreeNode(0) ); + mRootNode->SetExpanded( true ); + mRootNode->SetIndex(0); + } + + /** + * Destructor + */ + ~MulTree() + { + } + +public: //New method + + /** + * Create new node at specified index + * + * @param aPath Path to parent node + * @param aIndex Position at which node to be inserted in parent node + */ + void AddNode( const MulDataPath& aPath, int aIndex ); + + /** + * Remove node from specified index + * + * @param aPath Path to parent node + * @param aIndex Posiotin at which node to be remove from parent node + */ + void RemoveNode( const MulDataPath& aPath, int aIndex ); + + /** + * Finds node with specified path + * + * @param aPath path of node to be find + * @return Node does not return ownership + */ + MulTreeNode* FindNode( const MulDataPath& aPath ) const; + + /** + * Finds node with specified index in specified node + * + * @param aParentNode Parent node in which search required to be made + * @param aIndex Index of node to be find + * @return Node does not return ownership + */ + MulTreeNode* FindChildNode( MulTreeNode* aParentNode, int aIndex ) const; + + /** + * Find node with specified absolute index and return path to that node. + * + * @param aIndex Index of node + * @return Path to node + */ + MulDataPath FindNode( int aIndex ) const; + + /** + * Create and return path for given node + * + * @param aNode Node of which path is required + * @return Path of node + */ + MulDataPath Path( MulTreeNode& aNode ) const; + + /** + * Return number of node this tree contains + * + * @return Number of nodes + */ + int NodeCount() const; + + /** + * Return number of node this node branch + * + * @return Number of nodes + */ + int NodeCount(MulTreeNode* aCurrentNode ) const; + + /** + * Return number of items, + * Checks that node is expanded or not, + * if expanded then add it counts child count else ignore child count. + * + * @return Node count + */ + int ExpandedNodeCount() const; + + /** + * Return number of items, + * Checks that node is expanded or not, + * if expanded then add it couts child count else ignore child count. + * + * @param aCurrentNode Node of which count is needed + * + * @return Node count + */ + int ExpandedNodeCount(MulTreeNode* aCurrentNode ) const; + + /** + * Returns node's absolute index + * + * @param aPath Path to node + * @param aIndex index of node in path + * @return position of node in whole tree + */ + int NodeIndex( const MulDataPath& aPath, int aIndex ) const; + +private: + + /** + * Find node with specified absolute index and return path to that node. + * + * @param aNode Node in which index to be find + * @param aIndex Index of node + * @return Path to node + */ + MulDataPath FindNode( MulTreeNode* aNode, int& aAbsoluteIndex, int aIndex ) const; + + /** + * Returns node's absolute index + * + * @param aCurrentNode Node to compare path with + * @param aPath Path of node which absolute index is required + * @param aAbsoluteIndex Counter variable + * @return position of node in whole tree + */ + int NodeIndex( MulTreeNode* aCurrentNode, const MulDataPath& aPath,int& aAbsoluteIndex ) const; + +private: //data + + std::auto_ptr mRootNode; //root of tree - owned + }; + + } //namespace Alf + +#endif /*MULTREE_H_*/