/*

* Copyright (c) 2004 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:  Container class for cost warning view

*

*/

#include <txtrich.h>

/* don't need to change it to lower case */

#include <AknsBasicBackgroundControlContext.h> // CAknsBasicBackgroundControlContext

#include <eikedwin.h>

#include <utf.h>

#include <stringloader.h>

#include <internetradio.rsg>

#include "irui.h"

#include "ir.hrh"

#include "ircommon.h"

#include "irdebug.h"

#include "irbaseview.h"

#include "ircostwarningview.h"

#include "ircostwarningcontainer.h"

#include "irapplication.h"

#include "irnetworkcontroller.h"

#include "irsettings.h"

const TInt KNoOfLines = 50;

const TInt KNoOfCharacters = 3000;

const TInt KScrollbar = 15;

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

//  CIRCostWarningContainer::NewL

//  Creates a new instance of CIRCostWarningContainer

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

//

CIRCostWarningContainer* CIRCostWarningContainer::NewL(const TRect& aRect ,

					CIRCostWarningView& aView)

    {

	IRLOG_DEBUG( "CIRCostWarningContainer::NewL - Entering" );

    CIRCostWarningContainer* self = CIRCostWarningContainer::NewLC(aRect,aView);

    CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRCostWarningContainer::NewL - Exiting." );

    return self;

    }

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

//  CIRCostWarningContainer::NewLC

//  Creates a new instance of CIRCostWarningContainer and leaves it on the cleanup stack.

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

//

CIRCostWarningContainer* CIRCostWarningContainer::NewLC(const TRect& aRect ,

						CIRCostWarningView& aView)

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::NewLC - Entering" );

    CIRCostWarningContainer* self = new (ELeave) CIRCostWarningContainer(aView);

    CleanupStack::PushL(self);

    self->ConstructL(aRect);

	IRLOG_DEBUG( "CIRCostWarningContainer::NewLC - Exiting." );

    return self;

    }

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

// C++ default constructor.

// C++ default constructor can NOT contain any code, that might leave.

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

//

CIRCostWarningContainer::CIRCostWarningContainer( CIRCostWarningView& aMsgView ):

                                                  iMsgView(aMsgView)

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::CIRCostWarningContainer - Entering" );

    IRLOG_DEBUG( "CIRCostWarningContainer::CIRCostWarningContainer - Exiting" );

    }

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

// CIRCostWarningContainer::ConstructL()

// Two Phase constructor

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

//

void CIRCostWarningContainer::ConstructL( const TRect& aRect )

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::ConstructL - Entering" );

    CIRUi* ui = reinterpret_cast<CIRUi*>( iCoeEnv->AppUi() );

    CreateWindowL();

    iEditor = CreateEditorL();

    SetReadOnly(ETrue);

    SetRect(aRect);

    iEditor->SetRect(aRect);

    // for Skin Support, Create background control context:

    iBackGroundControlContext = CAknsBasicBackgroundControlContext::NewL(

                    KAknsIIDQsnBgAreaMain,  // Default mainpane skinning

                    Rect(),                 // Layout to the entire client rect

                    EFalse );

    if ( iBackGroundControlContext )

        {

        iEditor->SetSkinBackgroundControlContextL( iBackGroundControlContext );

        }

	if (!ui->iIRSettings->IsFlagCostWarningL())

		{

        ui->SetCommandSetL(R_IR_CBA_CONTINUE_EXIT);

		UpdateTermsL(); 

		}

    else

	    {   

	    ui->SetCommandSetL(R_IR_CBA_ACCEPT_DECLINE);                

		UpdateTermsL();   	

	    }

   	iEditor->SetCursorPosL(0, EFalse );

	IRLOG_DEBUG( "CIRCostWarningContainer::ConstructL - Exiting" );

    }

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

// CIRCostWarningContainer::~CIRCostWarningContainer()

// Destructor

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

//

CIRCostWarningContainer::~CIRCostWarningContainer()

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::~CIRCostWarningContainer - Entering" );

    delete iBackGroundControlContext;

    delete iEditor;

    if (iRichText)

	    {

	    delete iRichText;

	    iRichText = NULL;	

	    }

    delete iTermsData;

    IRLOG_DEBUG( "CIRCostWarningContainer::~CIRCostWarningContainer - Exiting" );

    }

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

// CIRCostWarningContainer::ComponentControl() const

