/*
* Copyright (c) 2009 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:  
 *
*/


// INCLUDE FILES
#include <aknconfphysics.rsg>
#include <akntextsettingpage.h>
#include <centralrepository.h>
#include <aknphysicscrkeys.h>

#include "aknconfsettingitem.h"
#include "aknconfphysicssettinglist.h"
#include "aknconf.hrh"

const TUid KPhysicsCenRepUid( KCRUidAknPhysicsSettings );
const TInt KPhysicsCenRepMassKey( KViewMass );
const TInt KPhysicsCenRepGravityKey( KGravity );
const TInt KPhysicsCenRepSurfaceSoftErpKey( KSurfaceErp );
const TInt KPhysicsCenRepSurfaceSoftCfmKey( KSurfaceCfm );
const TInt KPhysicsCenRepHighlightTimeoutKey( KHighlightTimeout );
const TInt KPhysicsCenRepDragThresholdKey( KDragTreshold );
const TInt KPhysicsCenRepFrameDelay( KFrameDelay );
const TInt KPhysicsCenRepMinFrameInterval( KMinFrameInterval );
const TInt KPhysicsCenRepFeatureEnabledKey( KFeatureEnabled );
const TInt KPhysicsCenRepFpsLoggingEnabledKey( KFpsLoggingEnabled );

_LIT( KResourceFile, "\\resource\\apps\\aknconfphysics.rsc" );

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

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


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::~CAknConfPhysicsSettingList()
// -----------------------------------------------------------------------------
//
CAknConfPhysicsSettingList::~CAknConfPhysicsSettingList()
    {
    }

// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::ResetValues()
// -----------------------------------------------------------------------------
//
void CAknConfPhysicsSettingList::ResetValues()
    {
    if ( iCenRep )
        {
        iCenRep->Reset();
        TInt cenRepKey( -1 );
        ValueFromCenRep( EAknConfPhysicsSettingMass, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingGravity, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingSurfaceSoftErp, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingSurfaceSoftCfm, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingHighlightTimeout, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingDragThreshold, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingFrameDelay, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingMinFrameInterval, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingFeatureEnabled, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingShortListEmptySpace, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingLongListEmptySpace, cenRepKey );
        ValueFromCenRep( EAknConfPhysicsSettingFpsLoggingEnabled, cenRepKey );
        TRAP_IGNORE( LoadSettingsL() );
        DrawDeferred();
        }
    }


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::CreateSettingItemL()
// -----------------------------------------------------------------------------
//
CAknSettingItem* CAknConfPhysicsSettingList::CreateSettingItemL( TInt aIdentifier )
    {
    if ( aIdentifier != EAknConfPhysicsSettingShortListEmptySpace
            && aIdentifier != EAknConfPhysicsSettingLongListEmptySpace
            && aIdentifier != EAknConfPhysicsSettingFeatureEnabled
            && aIdentifier != EAknConfPhysicsSettingFpsLoggingEnabled )
        {
        return CAknConfSettingList::CreateSettingItemL( aIdentifier );
        }
    CAknSettingItem* settingItem = NULL;
    TInt cenRepKey( 0 );

    TInt* settingValue( ValueFromCenRep( aIdentifier, cenRepKey ) );

    if ( aIdentifier == EAknConfPhysicsSettingShortListEmptySpace
        || aIdentifier == EAknConfPhysicsSettingLongListEmptySpace )
        {
        settingItem = 
            new ( ELeave ) CAknConfSliderSettingItem( 
                this, *settingValue, aIdentifier, cenRepKey );
        }
    else if ( aIdentifier == EAknConfPhysicsSettingFeatureEnabled
        || aIdentifier == EAknConfPhysicsSettingFpsLoggingEnabled )
        {
        settingItem 
            =  new ( ELeave ) CAknConfBinarySettingItem( 
                this, *settingValue, aIdentifier, cenRepKey );
        }
    return settingItem;
    }


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::CAknConfPhysicsSettingList()
// -----------------------------------------------------------------------------
//
CAknConfPhysicsSettingList::CAknConfPhysicsSettingList()
    :
    CAknConfSettingList(),
    iMass( 0 ),
    iGravity( 0 ),
    iSurfaceSoftErp( 0 ),
    iSurfaceSoftCfm( 0 ),
    iHighlightTimeout( 0 ),
    iDragThreshold( 0 ),
    iFrameDelay( 0 ),
    iMinFrameInterval( 0 ),
    iShortListEmptySpace( 0 ),
    iLongListEmptySpace( 0 )
    {
    }


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::ConstructL()
// -----------------------------------------------------------------------------
//
void CAknConfPhysicsSettingList::ConstructL()
    {
    CAknConfSettingList::ConstructL( KPhysicsCenRepUid, KResourceFile );
    CAknConfSettingList::ConstructFromResourceL( R_AKNCONF_PHYSICS_SETTINGITEMLIST );
    }


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::DataValuePointer()
// -----------------------------------------------------------------------------
//
TInt* CAknConfPhysicsSettingList::DataValuePointer( const TInt& aId, TInt& aCenRepKey )
    {
    TInt* valuePtr( NULL );
    switch ( aId )
        {
        case EAknConfPhysicsSettingMass:
            valuePtr = &iMass;
            aCenRepKey = KPhysicsCenRepMassKey;
            break;
        case EAknConfPhysicsSettingGravity:
            valuePtr = &iGravity;
            aCenRepKey = KPhysicsCenRepGravityKey;
            break;
        case EAknConfPhysicsSettingSurfaceSoftErp:
            valuePtr = &iSurfaceSoftErp;
            aCenRepKey = KPhysicsCenRepSurfaceSoftErpKey;
            break;
        case EAknConfPhysicsSettingSurfaceSoftCfm:
            valuePtr = &iSurfaceSoftCfm;
            aCenRepKey = KPhysicsCenRepSurfaceSoftCfmKey;
            break;
        case EAknConfPhysicsSettingHighlightTimeout:
            valuePtr = &iHighlightTimeout;
            aCenRepKey = KPhysicsCenRepHighlightTimeoutKey;
            break;
        case EAknConfPhysicsSettingDragThreshold:
            valuePtr = &iDragThreshold;
            aCenRepKey = KPhysicsCenRepDragThresholdKey;
            break;
        case EAknConfPhysicsSettingFrameDelay:
            valuePtr = &iFrameDelay;
            aCenRepKey = KPhysicsCenRepFrameDelay;
            break;   
        case EAknConfPhysicsSettingMinFrameInterval:
            valuePtr = &iMinFrameInterval;
            aCenRepKey = KPhysicsCenRepMinFrameInterval;
            break;   
        case EAknConfPhysicsSettingFeatureEnabled:
            valuePtr = &iFeatureEnabled;
            aCenRepKey = KPhysicsCenRepFeatureEnabledKey;
            break;
        case EAknConfPhysicsSettingShortListEmptySpace:
            valuePtr = &iShortListEmptySpace;
            aCenRepKey = KShortListEmptySpace;
            break;
        case EAknConfPhysicsSettingLongListEmptySpace:
            valuePtr = &iLongListEmptySpace;
            aCenRepKey = KLongListEmptySpace;
            break;
        case EAknConfPhysicsSettingFpsLoggingEnabled:
            valuePtr = &iFpsLoggingEnabled;
            aCenRepKey = KPhysicsCenRepFpsLoggingEnabledKey;
            break;
        default:
            break;
        }
    return valuePtr;
    }


// -----------------------------------------------------------------------------
// CAknConfPhysicsSettingList::ValueFromCenRep()
// -----------------------------------------------------------------------------
//
TInt* CAknConfPhysicsSettingList::ValueFromCenRep( const TInt& aId, 
                                            TInt& aCenRepKey )
    {
    aCenRepKey = 0;
    TInt* settingValue( DataValuePointer( aId, aCenRepKey ) );
    if ( !settingValue || !aCenRepKey )
        {
        return NULL;
        }

    TInt value( -1 );
    if ( iCenRep )
        {
        iCenRep->Get( aCenRepKey, value );
        }
    *settingValue = value;
    return settingValue;
    }
// End of File