/*

* Copyright (c) 2006-2007 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:  A class for folding view that can be expanded to its subview

*

*/

#include "CVPbkFoldingContactView.h"

#include <MVPbkContactStore.h>

#include <CVPbkSortOrder.h>

#include <MVPbkContactViewObserver.h>

#include <CVPbkAsyncCallback.h>

#include <MVPbkContactStoreProperties.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkContactManager.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkError.h>

#include "TVPbkFoldingContactBookmark.h"

#include "CVPbkFoldingViewContact.h"

namespace {

#ifdef _DEBUG

    enum TPanic

        {

        EPreCond_ConstructL

        };

    void Panic( TPanic aPanic )

        {

        _LIT(KPanicCat, "CVPbkFoldingContactView");

        User::Panic( KPanicCat, aPanic );

        }

#endif // _DEBUG

// CONSTANTS

const TInt KObserverArrayGranularity = 4;

// Event sending functions for different amount of parameters

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

// SendEventToObservers

// For observer functions that take MVPbkContactViewBase as a parameter

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

//

template <class NotifyFunc>

void SendEventToObservers(MVPbkContactViewBase& aView, 

                          RPointerArray<MVPbkContactViewObserver>& iObservers, 

                          NotifyFunc aNotifyFunc)

    {

    const TInt count = iObservers.Count();

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

        {

        MVPbkContactViewObserver* observer = iObservers[i];

        (observer->*aNotifyFunc)(aView);

        }

    }

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

// SendEventToObservers

// For observer functions that take MVPbkContactViewBase, and two other 

// parameters

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

//

template <class NotifyFunc, class ParamType1, class ParamType2>

void SendEventToObservers(MVPbkContactViewBase& aView, 

                          RPointerArray<MVPbkContactViewObserver>& iObservers, 

                          NotifyFunc aNotifyFunc,

                          ParamType1 aParam1,

                          ParamType2 aParam2)

    {

    const TInt count = iObservers.Count();

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

        {

        MVPbkContactViewObserver* observer = iObservers[i];

        (observer->*aNotifyFunc)(aView, aParam1, aParam2);

        }

    }

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

// DoMatchContactStore

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

//

TBool DoMatchContactStore(CVPbkContactViewDefinition& aViewDef,

        TVPbkContactStoreUriPtr::TVPbkContactStoreUriComponent aUriComponent, 

        const TDesC& aStoreUriComponentDes)

    {

    // Match store URI to the first view definition that is found starting

    // from the aViewDef. If not found then check subviews from left to right

    TBool result = EFalse;

    TVPbkContactStoreUriPtr uriPtr(aViewDef.Uri());

    if (uriPtr.Compare(aStoreUriComponentDes, aUriComponent) == 0)

        {

        result = ETrue;

        }

    else

        {

        const TInt count = aViewDef.SubViewCount();

        for (TInt i = 0; i < count && !result; ++i)

            {

            result = DoMatchContactStore(aViewDef.SubViewAt(i), aUriComponent, 

                aStoreUriComponentDes);

            }

        }

    return result;

    }

}

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

// CVPbkFoldingContactView::CVPbkFoldingContactView

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

//

CVPbkFoldingContactView::CVPbkFoldingContactView(

        const CVPbkContactManager& aContactManager) :

    iContactManager(aContactManager),

    iObservers( KObserverArrayGranularity )

    {

    }

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

// CVPbkFoldingContactView::ConstructL

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

//

inline void CVPbkFoldingContactView::ConstructL(

        const CVPbkContactViewDefinition& aViewDefinition,

        const MVPbkFieldTypeList& aSortOrder)

    {

    /// Folding view must have 1 sub view definition if it's used for

    /// expanding. If there is no sub view then this folding can not be

    /// exapanded and it's only used to show a named item.

    __ASSERT_DEBUG( aViewDefinition.SubViewCount() <= 1,

        Panic( EPreCond_ConstructL ) );

    /// Save the one and only subview definition for later usage

    iViewDefinition = CVPbkContactViewDefinition::NewL( aViewDefinition );

    /// Create the view contact

    iFoldingContact = CVPbkFoldingViewContact::NewL(*this);

    iSortOrder = CVPbkSortOrder::NewL(aSortOrder);

    }

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

// CVPbkFoldingContactView::NewLC

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

//  

