/*

* 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:  Implements CAcpProviderSpecificContainer methods

*

*/

#include <aknlists.h>

#include <StringLoader.h>

#include <accountcreationplugin.rsg>

// SKIN: includes

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <gdi.h>

#include "acpproviderspecificcontainer.h"

#include "accountcreationpluginlogger.h"

#include "accountcreationpluginconstants.h"

#include "acpcontroller.h"

const TInt KComponentControlCount = 6;

const TInt KScrollMin = -200;

const TInt KScrollMax = 10;

const TInt KEight = 8;

const TInt KPositionX = 10;

const TInt KScrollSpeed = 10;

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

// CAcpProviderSpecificContainer::CAcpProviderSpecificContainer

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

//

CAcpProviderSpecificContainer::CAcpProviderSpecificContainer( 

    CAcpController& aController )

    : iController( aController ), iScrollY( KScrollMax )

    {

    }

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

// CAcpProviderSpecificContainer::ConstructL

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

//

void CAcpProviderSpecificContainer::ConstructL( const TRect& aRect )

    {

    ACPLOG( "CAcpProviderSpecificContainer::ConstructL begin" );

    CreateWindowL();

    // Skin background.

    //SKIN: create the skin context for our control

    iBgContext = CAknsBasicBackgroundControlContext::NewL( 

        KAknsIIDQsnBgAreaMain, aRect, ETrue );

    // Provider.

    TInt index = iController.ActiveIndex();

    TPtrC providerName = iController.ProviderNameFromIndexL( index );

    TPtrC providerType = iController.ProviderTypeFromIndexL( index );

    TPtrC providerDescription = 

        iController.ProviderDescriptionFromIndexL( index );

    // Name label.

    iLabel = new (ELeave) CEikLabel;

    iLabel->SetContainerWindowL( *this );

    HBufC* typeText;

    typeText = StringLoader::LoadLC( R_SERVTAB_CD_DETAIL_NAME );

    iLabel->SetTextL( *typeText );

    CleanupStack::PopAndDestroy( typeText );

    // Type label.

    iLabel2 = new (ELeave) CEikLabel;

    iLabel2->SetContainerWindowL( *this );

    HBufC* typeText2;

    typeText2 = StringLoader::LoadLC( R_SERVTAB_CD_DETAIL_TYPE );

    iLabel2->SetTextL( *typeText2 );

    CleanupStack::PopAndDestroy( typeText2 );

    // Description label

    iLabel3 = new (ELeave) CEikLabel;

    iLabel3->SetContainerWindowL( *this );

    HBufC* typeText3;

    typeText3 = StringLoader::LoadLC( R_SERVTAB_CD_DETAIL_DESCRIPTION );

    iLabel3->SetTextL( *typeText3 );

    CleanupStack::PopAndDestroy( typeText3 ); 

    // Edwin for name.

    TResourceReader reader; 

    iCoeEnv->CreateResourceReaderLC( reader, R_ACP_TYPE );

    iEdwin = new (ELeave) CEikEdwin;

    iEdwin->SetContainerWindowL( *this );

    iEdwin->ConstructFromResourceL( reader );       

    CleanupStack::PopAndDestroy();

    if ( !providerName.Length() )

    	{

    	HBufC* typeText6;

        typeText6 = StringLoader::LoadLC( R_SERVTAB_CD_VALUE_UNDEFINED );

        iEdwin->SetTextL( typeText6 );

        CleanupStack::PopAndDestroy( typeText6 );

    	}

    else

        {

    	iEdwin->SetTextL( &providerName );

        }

    // Edwin for type.

    TResourceReader reader2; 

    iCoeEnv->CreateResourceReaderLC( reader2, R_ACP_TYPE );

    iEdwin2 = new (ELeave) CEikEdwin;

    iEdwin2->SetContainerWindowL( *this );

    iEdwin2->ConstructFromResourceL( reader2 );       

    CleanupStack::PopAndDestroy();

    if ( !providerType.Length() )

    	{

    	HBufC* typeText7;

        typeText7 = StringLoader::LoadLC( R_SERVTAB_CD_VALUE_UNDEFINED );

        iEdwin2->SetTextL( typeText7 );

        CleanupStack::PopAndDestroy( typeText7 );

    	}

    else

        {

    	iEdwin2->SetTextL( &providerType );

        }

    // Edwin for description.

    TResourceReader reader3; 

    iCoeEnv->CreateResourceReaderLC( reader3, R_ACP_TYPE );

    iEdwin3 = new (ELeave) CEikEdwin;

    iEdwin3->SetContainerWindowL( *this );

    iEdwin3->ConstructFromResourceL( reader3 );       

    CleanupStack::PopAndDestroy();

    if ( !providerDescription.Length() )

    	{

    	HBufC* typeText8;

        typeText8 = StringLoader::LoadLC( R_SERVTAB_CD_VALUE_UNDEFINED );

        iEdwin3->SetTextL( typeText8 );

        CleanupStack::PopAndDestroy( typeText8 );

    	}

    else

        {

    	iEdwin3->SetTextL( &providerDescription );

        }

    // Get label colours from skin.

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRgb color( 0, 0, 0 );

    AknsUtils::GetCachedColor( skin, color, KAknsIIDQsnTextColors,

        EAknsCIQsnTextColorsCG6 );

    iLabel->OverrideColorL( EColorLabelText, color );

    iLabel->SetEmphasis( CEikLabel::ENoEmphasis );

    iLabel2->OverrideColorL(EColorLabelText, color );

    iLabel2->SetEmphasis( CEikLabel::ENoEmphasis );

    iLabel3->OverrideColorL(EColorLabelText, color );

    iLabel3->SetEmphasis( CEikLabel::ENoEmphasis );

    CCharFormatLayer* formatLayer = CEikonEnv::NewDefaultCharFormatLayerL();

    CleanupStack::PushL( formatLayer );

    TCharFormat format;

    TCharFormatMask formatMask;

    formatLayer->Sense( format, formatMask );

    format.iFontPresentation.iTextColor = color;

    formatMask.SetAttrib( EAttColor );

    formatLayer->SetL( format, formatMask );

    iEdwin->SetCharFormatLayer( formatLayer->CloneL() );

    iEdwin2->SetCharFormatLayer( formatLayer->CloneL() );

    CleanupStack::Pop( formatLayer );

    iEdwin3->SetCharFormatLayer( formatLayer );

    SetRect( aRect );

    ActivateL();

    ACPLOG( "CAcpProviderSpecificContainer::ConstructL end" );

    }

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

