/*

* 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 of collection path

*

*/

#include <s32strm.h>

#include <e32panic.h>

#include <mpxuser.h>

#include <mpxcmn.h>

#include <mpxattribute.h>

#include <mpxdata.h>

#include "mpxcollectionpath.h"

/**

* Encapsulates single node in collection hierarchy level. A node represents a

* level of the collection path

*/

NONSHARABLE_CLASS(CMPXCollectionPathNode) : public CBase

    {

public:

    static CMPXCollectionPathNode* NewL();

    static CMPXCollectionPathNode* NewLC();

    static CMPXCollectionPathNode* NewLC(const CMPXCollectionPathNode& aNode);

    virtual ~CMPXCollectionPathNode();

public:

    /**

    * Sets current item at this level

    */

    void Set(const TMPXItemId& aId, TInt aIndex);

    /**

    * Sets the next level open mode

    */

    void Set(TMPXOpenMode aRequest);

    /**

    * Sets the next level open attributes

    */

    void SetL(const TArray<TMPXAttribute>& aAttrs);

    /**

    * Current index

    */

    TInt Index() const;

    /**

    * Current Id

    */

    const TMPXItemId& Id() const;

    /**

    * Open mode for next level

    */

    TMPXOpenMode OpenMode() const;

    /**

    * Open attributes for next level

    */

    const TArray<TMPXAttribute> OpenAttributes() const;

public:

    void ExternalizeL(RWriteStream& aStream) const;

    void InternalizeL(RReadStream& aStream);

private:

    CMPXCollectionPathNode();

    void ConstructL(const CMPXCollectionPathNode& aNode);

    void ConstructL();

private:

    TMPXItemId iId;

    TInt iIndex;

    TMPXOpenMode iOpenMode;

    RArray<TMPXAttribute> iAttrs; // Open attributes for next level

    };

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

// CMPXCollectionPathNode::NewL

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

//