CVPbkFoldingContactView* CVPbkFoldingContactView::NewLC(

        MVPbkContactViewObserver& aObserver,

        const CVPbkContactViewDefinition& aViewDefinition, 

        const CVPbkContactManager& aContactManager,

        const MVPbkFieldTypeList& aSortOrder)

    {

    CVPbkFoldingContactView* self = new(ELeave) CVPbkFoldingContactView(aContactManager);

    CleanupStack::PushL(self);

    self->ConstructL(aViewDefinition, aSortOrder);

    self->AddObserverL(aObserver);

    return self;

    }

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

// CVPbkFoldingContactView::~CVPbkFoldingContactView

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

//  

CVPbkFoldingContactView::~CVPbkFoldingContactView()

    {

    delete iViewDefinition;

    delete iSortOrder;

    delete iFoldingContact;

    iObservers.Close();

    }

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

// CVPbkFoldingContactView::Name

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

//

const TDesC& CVPbkFoldingContactView::Name() const

    {

    return iViewDefinition->Name();

    }

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

// CVPbkFoldingContactView::Type

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

//

TVPbkContactViewType CVPbkFoldingContactView::Type() const

    {

    return EVPbkFoldingView;

    }

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

// CVPbkFoldingContactView::ChangeSortOrderL

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

//

void CVPbkFoldingContactView::ChangeSortOrderL(const MVPbkFieldTypeList& aSortOrder)

    {

    if (iObservers.Count() > 0)

        {

        CVPbkSortOrder* newSortOrder = CVPbkSortOrder::NewL(aSortOrder);

        delete iSortOrder;

        iSortOrder = newSortOrder;

        SendAsyncUnavailableAndReadyEventL();

        }    

    }

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

// CVPbkFoldingContactView::SortOrder

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

//

const MVPbkFieldTypeList& CVPbkFoldingContactView::SortOrder() const

    {

    return *iSortOrder;

    }

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

// CVPbkFoldingContactView::RefreshL

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

//

void CVPbkFoldingContactView::RefreshL()

    {

    SendAsyncUnavailableAndReadyEventL();

    }

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

// CVPbkFoldingContactView::ContactCountL

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

//

TInt CVPbkFoldingContactView::ContactCountL() const

    {

    // This is folding view => only this view is visible as a contact

    return 1;

    }

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

// CVPbkFoldingContactView::ContactAtL

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

//

const MVPbkViewContact& CVPbkFoldingContactView::ContactAtL(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    return *iFoldingContact;

    }

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

// CVPbkFoldingContactView::CreateLinkLC

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

//

MVPbkContactLink* CVPbkFoldingContactView::CreateLinkLC(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    return iFoldingContact->CreateLinkLC();

    }

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

// CVPbkFoldingContactView::IndexOfLinkL

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

//

TInt CVPbkFoldingContactView::IndexOfLinkL(

        const MVPbkContactLink& /*aContactLink*/) const

    {

    return KErrNotFound;

    }

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

// CVPbkFoldingContactView::AddObserverL

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

//

void CVPbkFoldingContactView::AddObserverL(

        MVPbkContactViewObserver& aObserver)

    {

    VPbkEngUtils::MAsyncCallback* notifyObserver =

        VPbkEngUtils::CreateAsyncCallbackLC(

            *this, 

            &CVPbkFoldingContactView::DoAddObserverL, 

            &CVPbkFoldingContactView::AddObserverError, 

            aObserver);

    iAsyncOperation.CallbackL(notifyObserver);

    CleanupStack::Pop(notifyObserver);

    }

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

// CVPbkFoldingContactView::DoAddObserverL

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

//

void CVPbkFoldingContactView::DoAddObserverL(

        MVPbkContactViewObserver& aObserver)

    {

    TInt err( iObservers.InsertInAddressOrder( &aObserver ) );

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

        {

        User::Leave( err );

        }

    // this view is always ready

    aObserver.ContactViewReady(*this);

    }

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

// CVPbkFoldingContactView::AddObserverError

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

//

void CVPbkFoldingContactView::AddObserverError(

        MVPbkContactViewObserver& aObserver, TInt aError)

    {

    aObserver.ContactViewError(*this, aError, EFalse);

    }

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

// CVPbkFoldingContactView::SendAsyncUnavailableAndReadyEventL

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

//