// CAcpProviderSpecificContainer::NewL

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

//      

CAcpProviderSpecificContainer* CAcpProviderSpecificContainer::NewL( 

    CAcpController& aController,

    const TRect& aRect )

    {    

    CAcpProviderSpecificContainer* self = 

        CAcpProviderSpecificContainer::NewLC( aController, aRect );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAcpProviderSpecificContainer::NewLC

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

//

CAcpProviderSpecificContainer* CAcpProviderSpecificContainer::NewLC(

    CAcpController& aController,

    const TRect& aRect )

    {    

    CAcpProviderSpecificContainer* self = 

        new ( ELeave ) CAcpProviderSpecificContainer( aController );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    return self;

    }

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

// CAcpProviderSpecificContainer::~CAcpProviderSpecificContainer

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

//

CAcpProviderSpecificContainer::~CAcpProviderSpecificContainer()

    {

    ACPLOG( 

      "CAcpProviderSpecificContainer::~CAcpProviderSpecificContainer begin" );

    delete iLabel;

    delete iLabel2;

    delete iLabel3;

    delete iEdwin;

    delete iEdwin2;    

    delete iEdwin3;

    delete iBgContext;

    ACPLOG( 

        "CAcpProviderSpecificContainer::~CAcpProviderSpecificContainer end" );

    }

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

// CAcpProviderSpecificContainer::ComponentControl

// From class CoeControl.

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

//

CCoeControl* CAcpProviderSpecificContainer::ComponentControl( 

    TInt aIndex ) const

    {

    const TInt KZeroCase  = 0;

    const TInt KOneCase   = 1;

    const TInt KTwoCase   = 2;

    const TInt KThreeCase = 3;

    const TInt KFourCase  = 4;

    const TInt KFiveCase  = 5;

    switch ( aIndex )

        {

            case KZeroCase:

                return iLabel;

            case KOneCase:

                return iLabel2;

    		case KTwoCase:

    			return iLabel3;

    		case KThreeCase:

    			return iEdwin;

    		case KFourCase:

    			return iEdwin2;	

    		case KFiveCase: 

    			return iEdwin3;

            default:

                return NULL;

        }

    }

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

// CAcpProviderSpecificContainer::MopSupplyObject

// From class CCoeControl.

// SKIN: pass context to child controls.

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

//

TTypeUid::Ptr CAcpProviderSpecificContainer::MopSupplyObject( TTypeUid aId )

    {

    if ( iBgContext )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CAcpProviderSpecificContainer::Draw

// From class CoeControl.

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

//

void CAcpProviderSpecificContainer::Draw( const TRect& aRect ) const

    {

    // Get the standard graphics context.

    CWindowGc& gc = SystemGc();

    // Draw skin backgound.

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

  	MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

    AknsDrawUtils::Background( skin, cc, this, gc, aRect );

    }

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

// CAcpProviderSpecificContainer::CountComponentControls

// From class CoeControl.

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

//

TInt CAcpProviderSpecificContainer::CountComponentControls() const

    {

    return KComponentControlCount;

    }

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

// CAcpProviderSpecificContainer::SizeChanged

// From class CoeControl.

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

//

void CAcpProviderSpecificContainer::SizeChanged()

    {

    RepositionLabels();

    // Redraw the control.

    DrawDeferred();

    }

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

// CAcpProviderSpecificContainer::HandleResourceChange

// From class CCoeControl.

// Called by framework when layout is changed.

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

//

void CAcpProviderSpecificContainer::HandleResourceChange( TInt aType )

    {

    CCoeControl::HandleResourceChange( aType );

    // *****************************

    // ADDED FOR SCALABLE UI SUPPORT

    // *****************************

    if ( KEikDynamicLayoutVariantSwitch == aType )

        {

        TRect rect;

        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );

        SetRect( rect );

        iBgContext->SetRect( rect );

        }

    }

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

// CAcpProviderSpecificContainer::ScrollText

// Scrolls text labels up or down.

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

//

void CAcpProviderSpecificContainer::ScrollText( TInt aDelta )

    {

    ACPLOG( "CAcpProviderSpecificContainer::ScrollText begin" );

    iScrollY += aDelta;

    if ( iScrollY > KScrollMax ) 

        {

        iScrollY = KScrollMax;

        }

    else if ( iScrollY < KScrollMin )

        {

        iScrollY = KScrollMin;

        }

    RepositionLabels();

    // Redraw the control.

    DrawDeferred();

    ACPLOG( "CAcpProviderSpecificContainer::ScrollText end" );

    }

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

// CAcpProviderSpecificContainer::RepositionLabels

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

//

void CAcpProviderSpecificContainer::RepositionLabels()

    {

    const TInt KWidthX = Rect().Width() - KPositionX;

    const TInt KDeltaY = Rect().Height() / KEight;

    TInt yPos = iScrollY;

    iLabel->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, KDeltaY ) );

    yPos += KDeltaY;

    iEdwin->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, KDeltaY ) );

    yPos += KDeltaY;

    iLabel2->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, KDeltaY ) );

    yPos += KDeltaY;

    iEdwin2->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, KDeltaY ) );

    yPos += KDeltaY;

    iLabel3->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, KDeltaY ) );

    yPos += KDeltaY;

    iEdwin3->SetExtent( TPoint( KPositionX, yPos ), 

        TSize( KWidthX, Rect().Height() ) );

    }

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

// CAcpProviderSpecificContainer::OfferKeyEventL

// Handles key events.

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

//

TKeyResponse CAcpProviderSpecificContainer::OfferKeyEventL(

    const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    ACPLOG( "CAcpProviderSpecificContainer::OfferKeyEventL begin" );

    TKeyResponse ret = EKeyWasNotConsumed;

    switch ( aKeyEvent.iScanCode )

        {

        case EStdKeyUpArrow:

            if ( aType != EEventKeyUp )

                {

                ScrollText( KScrollSpeed );

                ret = EKeyWasConsumed;

                }

            break;

        case EStdKeyDownArrow:

            if ( aType != EEventKeyUp )

                {

                ScrollText( -KScrollSpeed );

                ret = EKeyWasConsumed;

                }

            break;

        default:

            break;

        }

    ACPLOG( "CAcpProviderSpecificContainer::OfferKeyEventL end" );

    return ret;

    }

// End of file.