/*

* Copyright (c) 2002-2010 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: 

*             Declares container control for application.

*

*/

// INCLUDE FILES

#include    <ussd.rsg>

#include    <aknkeys.h>

#include    <eikedwin.h>

#include    <bldvariant.hrh>

#include    <featmgr.h>

#include    <centralrepository.h>

#include    <telinternalcrkeys.h>

#include <csxhelp/ussd.hlp.hrh>  // for help context

// For skinning.

#include    <AknsBasicBackgroundControlContext.h>

#include    <AknsDrawUtils.h>

#include    <AknsUtils.h>

#include    <txtglobl.h>

#include    "telephonyvariant.hrh"

#include    "UssdComms.h"

#include    "UssdNaviPane.h"

#include    "UssdAppUi.h"

#include    "UssdContainer.h"

#include    "UssdEditorLines.h"

#include    "UssdLayout.h"

#include    "ussd.hrh"

#include    "UssdApp.h" // for applicationUID

#include    "UssdLogger.h"

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

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

// CUssdContainer::CUssdContainer

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CUssdContainer::CUssdContainer( CUssdAppUi& aAppUi ): iAppUi( aAppUi )

    {

    }

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

// CUssdContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUssdContainer::ConstructL( const TRect& aRect )

    {

    _LOGSTRING( "CUssdContainer::ConstructL =>" )

    CreateWindowL();

    // Create background control context for skins.

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgAreaMainMessage, aRect, ETrue /*Parent absolute*/ );

    // Create editor

    iEditor = CreateEdwinL();

    // Lines

    iLines = new ( ELeave ) CUssdEditorLines;

    iLines->ConstructL( this );

    TInt featureBitmask( 0 );

    // Connecting and initialization KCRUidTelVariation

    CRepository* repository = CRepository::NewL( KCRUidTelVariation );

    CleanupStack::PushL( repository );

    // Get the value from Central Repository

    repository->Get( KTelVariationFlags, featureBitmask );

    if ( featureBitmask & KTelephonyLVFlagUssdUIRemainingChars )

        {

        iNaviPaneHandler = CUssdNaviPane::NewL( iAppUi );

        }

    CleanupStack::PopAndDestroy( repository );

    // Finish the job

    SetRect( aRect );

    ActivateL();

    iEditor->SetFocus( ETrue );

    _LOGSTRING( "CUssdContainer::ConstructL <=" )

    }

// Destructor

CUssdContainer::~CUssdContainer()

    {

    _LOGSTRING( "CUssdContainer::~CUssdContainer =>" ) 

    delete iLines;

    AknsUtils::DeregisterControlPosition( iEditor );

    delete iEditor;

    delete iNaviPaneHandler;

    delete iBgContext; // For skinning, can be deleted, NULL if not exist.

    _LOGSTRING( "CUssdContainer::~CUssdContainer <=" )

    }

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

// CUssdContainer::HandleEdwinEventL

// Called by framework when the Editor is changed

//

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

//

void CUssdContainer::HandleEdwinEventL( CEikEdwin* /*aEdwin*/,

        TEdwinEvent aEventType )

    {

     switch( aEventType )

         {

         case EEventTextUpdate:

             {

             UpdateNavipaneMsgLengthL();

             break;

             }

         default:

             break;

         }

    }

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

// CUssdContainer::SizeChanged

// Called by framework when the view size is changed

//

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

//