CMPXCollectionPathNode* CMPXCollectionPathNode::NewL()

    {

    CMPXCollectionPathNode* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMPXCollectionPathNode::NewLC

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

//

CMPXCollectionPathNode* CMPXCollectionPathNode::NewLC()

    {

    CMPXCollectionPathNode* self = new(ELeave) CMPXCollectionPathNode();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CMPXCollectionPathNode::NewLC

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

//

CMPXCollectionPathNode* CMPXCollectionPathNode::NewLC(

    const CMPXCollectionPathNode& aNode)

    {

    CMPXCollectionPathNode* self = new(ELeave) CMPXCollectionPathNode();

    CleanupStack::PushL(self);

    self->ConstructL(aNode);

    return self;

    }

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

// CMPXCollectionPathNode::ConstructL

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

//

void CMPXCollectionPathNode::ConstructL()

    {

    }

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

// CMPXCollectionPathNode::ConstructL

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

//

void CMPXCollectionPathNode::ConstructL(

    const CMPXCollectionPathNode& aNode)

    {

    iId=aNode.iId;

    iIndex=aNode.iIndex;

    iOpenMode=aNode.iOpenMode;

    ::CopyArrayL<TMPXAttribute>(aNode.iAttrs.Array(), iAttrs);

    }

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

// CMPXCollectionPathNode::CMPXCollectionPathNode

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

//

CMPXCollectionPathNode::CMPXCollectionPathNode()

:   iId(KMPXInvalidItemId),

    iIndex(KErrNotFound),

    iOpenMode(EMPXOpenGroupOrPlaylist)

    {

    }

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

// CMPXCollectionPathNode::~CMPXCollectionPathNode

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

//

CMPXCollectionPathNode::~CMPXCollectionPathNode()

    {

    iAttrs.Close();

    }

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

// CMPXCollectionPathNode::Set

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

//

void CMPXCollectionPathNode::Set(const TMPXItemId& aId, TInt aIndex)

    {

    iId=aId;

    iIndex=aIndex;

    }

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

// CMPXCollectionPathNode::Set

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

//

void CMPXCollectionPathNode::Set(TMPXOpenMode aMode)

    {

    iOpenMode=aMode;

    }

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

// CMPXCollectionPathNode::Set

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

//

void CMPXCollectionPathNode::SetL(const TArray<TMPXAttribute>& aAttrs)

    {

    ::CopyArrayL(aAttrs, iAttrs);

    }

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

// CMPXCollectionPathNode::Index

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

//

TInt CMPXCollectionPathNode::Index() const

    {

    return iIndex;

    }

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

// CMPXCollectionPathNode::Id

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

//

const TMPXItemId& CMPXCollectionPathNode::Id() const

    {

    return iId;

    }

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

// CMPXCollectionPathNode::OpenMode

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

//

TMPXOpenMode CMPXCollectionPathNode::OpenMode() const

    {

    return iOpenMode;

    }

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

// CMPXCollectionPathNode::OpenAttributes

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

//

const TArray<TMPXAttribute> CMPXCollectionPathNode::OpenAttributes() const

    {

    return iAttrs.Array();

    }

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

// Externalize object

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

//

void CMPXCollectionPathNode::ExternalizeL(RWriteStream& aStream) const

    {

    aStream.WriteUint32L(iId.iId1);

    aStream.WriteUint32L(iId.iId2);

    aStream.WriteInt32L(iIndex);

    aStream.WriteInt32L(iOpenMode);

    ::ExternalizeL(iAttrs.Array(), aStream);

    }

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

// Internalize object

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

//

void CMPXCollectionPathNode::InternalizeL(RReadStream& aStream)

    {

    TUint32 id1 = aStream.ReadUint32L();

    TUint32 id2 = aStream.ReadUint32L();

    iId=TMPXItemId( id1, id2 );

    iIndex=aStream.ReadInt32L();

    iOpenMode=static_cast<TMPXOpenMode>(aStream.ReadInt32L());

    iAttrs.Reset();

    ::InternalizeL(iAttrs, aStream);

    }

// ============================== MEMBER FUNCTIONS =============================

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPath* CMPXCollectionPath::NewL()

    {

    CMPXCollectionPath* p = new(ELeave) CMPXCollectionPath();

    CleanupStack::PushL(p);

    p->ConstructL();

    CleanupStack::Pop(p);

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPath* CMPXCollectionPath::NewL(

    const CMPXCollectionPath& aPath)

    {

    CMPXCollectionPath* p = new(ELeave) CMPXCollectionPath();

    CleanupStack::PushL(p);

    p->ConstructL(aPath);

    CleanupStack::Pop(p);

    return p;

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCollectionPath* CMPXCollectionPath::NewL(

    RReadStream& aStream)

    {

    CMPXCollectionPath* p = new(ELeave) CMPXCollectionPath();

    CleanupStack::PushL(p);

    p->ConstructL(aStream);

    CleanupStack::Pop(p);

    return p;

    }

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

// Destructor

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

//

EXPORT_C CMPXCollectionPath::~CMPXCollectionPath()

    {

    iNodeArray.ResetAndDestroy();

    iNodeArray.Close();

    iIds.Close();

    iSelection.Close();

    }

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

// Default constructor

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

//

CMPXCollectionPath::CMPXCollectionPath() : iInvalidId(KMPXInvalidItemId)

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXCollectionPath::ConstructL(const CMPXCollectionPath& aPath)

    {

    iNodeArray.ResetAndDestroy();

    TInt count = aPath.iNodeArray.Count();

    for (TInt i=0; i<count; ++i)

        {

        CMPXCollectionPathNode* node =

            CMPXCollectionPathNode::NewLC(*(aPath.iNodeArray[i]));

        iNodeArray.AppendL(node);

        CleanupStack::Pop(node);

        }

    ::CopyArrayL(aPath.iIds.Array(),iIds);

    ::CopyArrayL(aPath.iSelection.Array(),iSelection);

    }

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

// 2nd phase constructor.

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

//

void CMPXCollectionPath::ConstructL()

    {

    }

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

// 2nd phase constructor.

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

//

void CMPXCollectionPath::ConstructL(RReadStream& aStream)

    {

    InternalizeL(aStream);

    }

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

// Advances path to next item

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

//

EXPORT_C TBool CMPXCollectionPath::operator++()

    {

    TBool ret(EFalse);

    TInt index=Index();

    if (index < Count()-1)

        {

        Set(++index);

        ret=ETrue;

        } // else the last one, no more to go and return false

    return ret;

    }

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

// Advances path to previous item

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

//

EXPORT_C TBool CMPXCollectionPath::operator--()

    {

    TBool ret=EFalse;

    TInt index=Index();

    if (index>0)

        {

        Set(--index);

        ret=ETrue;

        } // else the first one, no more to go and return false

    return ret;

    }

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

// Sets path to first item

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

//

EXPORT_C void CMPXCollectionPath::SetToFirst()

    {

    Set(0);

    }

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

// Sets path to last item

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

//

EXPORT_C void CMPXCollectionPath::SetToLast()

    {

    Set(Count()-1);

    }

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

// Change current item by index at top level

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

//

EXPORT_C void CMPXCollectionPath::Set(TInt aIndex)

    {

    MPX_ASSERT(Levels());

    CMPXCollectionPathNode& topLevel = TopLevel();

    // RArray will panic if aIndex out of bound

    topLevel.Set(iIds[aIndex], aIndex);

    }

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

// Change current item by id at top level

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

//

EXPORT_C void CMPXCollectionPath::Set(const TMPXItemId& aId)

    {

    TInt index=IndexOfId(aId);

    MPX_ASSERT(KErrNotFound!=index && Levels());

    CMPXCollectionPathNode& topLevel = TopLevel();

    topLevel.Set(aId, index);

    }

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

// Set open mode for next level

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

//

EXPORT_C void CMPXCollectionPath::Set(TMPXOpenMode aMode)

    {

    MPX_ASSERT(Levels());

    TopLevel().Set(aMode);

    }

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

// Set open attrobutes for next level

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

//

EXPORT_C void CMPXCollectionPath::Set(const TArray<TMPXAttribute>& aAttrs)

    { // DEPRECATED

    TRAP_IGNORE(SetL(aAttrs));

    }

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

// Set open attrobutes for next level

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

//

EXPORT_C void CMPXCollectionPath::SetL(const TArray<TMPXAttribute>& aAttrs)

    {

    MPX_ASSERT(Levels());

    TopLevel().SetL(aAttrs);

    }

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

//  Select an item by id in the path

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

//

EXPORT_C void CMPXCollectionPath::SelectL(const TMPXItemId& aId)

    {

    TInt index=IndexOfId(aId);

    MPX_ASSERT(KErrNotFound != index);

    SelectL(index);

    }

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

//  Select an item by index in the path

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

//

EXPORT_C void CMPXCollectionPath::SelectL(TInt aIndex)

    {

    MPX_ASSERT_EX(aIndex>=0 && aIndex<iIds.Count(), EBadArrayIndex);

    TInt err = iSelection.InsertInOrder(aIndex);

    if (KErrNone!=err && KErrAlreadyExists!=err)

        { // ignore duplicated items

        User::Leave(err);

        }

    }

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

//  Select an item by index in the path

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

//

EXPORT_C void CMPXCollectionPath::SelectAllL()

    {

    iSelection.Reset();

    for (TInt i=0; i < iIds.Count(); ++i)

        {

        iSelection.AppendL(i);

        }

    }

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

//  Deselects an item by id in the path

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

//

EXPORT_C void CMPXCollectionPath::Deselect(const TMPXItemId& aId)

    {

    TInt index=IndexOfId(aId);

    MPX_ASSERT(KErrNotFound != index);

    Deselect(index);

    }

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

//  Deselects an item by index in the path

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

//

EXPORT_C void CMPXCollectionPath::Deselect(TInt aIndex)

    {

    MPX_ASSERT_EX(aIndex>=0 && aIndex<iIds.Count(), EBadArrayIndex);

    TInt index(iSelection.FindInOrder(aIndex));

    MPX_ASSERT(KErrNotFound !=index);

    iSelection.Remove(index);

    }

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

//  Select an item by index in the path

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

//

EXPORT_C void CMPXCollectionPath::DeselectAll()

    {

    iSelection.Reset();