void CVPbkFoldingContactView::SendAsyncUnavailableAndReadyEventL()

    {

    // Send first unvavailable event...

    VPbkEngUtils::MAsyncCallback* notifyObserver = 

        VPbkEngUtils::CreateAsyncCallbackLC(

            *this, 

            &CVPbkFoldingContactView::DoSignalObserversViewUnavailable,

            &CVPbkFoldingContactView::DoSignalObserversViewError,

            *iObservers[0]);//Observer is actually not used by DoSignal*

    iAsyncOperation.CallbackL(notifyObserver);

    CleanupStack::Pop(notifyObserver);

    // ...then ready event. This is how views must behave.

    notifyObserver = VPbkEngUtils::CreateAsyncCallbackLC(

        *this,

        &CVPbkFoldingContactView::DoSignalObserversViewReady, 

        &CVPbkFoldingContactView::DoSignalObserversViewError,

        *iObservers[0]);//Observer is actually not used by DoSignal*

    iAsyncOperation.CallbackL( notifyObserver );

    CleanupStack::Pop( notifyObserver );

    }

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

// CVPbkFoldingContactView::DoSignalObserversViewReady

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

//

void CVPbkFoldingContactView::DoSignalObserversViewReady(

        MVPbkContactViewObserver& /*aObserver*/)

    {

    SendEventToObservers(*this, iObservers, 

        &MVPbkContactViewObserver::ContactViewReady);

    }

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

// CVPbkFoldingContactView::DoSignalObserversViewUnavailable

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

//

void CVPbkFoldingContactView::DoSignalObserversViewUnavailable(

        MVPbkContactViewObserver& /*aObserver*/)

    {

    SendEventToObservers( *this, iObservers, 

        &MVPbkContactViewObserver::ContactViewUnavailable );

    }

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

// CVPbkFoldingContactView::DoSignalObserversViewError

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

//

void CVPbkFoldingContactView::DoSignalObserversViewError(

        MVPbkContactViewObserver& /* aObserver */, 

        TInt aError )

    {

    SendEventToObservers(*this, iObservers, 

        &MVPbkContactViewObserver::ContactViewError, aError, EFalse );

    }

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

// CVPbkFoldingContactView::RemoveObserver

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

//

void CVPbkFoldingContactView::RemoveObserver(

        MVPbkContactViewObserver& aObserver)

    {

    TInt index( iObservers.FindInAddressOrder( &aObserver ) );

    if (index != KErrNotFound)

        {

        iObservers.Remove(index);

        }

    }

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

// CVPbkFoldingContactView::MatchContactStore

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

//

TBool CVPbkFoldingContactView::MatchContactStore(

        const TDesC& aContactStoreUri) const

    {

    return DoMatchContactStore(*iViewDefinition, 

        TVPbkContactStoreUriPtr::EContactStoreUriAllComponents,

        aContactStoreUri);

    }

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

// CVPbkFoldingContactView::MatchContactStoreDomain

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

//

TBool CVPbkFoldingContactView::MatchContactStoreDomain(

        const TDesC& aContactStoreDomain) const

    {

    return DoMatchContactStore(*iViewDefinition, 

        TVPbkContactStoreUriPtr::EContactStoreUriStoreType,

        aContactStoreDomain);

    }

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

// CVPbkFoldingContactView::CreateBookmarkLC

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

//

MVPbkContactBookmark* CVPbkFoldingContactView::CreateBookmarkLC(

        TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0, 

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    return iFoldingContact->CreateBookmarkLC();

    }

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

// CVPbkFoldingContactView::IndexOfBookmarkL

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

//

TInt CVPbkFoldingContactView::IndexOfBookmarkL(

        const MVPbkContactBookmark& aContactBookmark) const

    {

    const TVPbkFoldingContactBookmark* bookmark = 

        dynamic_cast<const TVPbkFoldingContactBookmark*>(&aContactBookmark);

    if (bookmark && iFoldingContact == &bookmark->Contact())

        {

        // Folding view has always only one contact in index 0

        return 0;

        }

    return KErrNotFound;

    }

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

// CVPbkFoldingContactView::ViewFiltering

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

//

MVPbkContactViewFiltering* CVPbkFoldingContactView::ViewFiltering()

    {

    // Folding view doesn't support filtering yet.

    return NULL;

    }

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

// CVPbkFoldingContactView::ExpandLC

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

//

MVPbkContactViewBase* CVPbkFoldingContactView::ExpandLC(

        MVPbkContactViewObserver& aObserver,

        const MVPbkFieldTypeList& aSortOrder) const

    {

    /// Folding view can be expanded if it has one sub view definition. 

    /// If it has more than one then the rest of subview definitions are 

    /// ignored.

    if ( iViewDefinition->SubViewCount() >= 1 )

        {

        // Create a view according to first subview definition.

        return iContactManager.CreateContactViewLC(

            aObserver, iViewDefinition->SubViewAt( 0 ), aSortOrder );

        }

    return NULL;

    }

//End of file