void CUssdContainer::SizeChanged()

    {

    // Backgroud context

    iBgContext->SetParentPos( PositionRelativeToScreen() );

    iBgContext->SetRect( Rect() ) ;

    // Edwin

    AknLayoutUtils::LayoutEdwin(

        iEditor,

        Rect(),

        UssdLayout::MessageWritingTexts3() );

    // We need to make some room for scrollbar to fit

    // so the editor must be narrowed down a bit.

    TAknLayoutId layout = UssdLayout::CurrentLayout();

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

    if( layout != EAknLayoutIdABRW )

        {

        TPoint editorTLPoint(Rect().iTl.iX, iEditor->Rect().iTl.iY);

        iEditor->SetExtent( editorTLPoint ,

                    TSize( Rect().Width() - sbr.Width(), sbr.Height() ) );

        }

    else // right to left layout

        {

        TPoint editorTLPoint( ( Rect().iTl.iX + sbr.Width() ),

                                iEditor->Rect().iTl.iY);

        iEditor->SetExtent( editorTLPoint ,

                            TSize( Rect().Width() - sbr.Width(),

                            sbr.Height() ) );

        }

    TRAP_IGNORE( UpdateNavipaneMsgLengthL() );

    // overwite inputmode in portraitmode

    if ( Rect().Height() > Rect().Width() )

        {

        iEditor->SetAknEditorCurrentInputMode( EAknEditorNumericInputMode );

        }

    // Change the colour of the edwin if needed

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if ( skin )

        {

        TRgb color;

        TInt error = AknsUtils::GetCachedColor(

            skin,

            color,

            KAknsIIDQsnTextColors,

            EAknsCIQsnTextColorsCG6 );

        if ( error == KErrNone )

            {

            TCharFormat charFormat;

            TCharFormatMask charFormatMask;

            ( reinterpret_cast< CGlobalText* >( iEditor->Text() ) )

                ->GetCharFormat( charFormat, charFormatMask, 0, 0 );

            charFormat.iFontPresentation.iTextColor = color;

            charFormatMask.SetAll();

            CCharFormatLayer* charFormatLayer = NULL;

            TRAP( error, charFormatLayer =

                CCharFormatLayer::NewL( charFormat,charFormatMask ) );

            if ( !error )

                {

                iEditor->SetCharFormatLayer( charFormatLayer );

                }

            }

        }

    // Set editor lines

    iLines->SetRect( Rect() );

    AknsUtils::RegisterControlPosition( iEditor );

    }

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

// CUssdContainer::CountComponentControls

//

//

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

//

TInt CUssdContainer::CountComponentControls() const

    {

    return 2; // editor and lines

    }

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

// CUssdContainer::ComponentControl

//

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

//

CCoeControl* CUssdContainer::ComponentControl( TInt aIndex ) const

    {

    switch ( aIndex )

        {

        case 0:

            return iEditor;

        case 1:

            return iLines;

        default:

            return NULL;

        }

    }

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

// CUssdContainer::Draw

//

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

//

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

    {

    CWindowGc& gc = SystemGc();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if ( iBgContext )

        {

        AknsDrawUtils::Background(

            skin, iBgContext, this, gc, aRect);

        }

    else

        {

        // Otherwise clear the area

        gc.SetBrushColor( AKN_LAF_COLOR( UssdLayout::LayoutColourWhite() ) );

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

        }

    }

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

// CUssdContainer::OfferKeyEventL

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

//

