/*
* 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()
{
IRLOG_DEBUG( "CIRCostWarningContainer::LayoutTermsL - Entering" );
TCharFormat charFormat;
TCharFormatMask charFormatMask;
TInt dataCounter(0);
iTotalTextHeight = 0;
TIRTermsTextType type(EIRTermsTextInvalid);
TPtrC text;
charFormatMask.SetAttrib(EAttFontStrokeWeight);
charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
iRichText->SetInsertCharFormatL(charFormat,charFormatMask,iRichText->DocumentLength());
HBufC *CWHeading = StringLoader::LoadLC(R_IRAPP_TERMS_CONDITIONS_HEADING);
TPtrC termsHeading;
termsHeading.Set( *CWHeading );
iRichText->InsertL(iRichText->DocumentLength(),termsHeading);
iRichText->InsertL(iRichText->DocumentLength(), CEditableText::ELineBreak );
iRichText->CancelInsertCharFormat();
CleanupStack::PopAndDestroy(CWHeading);
while (GetNextTermsL(dataCounter, text, type))
{
if( type != EIRTermsTextHeading && type != EIRTermsTextNormal)
{
User::Leave(KErrCorrupt);
}
}
IRLOG_DEBUG( "CIRCostWarningContainer::LayoutTermsL - Exiting" );
}
// ---------------------------------------------------------------------------
// GetNextTermsL()
// Inserts the text into the RichText object (Body of Terms & Conditions).
// ---------------------------------------------------------------------------
//
TBool CIRCostWarningContainer::GetNextTermsL(TInt& aCounter,
TPtrC& aTermsText, TIRTermsTextType& aTermsType)
{
IRLOG_DEBUG( "CIRCostWarningContainer::GetNextTermsL - Entering" );
TCharFormat charFormat;
TCharFormatMask charFormatMask;
TBool textFound(EFalse);
_LIT(KIRHeadingStartTag, "<h1>");
_LIT(KIRHeadingEndTag, "</h1>");
_LIT(KIRNormalStartTag, "<p>");
_LIT(KIRNormalEndTag, "</p>");
TPtr data = iTermsData->Des();
TInt heading = data.Mid(aCounter).Find(KIRHeadingStartTag);
TInt normal = data.Mid(aCounter).Find(KIRNormalStartTag);
if ((heading != KErrNotFound) || (normal != KErrNotFound))
{
if( ((heading != KErrNotFound) && (normal != KErrNotFound) && (heading<normal)) ||
(normal == KErrNotFound) )
{
aTermsType = EIRTermsTextHeading;
aCounter = aCounter + heading + KIRHeadingStartTag().Length();
}
else
{
aTermsType = EIRTermsTextNormal;
aCounter = aCounter + normal + KIRNormalStartTag().Length();
}
if( aTermsType == EIRTermsTextNormal )
{
aTermsText.Set(data.Mid(aCounter, data.Mid(aCounter).Find(KIRNormalEndTag)));
aCounter = aCounter + aTermsText.Length() + KIRNormalEndTag().Length();
charFormatMask.SetAttrib(EAttFontStrokeWeight);
charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);
iRichText->SetInsertCharFormatL(charFormat,charFormatMask,iRichText->DocumentLength());
iRichText->InsertL(iRichText->DocumentLength(),aTermsText);
iRichText->InsertL(iRichText->DocumentLength(), CEditableText::ELineBreak );
iRichText->CancelInsertCharFormat();
}
else
{
aTermsText.Set(data.Mid(aCounter, data.Mid(aCounter).Find(KIRHeadingEndTag)));
aCounter = aCounter + aTermsText.Length() + KIRHeadingEndTag().Length();
charFormatMask.SetAttrib(EAttFontStrokeWeight);
charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
iRichText->SetInsertCharFormatL(charFormat,charFormatMask,iRichText->DocumentLength());
iRichText->InsertL(iRichText->DocumentLength(),aTermsText);
iRichText->InsertL(iRichText->DocumentLength(), CEditableText::ELineBreak );
iRichText->CancelInsertCharFormat();
}
textFound = ETrue;
}
IRLOG_DEBUG( "CIRCostWarningContainer::GetNextTermsL - Exiting" );
return textFound;
}
// ---------------------------------------------------------------------------------
//
// CIRCostWarningContainer::TandCAcceptL()
// For setting the terms and conditions flag
// ---------------------------------------------------------------------------------
void CIRCostWarningContainer::TandCAcceptL() const
{
IRLOG_DEBUG( "CIRCostWarningContainer::TandCAcceptL - Entering" );
CIRUi* ui = static_cast<CIRUi*>( iCoeEnv->AppUi() );
//set the t&c flag,so that it doesnot come up the next time
ui->iIRSettings->SetFlagTermsAndConditionsL();
// ui->iNetworkController->ChooseAccessPointL()
if(ui->GetPlsActiavted())
{
ui->ActivateLocalViewL(KIRPlsViewID);
}
else
{
if(ui->IsFirstTime())
{
ui->ActivateLocalViewL(KIRFirstTimeViewId);
}
else
{
ui->ActivateLocalViewL(KIRMainChoiceViewID);
}
}
IRLOG_DEBUG( "CIRCostWarningContainer::TandCAcceptL - Exiting" );
}
// ---------------------------------------------------------------------------
//
// CIRCostWarningContainer::CostWarningContinueL()
// For displaying the soft keys
// ---------------------------------------------------------------------------
void CIRCostWarningContainer::CostWarningContinueL()
{
IRLOG_DEBUG( "CIRCostWarningContainer::CostWarningContinueL - Entering" );
CIRUi* ui = static_cast<CIRUi*>( iCoeEnv->AppUi() );
ui->iIRSettings->SetFlagCostWarningL();
if (iRichText)
{
delete iRichText;
iRichText=NULL;
}
UpdateTermsL();
iEditor->SetCursorPosL(0,EFalse );
CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();
cba->SetCommandSetL( R_IR_CBA_ACCEPT_DECLINE );
cba->DrawDeferred();
DrawNow();
IRLOG_DEBUG( "CIRCostWarningContainer::CostWarningContinueL - Exiting" );
}
// ---------------------------------------------------------------------------
// CIRCostWarningContainer::HandlePointerEventL()
// Handles pointer events.
// ---------------------------------------------------------------------------
void CIRCostWarningContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
{
IRLOG_DEBUG( "CIRCostWarningContainer::HandlePointerEventL - Entering" );
if(iEditor)
{
CCoeControl::HandlePointerEventL( aPointerEvent );
IRLOG_DEBUG( "CIRCostWarningContainer::HandlePointerEventL - Exiting" );
}
}