// returns a pointer to the control under this view depending on the index

// passed,to the framework.

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

//

TInt CIRCostWarningContainer::CountComponentControls() const

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::CountComponentControls - Entering" );

    return iEditor ? 1 : 0;

    }

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

// CIRCostWarningContainer::ComponentControl() const

// returns a pointer to the control under this view depending on the index

// passed,to the framework.

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

// 

CCoeControl* CIRCostWarningContainer::ComponentControl( TInt aIndex ) const

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::ComponentControl - Entering" );

    CCoeControl* ctrl = NULL;

    switch(aIndex)

	    {

    	case 0:

	    	ctrl = iEditor;

	    	break;

	    default:

	    	break;

    	}

    IRLOG_DEBUG( "CIRCostWarningContainer::ComponentControl - Exiting" );

    return ctrl;

    }

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

// TKeyResponse CIRCostWarningContainer::OfferKeyEventL( )

// From class CCoeControl.

// We need to catch the selection key event in order to do a couple of things 

// in moving state make the movement, and in normal state open channel 

// specific popup menu. Up and down buttons are forwarded to the list.

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

//

TKeyResponse CIRCostWarningContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,TEventCode aType )

    {    

    IRLOG_DEBUG( "CIRCostWarningContainer::OfferKeyEventL - Entering" );   	

	TKeyResponse res = EKeyWasNotConsumed;

    if (aType == EEventKey)

    {

        if (aKeyEvent.iCode == EKeyDownArrow)

        {

            iEditor->MoveCursorL (TCursorPosition::EFPageDown, EFalse);

            res = EKeyWasConsumed;

        }

        else if (aKeyEvent.iCode == EKeyUpArrow)

        {

            iEditor->MoveCursorL (TCursorPosition::EFPageUp, EFalse);

            res = EKeyWasConsumed;

        }

        else

        {

            res = iEditor->OfferKeyEventL(aKeyEvent, aType);

        }

    }

    IRLOG_DEBUG( "CIRCostWarningContainer::OfferKeyEventL - Exiting" );

    return res;

    }

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

// CIRCostWarningContainer::UpdateTermsL

// To update the required data whenever called

// 

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

//

void CIRCostWarningContainer::UpdateTermsL()

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::UpdateTermsL - Entering" );

    CreateRichTextDataL();

    iEditor->DrawNow();

    ActivateL();		

    IRLOG_DEBUG( "CIRCostWarningContainer::UpdateTermsL - Exiting" );

    }

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

// CIRCostWarningContainer::SizeChanged

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

//

void CIRCostWarningContainer::SizeChanged()

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::SizeChanged - Entering" );

    if ( iEditor ) 

        {

		TRect   rectParent = Rect();

		TPoint	point1( rectParent.iTl.iX, rectParent.iTl.iY );

		TRect scrollBarRect = iEditor->ScrollBarFrame()->VerticalScrollBar()->Rect();

		iEditor->SetExtent( point1, TSize( rectParent.Width() - scrollBarRect.Width(),

		    					rectParent.Height() - KScrollbar  ) );

        iEditor->DrawNow();

        }

    IRLOG_DEBUG( "CIRCostWarningContainer::SizeChanged - Exiting" );

    }

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

// CIRCostWarningContainer::CreateEditorL

// Creates the CEikRichTextEditor object

// 

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

//

CEikRichTextEditor* CIRCostWarningContainer::CreateEditorL() const

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::CreateEditorL - Entering" );

    CEikRichTextEditor* editor = new (ELeave) CEikRichTextEditor;

    CleanupStack::PushL( editor );

    editor->SetContainerWindowL(*this);

    TInt edwinflags =  CEikEdwin::EReadOnly | CEikEdwin::EEdwinAlternativeWrapping ;

    editor->ConstructL(this, KNoOfLines,KNoOfCharacters,edwinflags );

    // create vertical scrollbar

    editor->CreateScrollBarFrameL();

    editor->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,

    												   CEikScrollBarFrame::EAuto );

	editor->ActivateL();

    CleanupStack::Pop(editor); // editor

    IRLOG_DEBUG( "CIRCostWarningContainer::CreateEditorL - Exiting" );

    return editor;

    }

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

// void CIRCostWarningContainer::Draw( const TRect& aRect ) const

// From class CCoeControl.

// Draws the control.

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