TKeyResponse CUssdContainer::OfferKeyEventL(

    const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    _LOGSTRING3(

    "CUssdContainer::OfferKeyEventL =>,TKeyEvent::iCode=%d,TEventCode=%d",

    aKeyEvent.iCode, aType )

    TKeyResponse response = EKeyWasNotConsumed;

    // Special key handling comes first.

    if ( aKeyEvent.iScanCode == EStdKeyYes ) // Send key.

        {

        // The reason that the send key is handled via TStdScanCode rather than TKeyCode is that

        // we also have to be able to catch EEventKeyUp and EEventKeyDown key events in addition

        // to EEventKey. This is because TKeyEvent::iCode is always 0 when TEventCode is EEventKey.

        if ( iEditor->TextLength() )

            {

            if ( aType == EEventKey )

                {

                if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                    {

                    iAppUi.HandleCommandL( EUssdMenuItemSend );

                    }

                else

                    {

                    iAppUi.HandleCommandL( EUssdSoftkeySend );

                    }

                }

            response = EKeyWasConsumed; // Dialer should not be launched when the USSD string exists and send key is used.

            }

        }

    else if ( aKeyEvent.iCode == EKeyEscape )

        {

        iAppUi.HandleCommandL( EAknSoftkeyExit );

        response = EKeyWasConsumed;

        }

    else // Default keys are handled here.

        {

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

        if ( aType == EEventKey || aType == EEventKeyUp )

            {

            UpdateNavipaneMsgLengthL();

            }

        if ( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

            {

            // Change softkeys if needed.

            iAppUi.SetSoftkeySendVisibleL( iEditor->TextLength() != 0 );

            }

            iAppUi.Cba()->SetCommandSetL( R_USSD_SOFTKEYS_OPTIONS_EXIT_OPTIONS );

            iAppUi.Cba()->DrawNow();

        }

    _LOGSTRING2(

    "CUssdContainer::OfferKeyEventL <=, response=%d", response )

    return response;

    }

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

// CUssdContainer::Editor

// Give editor

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

//

CEikEdwin& CUssdContainer::Editor()

    {

    return *iEditor;

    }

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

// CUssdContainer::FocusChanged

//

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

//

void CUssdContainer::FocusChanged( TDrawNow aDrawNow )

    {

    iEditor->SetFocus( IsFocused(), aDrawNow );

    }

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

// CUssdContainer::GetHelpContext

// This function is called when Help application is launched.

//

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

//

void CUssdContainer::GetHelpContext(

    TCoeHelpContext& aContext ) const

    {

    // If help defined.

    if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

        {

        aContext.iMajor = KUidussd;

        aContext.iContext = KUSSD_HLP_EDITOR;

        }

    // If help not defined, do nothing

    }

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

// CUssdContainer::HandleResourceChange

// This function is called when Help application is launched.

//

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

//

void CUssdContainer::HandleResourceChange( TInt aType )

    {

    switch ( aType )

        {

        case KEikColorResourceChange:

        case KAknsMessageSkinChange:

            {

            SizeChanged();

            DrawDeferred();

            break;

            }

        default:

            {

            CCoeControl::HandleResourceChange( aType );

            }

        }

    }

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

// CUssdContainer::MopSupplyObject

//

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

//

TTypeUid::Ptr CUssdContainer::MopSupplyObject( TTypeUid aId )

    {

    if ( aId.iUid == MAknsControlContext::ETypeId )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CUssdContainer::CreateEdwinL

// Creates new edwin

//

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

//

CEikEdwin* CUssdContainer::CreateEdwinL()

    {

    CEikEdwin* newEditor = new ( ELeave ) CEikEdwin;

    CleanupStack::PushL( newEditor );

    newEditor->SetContainerWindowL( *this );

    //Set the editor observer

    newEditor->SetEdwinObserver( this );

    newEditor->SetAknEditorAllowedInputModes(

        EAknEditorNumericInputMode | EAknEditorTextInputMode );

    newEditor->SetAknEditorInputMode( EAknEditorNumericInputMode );

    newEditor->SetAknEditorNumericKeymap( EAknEditorStandardNumberModeKeymap );

    TInt editorFlags = EAknEditorFlagNoT9 | EAknEditorFlagEnableScrollBars | 

        EAknEditorFlagLatinInputModesOnly;

     if( FeatureManager::FeatureSupported( KFeatureIdPenSupport ) )

        {

        editorFlags |= EAknEditorFlagDeliverVirtualKeyEventsToApplication;

        }

    newEditor->SetAknEditorFlags( editorFlags );

    // Get the layout, i.e. variant.

    EVariantFlag variant = AknLayoutUtils::Variant();

    // According to layout, construct the editor.

    if ( variant == EApacVariant )

        {

        // APAC variant

        AknEditUtils::ConstructEditingL( newEditor , R_USSD_EDWIN_EDITOR_APAC );

        }

    else

        {

        // EEuropeanVariant (includes ABRW)

        AknEditUtils::ConstructEditingL( newEditor , R_USSD_EDWIN_EDITOR_ELAF );

        }

    CleanupStack::Pop( newEditor );

    return newEditor;

    }

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

// CUssdContainer::UpdateNavipaneMsgLengthL

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

void CUssdContainer::UpdateNavipaneMsgLengthL()

    {

    _LOGSTRING( "CUssdContainer::UpdateNavipaneMsgLengthL =>" )

    if ( iNaviPaneHandler )

        {

        TInt maxLen=0;

        TBuf<KUssdEditorMaxLenght> inputTexts;

        iEditor->GetText( inputTexts );

        maxLen = iNaviPaneHandler->UpdateMsgLengthL( inputTexts, this );

        // if pasted more than 91 chinese characters then it must be

        // cutted and set correct message length in navi pane

        if ( inputTexts.Length() > maxLen )

            {

            inputTexts.Copy( inputTexts.Left( maxLen ) );

            iEditor->SetTextL( &inputTexts );

            iNaviPaneHandler->UpdateMsgLengthL( inputTexts, this );

            iEditor->DrawNow();

            iEditor->SetCursorPosL( maxLen, EFalse );

            }

        iEditor->SetMaxLength( maxLen );

        }

    _LOGSTRING( "CUssdContainer::UpdateNavipaneMsgLengthL <=" )

    }

// End of File