/*
* 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:   item presentation model
*
*/


#include <liwservicehandler.h>
#include "hnitemmodel.h"
#include "hnmenuitemmodel.h"
#include "hnactionmodel.h"
#include "hntoolbarmodel.h"
#include "hnattributebase.h"
#include "hnattributetext.h"
#include "hnbuttonmodel.h"
#include "hnglobals.h"
#include "hnconvutils.h"

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


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CHnItemModel* CHnItemModel::NewL()
    {
    CHnItemModel* self = new( ELeave ) CHnItemModel();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
CHnItemModel::~CHnItemModel()
    {
    iTemplate.Close();
    delete iMenuModel;
    delete iToolbarModel;
    delete iMskModel;
    DeleteAllActionModels();
    iAttrs.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnItemModel::DeleteAllActionModels()
    {
    THashMapIter< TInt, CArrayPtr<CHnActionModel>* > iterator( iActions );
    while( iterator.NextKey() )
        {
        CArrayPtr<CHnActionModel>** actions = iterator.CurrentValue();
        (*actions)->ResetAndDestroy();
        delete *actions;
        iterator.RemoveCurrent();
        }
    iActions.Close();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CHnItemModel::RemoveLiwObjects()
    {
    if ( iToolbarModel )
        {
        iToolbarModel->RemoveLiwObjects();
        }

    for( TInt i = 0; i < iAttrs.Count(); ++i )
        {
        iAttrs[i]->RemoveLiwObjects();
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CHnItemModel::OfferHnEventL( CHnEventHandler & aEventHandler, 
        const TInt aEventId, CLiwGenericParamList* aEventParameters  )
    {
    TInt err = KErrNotFound;
    CArrayPtr<CHnActionModel>* actions = GetActions( aEventId );
    if ( actions ) 
        {
        TInt actionsCount = actions->Count();
        for( TInt i = 0; i < actionsCount; i++ )
            {
            ASSERT( actions->At( i ) );
            err = actions->At( i )->ExecuteL( aEventHandler,  aEventParameters );
            if ( err != KErrNone )
                {
                break;
                }
            }
        }
    return err;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//      
CHnItemModel::CHnItemModel() :
                iActions( &DefaultHash::Integer, &DefaultIdentity::Integer ),
                iEditable( EFalse ),
                iCustomId( KErrNotFound ),
                iMskModel( NULL )
    {
    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CHnItemModel::ConstructL()
    {
    iUid = TUid::Null();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::SetMenuItemModel(  CHnMenuItemModel* aMenu )
    {
    ASSERT( aMenu );
    delete iMenuModel;
    iMenuModel = aMenu;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
MHnMenuItemModelIterator* CHnItemModel::GetMenuStructure()
    {
    if( iMenuModel )
        return iMenuModel->GetMenuStructure();
    else 
        return 0;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C void CHnItemModel::SetMiddleSoftKey( CHnButtonModel* aMsk )
    {
    delete iMskModel;
    iMskModel = aMsk;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C CHnButtonModel* CHnItemModel::GetMiddleSoftKey()
    {
    return iMskModel;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C RHashMap< TInt, CArrayPtr<CHnActionModel>* >& 
        CHnItemModel::GetActions()
    {
    return iActions;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C CArrayPtr<CHnActionModel>* CHnItemModel::GetActions( TInt aId )
    {
    CArrayPtr<CHnActionModel>** ret = iActions.Find( aId );
    if( ret )
        {
        return *ret;
        }
    return NULL;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C const CHnToolbarModel* CHnItemModel::GetToolbarModel() const
    {
    return iToolbarModel;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::SetToolbarModel( CHnToolbarModel* aToolbar )
    {
    delete iToolbarModel;
    iToolbarModel = NULL;
    iToolbarModel = aToolbar;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CHnItemModel::GetTemplate()
    {
    CHnAttributeBase* templateAttr = GetAttribute( KTemplate8() );
    if ( templateAttr )
        {
        return templateAttr->Value();
        }
    return KNullDesC8();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnItemModel::SetTemplateL( const TDesC8& aTemplate )
    {
    CHnAttributeText* templateAttr = CHnAttributeText::NewL();
    templateAttr->SetNameL( KTemplate8 );
    templateAttr->SetValueL( aTemplate );
    SetAttributeL( templateAttr );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C void CHnItemModel::SetAttributeL( CHnAttributeBase* aAttr )
    {
    for( TInt i( 0 ); i < iAttrs.Count(); i++ )
        {
        if( iAttrs[i]->Name() == aAttr->Name() )
            {
            delete iAttrs[i];
            iAttrs.Remove(i);
            break;
            }
        }
    iAttrs.AppendL( aAttr );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C void CHnItemModel::ClearAttributesL()
    {
    iAttrs.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C CHnAttributeBase* CHnItemModel::GetAttribute( const TDesC8 & aMulAttribute )
    {
    CHnAttributeBase* attr = NULL;
    for( TInt i( 0 ); i < iAttrs.Count(); i++ )
        {
        if( ! iAttrs[i]->Name().Compare( aMulAttribute ) )
            {
            attr = iAttrs[i];
            break;
            }
        }
    return attr;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C TBool CHnItemModel::IsDeleteLocked()
    {
    TBool res = EFalse;
    if ( iFlags & EItemFlagRemoveLocked )
        {
        res = ETrue;
        }
    return res;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C TBool CHnItemModel::IsMoveLocked()
    {
    TBool res = EFalse;
    if ( iFlags & EItemFlagMoveLocked )
        {
        res = ETrue;
        }
    return res;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C TBool CHnItemModel::IsDrmExpired()
    {
    TBool res = EFalse;
    if ( iFlags & EItemFlagDrmExpired )
        {
        res = ETrue;
        }
    return res;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C TBool CHnItemModel::IsRunning()
    {
    TBool res = EFalse;
    if ( iFlags & EItemFlagRunning )
        {
        res = ETrue;
        }
    return res;    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::SetFlag( TInt aFlag )
    {
    if ( ( iFlags & aFlag ) == 0 )
        {
        iFlags |= aFlag;
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::ClearFlags()
    {
    iFlags = 0;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::SetType( const TDesC8& aType )
    {
    if ( !aType.Compare( KMenuFolder8 ) )
        {
        iType = EItemTypeFolder;
        }
    else if ( !aType.Compare( KMenuSuite8 ) )
        {
        iType = EItemTypeSuite;
        }
    else if ( !aType.Compare( KMenuApplication8 ) )
        {
        iType = EItemTypeApplication;
        }
    else if ( !aType.Compare( KMenuParentFolder8 ) )
        {
        iType = EItemTypeParentFolder;
        }
    else
        {
        iType = EItemTypeUnknown;        
        }    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C void CHnItemModel::SetCustomId( TInt64 aCustomId )
    {
    iCustomId = aCustomId;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
EXPORT_C TInt64 CHnItemModel::CustomId()
    {
    return iCustomId;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C TMcsItemType CHnItemModel::GetItemType()
    {
    return iType;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C TUid CHnItemModel::GetItemUid()
    {
    return iUid;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
EXPORT_C void CHnItemModel::SetItemUidL( const TDesC8& aUid )
    {
    TUint uint( KErrNone );
    HBufC* str = HnConvUtils::Str8ToStr( aUid );
    CleanupStack::PushL( str );
    
    TInt position( str->Find( KHexPrefix16 ) );
    TPtrC string( *str );
    TRadix radix( EDecimal );
    if ( position == 0 )
        {
        radix = EHex;
        string.Set( str->Mid( KHexPrefix16().Length() ) );
        }
    
    TLex( string ).Val( uint, radix );
    CleanupStack::PopAndDestroy( str );

    iUid = TUid::Uid( uint );
    }