//

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

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::Draw - Entering" );

    CWindowGc& gc = SystemGc();

    // for clearing gap between editor and the view rect

    if ( IsReadyToDraw() )

        {

        DrawUtils::ClearBetweenRects( gc, aRect, iEditor->Rect() );

        if ( iBackGroundControlContext )

            {//Draw the skin background

            MAknsSkinInstance* skin = AknsUtils::SkinInstance();

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

            }

        }

    IRLOG_DEBUG( "CIRCostWarningContainer::Draw - Exiting" );

    }

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

// CIRCostWarningContainer::SetReadOnly

// Making the editor as ReadOnly

// 

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

//

void CIRCostWarningContainer::SetReadOnly( TBool aReadOnly )

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::SetReadOnly - Entering" );

    iEditor->SetReadOnly(aReadOnly);

    IRLOG_DEBUG( "CIRCostWarningContainer::SetReadOnly - Exiting" );

    }

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

// CIRCostWarningContainer::SetDataContentL

// Setting the RichText into the Editor

// 

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

//

void CIRCostWarningContainer::SetDataContentL( CRichText& aText )

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::CIRCostWarningContainer - Entering" );

    iEditor->SetDocumentContentL(aText);

   	TRect   rectParent = Rect();

    TPoint	point1( rectParent.iTl.iX, rectParent.iTl.iY );

    TRect scrollBarRect = iEditor->ScrollBarFrame()->VerticalScrollBar()->Rect();

	iEditor->SetExtent( point1, TSize( rectParent.Width() - scrollBarRect.Width(),

	        					rectParent.Height() - KScrollbar  ) );

    IRLOG_DEBUG( "CIRCostWarningContainer::SetDataContentL - Exiting" );  

    }

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

// CIRCostWarningContainer::CreateRichTextDataL

// Creating the CRichText object

// 

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

//

void CIRCostWarningContainer::CreateRichTextDataL()

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::CreateRichTextDataL - Entering" );

    CIRUi* ui = reinterpret_cast<CIRUi*>( iCoeEnv->AppUi() );

    CParaFormatLayer* globalParaLayer = CParaFormatLayer::NewL();

    CleanupStack::PushL(globalParaLayer);

    CCharFormatLayer* globalCharLayer = NULL;   

    TRgb textColor;

    TCharFormat charFormat;

    TCharFormatMask formatMask;

    iEditor->RichText()->GetCharFormat( charFormat, formatMask, 0, 0 );

    MAknsSkinInstance * skin=AknsUtils::SkinInstance () ;

    TInt error = AknsUtils::GetCachedColor(

        skin,

        textColor,

        KAknsIIDQsnTextColors,

        EAknsCIQsnTextColorsCG6 );

	if( error != KErrNone )

		{

		textColor = KRgbBlack;

		}

	charFormat.iFontPresentation.iTextColor = textColor;	

	charFormat.iFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

    formatMask.SetAll();

    globalCharLayer = CCharFormatLayer::NewL( charFormat, formatMask );

    CleanupStack::PushL( globalCharLayer );

    iRichText = CRichText::NewL( globalParaLayer, globalCharLayer );

    CParaFormat *para=CParaFormat::NewL();

    CleanupStack::PushL( para );

    TParaFormatMask paraMask;

    paraMask.SetAttrib(EAttSpaceAfter);	

    if (!ui->iIRSettings->IsFlagCostWarningL())

	    {

		TCharFormat charFormat;

		TCharFormatMask charFormatMask;

		TPtrC costHeading;

		HBufC *CWHeading = StringLoader::LoadLC(R_IRAPP_COST_WARNING_HEADING);

		costHeading.Set(*CWHeading);

		charFormatMask.SetAttrib(EAttFontStrokeWeight);

		charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

		iRichText->SetInsertCharFormatL(charFormat,charFormatMask,iRichText->DocumentLength());

		iRichText->InsertL(iRichText->DocumentLength(),costHeading);

		iRichText->InsertL(iRichText->DocumentLength(),CEditableText::ELineBreak );

	    iRichText->InsertL(iRichText->DocumentLength(), CEditableText::ELineBreak );

		iRichText->CancelInsertCharFormat();

		CleanupStack::PopAndDestroy(CWHeading);	

		TPtrC costText;

		HBufC *CWInfo = StringLoader::LoadLC(R_IRAPP_COST_WARNING_INFO);

		costText.Set(*CWInfo);

		charFormatMask.SetAttrib(EAttFontStrokeWeight);

		charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

		iRichText->SetInsertCharFormatL(charFormat,charFormatMask,iRichText->DocumentLength());

		iRichText->InsertL(iRichText->DocumentLength(),costText);

		iRichText->CancelInsertCharFormat();

		CleanupStack::PopAndDestroy(CWInfo);		

	    }

    else

	    {

	    ReadTermsFromFileL();

	    LayoutTermsL();

	    }

    SetDataContentL( *iRichText );

    iEditor->SetCharFormatLayer( globalCharLayer );

    iEditor->SetCursorPosL(0, EFalse );

    CleanupStack::PopAndDestroy(para);  // para

    CleanupStack::Pop(globalCharLayer);            // globalCharLayer

    CleanupStack::PopAndDestroy(globalParaLayer);  // globalParaLayer

    IRLOG_DEBUG( "CIRCostWarningContainer::CreateRichTextDataL - Exiting" );

    }

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

// CIRCostWarningContainer::GetEditor

// Getting the contents of RichText to the Editor

// 

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

CRichText* CIRCostWarningContainer::GetEditor() const

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::GetEditor" );

    return iEditor->RichText();

    }

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

// CIRCostWarningContainer::HandleResourceChange

// Handles a change to the application's resources which are shared across

// the environment.

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

void CIRCostWarningContainer::HandleResourceChange( TInt aType )

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::HandleResourceChange - Entering" );

    CCoeControl::HandleResourceChange( aType );

	if( aType == KEikDynamicLayoutVariantSwitch )

		{

		TRect rect;

		TBool bRes = AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane  , rect);

		SetRect(rect);

        iEditor->HandleResourceChange( aType );

		if ( iBackGroundControlContext )

			{

			iBackGroundControlContext->SetRect( Rect() );

			}

		}

	else if( ( aType == KAknsMessageSkinChange ) && ( iBackGroundControlContext ) )

			{

			TRAPD( ignore, iEditor->SetSkinBackgroundControlContextL( iBackGroundControlContext ) );

            if(ignore)

				{

				return;	

				}

			if (iRichText)

				{

				delete iRichText;

				iRichText=NULL;	

				}

			TRAPD(err ,UpdateTermsL());

			if(err)

				{

				return;	

				}

			TRAPD( error ,iEditor->SetCursorPosL(0, EFalse ));

			if(error)

				{

				return;

				}

	        } 

	IRLOG_DEBUG( "CIRCostWarningContainer::HandleResourceChange - Exiting" );			

    }

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

// CIRCostWarningContainer::ReadTermsFromFileL()

// Reads the text from a HTML file

//

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

void CIRCostWarningContainer::ReadTermsFromFileL()

    {

    IRLOG_DEBUG( "CIRCostWarningContainer::ReadTermsFromFileL - Entering" );

    RFs& fs = static_cast<CEikonEnv*>(iCoeEnv)->FsSession();

	TFileName privatePath;

	User::LeaveIfError(fs.PrivatePath(privatePath));

	HBufC* termsFileName = StringLoader::LoadL(R_IRAPP_TERMS_FILE);

    TParse parse;

    parse.Set(*termsFileName, &privatePath, NULL);

    delete termsFileName;

    TFileName fileName = parse.FullName();

    CompleteWithAppPath(fileName);

    RFile fileHandle;

    User::LeaveIfError(fileHandle.Open(fs, fileName, EFileRead));

    CleanupClosePushL(fileHandle);

    TInt fileSize;

    User::LeaveIfError( fileHandle.Size( fileSize ) );

    HBufC8* termsData = HBufC8::NewLC( fileSize );

    TPtr8 pData8( termsData->Des() );

    User::LeaveIfError( fileHandle.Read( pData8 ) );

    delete iTermsData;

    iTermsData = NULL;

    iTermsData = CnvUtfConverter::ConvertToUnicodeFromUtf8L( pData8 );

    CleanupStack::PopAndDestroy( termsData );

    CleanupStack::PopAndDestroy( &fileHandle );

    IRLOG_DEBUG( "CIRCostWarningContainer::ReadTermsFromFileL - Exiting" );

    }

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

// CIRCostWarningContainer::LayoutTermsL()

// Inserts the text into the RichText object (Heading of Terms & Conditions).

//

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

void CIRCostWarningContainer::LayoutTermsL()