/*

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

*

*/

//  INCLUDES

#include <coemain.h>

#include <bautils.h>

#include <AknsItemID.h> 

#include <AknsSkinInstance.h>

#include <AknsUtils.h> 

#include <aknlayoutscalable_avkon.cdl.h>

 #include <AknUtils.h> 

#include <peninputbutton.h>

#include <peninputcommonbutton.h>

#include <peninputdragbutton.h>

#include <peninputbasewindowext.h>

#include <peninputcommonlayoutglobalenum.h>

#include <peninputlayoutinputmodechoice.h>

#include <peninputlayoutmultilineicf.h>

const TInt32 KInvalidResId = -1;

const TInt KNotSupportSkin = -1;

const TInt KInvalidImg = -1 ;

const TUint32 KDefaultTextColor = 0x000000;

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

// Constructor

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

//

EXPORT_C CAknFepCtrlBaseWindowExt::CAknFepCtrlBaseWindowExt(CFepUiLayout* aFepUiLayout, 

                                          TInt aControlId)

    :CControlGroup(aFepUiLayout,aControlId),

    iCloseButton(NULL),

    iFirstTimeConstruct(ETrue), 

    iCoeEnv(CCoeEnv::Static())

    {

    }

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

// Constructor

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

//

EXPORT_C void CAknFepCtrlBaseWindowExt::BaseConstructL()

    {

    CControlGroup::ConstructL();

    }

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

// Destructor

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

//

EXPORT_C CAknFepCtrlBaseWindowExt::~CAknFepCtrlBaseWindowExt()

    {

    }

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

// Draw window frame and sub controls

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

//

EXPORT_C void CAknFepCtrlBaseWindowExt::Draw()

    {

    if(Hiden() || !Ready())

        {

        return;

        }

    //Clear();

    DrawOpaqueMaskBackground( Rect() );

    CFbsBitGc* gc= static_cast<CFbsBitGc*> ( BitGc());

    /*

    gc->Activate( MaskBitmapDevice() );

    gc->SetBrushStyle( CGraphicsContext::ENullBrush );

    gc->SetBrushColor( MaskBkCol() );

    gc->SetPenSize( PenSize());

    gc->SetPenColor( PenColor() );

    gc->DrawRect( Rect());

	*/

    // ----- draw bitmaps -----

    gc->Activate( BitmapDevice() ); 

    gc->SetBrushColor( TRgb(KOpaqueColor) );

    gc->SetPenColor( TRgb(KOpaqueColor) );

    gc->DrawRect( Rect());

    if( BackgroundBmp() && BackgroundBmp()->SizeInPixels() != Rect().Size() )    

    	AknIconUtils::SetSize(BackgroundBmp(), Rect().Size(), EAspectRatioNotPreserved);

	DrawBackground();

	CControlGroup::Draw();

	/*

    for(TInt i=0; i< NumOfControls(); i++)        

        {

        CFepUiBaseCtrl* ctrl = At(i);

        if(!ctrl->Hiden())

            {

            ctrl->Draw();        

            }

        }*/

    }

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

// Close window

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

//

EXPORT_C void CAknFepCtrlBaseWindowExt::Close()

    {

    if (DoClose())

        {

        Hide(ETrue);

        }

    }

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

// Enable or disable drag window

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

//

EXPORT_C void CAknFepCtrlBaseWindowExt::SetDragEnable(TBool /*aEnable*/)

    {

    /*if (iMoveButton)

        {

        iMoveButton->EnableDragging(aEnable);

        }*/

    }

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

// Handle close event

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

//

EXPORT_C void CAknFepCtrlBaseWindowExt::HandleControlEvent(TInt aEventType, 

                                             CFepUiBaseCtrl* aCtrl, 

                                             const TDesC& /*aEventData*/)

    {

    if (aEventType == EEventButtonUp)

        {

        if (aCtrl->ControlId() == EPeninutWindowCtrlIdCloseBtn)

            {

            Close();

            }

        }

    }

EXPORT_C TBool CAknFepCtrlBaseWindowExt::DoClose()

    {

    return ETrue;

    }

EXPORT_C CFepUiBaseCtrl* CAknFepCtrlBaseWindowExt::Control(TInt aCtrlId)

    {

    CFepUiBaseCtrl* ctrl = NULL;

    RPointerArray<CFepUiBaseCtrl> todo;

    TInt current = 0;

    TBool notFound = ETrue;

    todo.Append(this);

    while (current < todo.Count() && notFound)

        {

        ctrl = todo[current];

        if(ctrl->ControlId() == aCtrlId)

            {

            notFound = EFalse;     

            }

        else

            {

            if(ctrl->IsKindOfControl(ECtrlControlGroup))

                {

                CControlGroup* temp = static_cast<CControlGroup*>(ctrl);

                for (int i = 0; i < temp->NumOfControls(); i++)

                    {

                    todo.Append(temp->At(i));

                    }

                }

            current++;

            }

        }

    todo.Close();

    return notFound ? NULL : ctrl;

    }    

EXPORT_C void CAknFepCtrlBaseWindowExt::ConstructFromResourceL()

    {    

    if (iResourceId == KInvalidResId)

    	{

        User::Leave(KErrArgument);

    	}

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader, iResourceId);

    TInt supportskin = reader.ReadInt16();

    if (iFirstTimeConstruct&& (supportskin != KNotSupportSkin))

        {

    	UiLayout()->AddControlL(this);

        }

    // Read information of shadow

    const TInt32 shadowResId = reader.ReadInt32(); 

    ReadShadowInfoL( shadowResId );

    // Read information of background 

    const TInt32 backgroundResId = reader.ReadInt32(); 

    ReadBackgroundInfoL( backgroundResId ); 

    // Read resource information to create base window controls

     const TInt count = reader.ReadInt16();

	if( iFirstTimeConstruct )

		{

		for( TInt i = 0; i < count && iFirstTimeConstruct; i++ )

	        {

	        const TInt16 id = reader.ReadInt16();

	        const TInt32 image = reader.ReadInt32();

	        CreateBaseWindowControlsL( id, image );

	        }    	

		}

	else

		{

		CControlGroup::ConstructFromResourceL();

		// ReConstruct ICF when resource changed

        CFepLayoutMultiLineIcf* multiIcf = 

		    static_cast<CFepLayoutMultiLineIcf*>( Control(EPeninputWindowCtrlIdMultiLineICF));

		if( multiIcf )

			{

			TResourceReader reader;

			iCoeEnv->CreateResourceReaderLC( reader, multiIcf->ResourceId() );  

			ReadMultiLineIcfInforL( reader, multiIcf );     

			CleanupStack::PopAndDestroy( 1 );				

			}

		}

    CleanupStack::PopAndDestroy(); // reader

    iFirstTimeConstruct = EFalse;

    }

TBool CAknFepCtrlBaseWindowExt::CreateCustomControlL( TInt16 /*aControlId*/, TInt32 /*aImageId*/ )

	{

	return EFalse;	

	}

void CAknFepCtrlBaseWindowExt::AddCustomControlGroupL(CFepUiBaseCtrl* aCtrl)

	{

	AddControlL(aCtrl);

	}

EXPORT_C void CAknFepCtrlBaseWindowExt::CreateBaseWindowControlsL( TInt16 aControlId, 

                                                                   TInt32 aImageId )

    {

    if (CreateCustomControlL(aControlId, aImageId))

    	{

    	return;	

    	}

    switch ( aControlId )

        {

        case EPeninutWindowCtrlIdCloseBtn:

            {

            CAknFepCtrlCommonButton* closeButton = 

            	CAknFepCtrlCommonButton::NewL(UiLayout(), aControlId, 

            								  KAknsIIDQsnFrFunctionButtonNormal,

        									  KAknsIIDQsnFrFunctionButtonPressed,

        									  KAknsIIDQsnFrFunctionButtonInactive);

            AddCustomControlGroupL( closeButton );

            closeButton->AddEventObserver(this);

            closeButton->SetResourceId( aImageId );

            closeButton->ConstructFromResourceL();

            SetCloseButton(closeButton);

            }

            break;

        case EPeninutWindowCtrlIdInputContextField:

            {

            CFepInputContextField* icf= CFepInputContextField::NewL( TRect(), 

                UiLayout(), aControlId ); 

            AddCustomControlGroupL( icf );

            icf->SetFocus(ETrue);

            icf->AddEventObserver( UiLayout() );

            TResourceReader reader;

            iCoeEnv->CreateResourceReaderLC( reader, aImageId );  

            ReadIcfInfoL( reader, icf);     

            CleanupStack::PopAndDestroy( 1 );

            }

            break;

        case EPeninputWindowCtrlIdMultiLineICF:

            {

            const CFont* icfFont = NULL;

            TAknTextLineLayout textPaneTextLayout;

            textPaneTextLayout = 

            AknLayoutScalable_Avkon::fep_vkb_top_text_pane_t1().LayoutLine();

            icfFont = AknLayoutUtils::FontFromId( textPaneTextLayout.iFont, NULL );    

            CFepLayoutMultiLineIcf* multiLineIcf = NULL;

            if ( icfFont )

                {

                multiLineIcf = CFepLayoutMultiLineIcf::NewL( TRect(), 

                    UiLayout(), aControlId, icfFont->HeightInPixels(),

                    icfFont->FontMaxHeight(),icfFont );    

                AddCustomControlGroupL( multiLineIcf );

                // Add layout as event observer

                multiLineIcf->AddEventObserver( UiLayout() );

                multiLineIcf->SetResourceId( aImageId );

                multiLineIcf->SetFocus(ETrue);

	            TResourceReader reader;

	            iCoeEnv->CreateResourceReaderLC( reader, aImageId );  

	            ReadMultiLineIcfInforL( reader,multiLineIcf );     

	            CleanupStack::PopAndDestroy( 1 );

                }

            }

            break;

        case EPeninutWindowCtrlIdOptionBtn:

            {

            CAknFepCtrlEventButton* touchInputOptionButton = CAknFepCtrlEventButton::NewL( 

        									  UiLayout(),

        									  aControlId, EPeninputLayoutEventOption, 0, 

        									  KAknsIIDQsnFrFunctionButtonNormal,

        									  KAknsIIDQsnFrFunctionButtonPressed,

        									  KAknsIIDQsnFrFunctionButtonInactive );

            AddCustomControlGroupL( touchInputOptionButton );

            touchInputOptionButton->AddEventObserver( UiLayout() );

            touchInputOptionButton->SetResourceId( aImageId ); 

            touchInputOptionButton->ConstructFromResourceL();  

            }

            break;

        case EPeninutWindowCtrlIdBackspaceBtn:

            {

            CAknFepCtrlRepeatButton* backspaceButton = CAknFepCtrlRepeatButton::NewL( 

        									  UiLayout(), aControlId, EPeninputLayoutEventBack, EKeyBackspace, 

        									  KAknsIIDQsnFrFunctionButtonNormal,

        									  KAknsIIDQsnFrFunctionButtonPressed,

        									  KAknsIIDQsnFrFunctionButtonInactive );

            AddCustomControlGroupL( backspaceButton );

            backspaceButton->AddEventObserver( UiLayout() );

            backspaceButton->SetResourceId( aImageId );

            backspaceButton->ConstructFromResourceL();  

            }

            break;

        case EPeninutWindowCtrlIdSpaceBtn:

            {

            CAknFepCtrlEventButton* spaceButton = CAknFepCtrlEventButton::NewL( 

        									  UiLayout(), aControlId, EPeninputLayoutEventSpace, EKeySpace,

        									  KAknsIIDQsnFrFunctionButtonNormal,

        									  KAknsIIDQsnFrFunctionButtonPressed,

        									  KAknsIIDQsnFrFunctionButtonInactive );

            AddCustomControlGroupL( spaceButton );

            spaceButton->AddEventObserver( UiLayout() );

            spaceButton->SetResourceId( aImageId );

            spaceButton->ConstructFromResourceL();  

            }

            break;

        case EPeninutWindowCtrlIdEnterBtn:

            {

            CAknFepCtrlEventButton* enterButton = CAknFepCtrlEventButton::NewL( 

        									  UiLayout(), aControlId, EPeninputLayoutEventEnter, EKeyEnter, 

        									  KAknsIIDQsnFrFunctionButtonNormal,

        									  KAknsIIDQsnFrFunctionButtonPressed,

        									  KAknsIIDQsnFrFunctionButtonInactive  );

            AddCustomControlGroupL( enterButton );

            enterButton->AddEventObserver(UiLayout());

            enterButton->SetResourceId( aImageId );

            enterButton->ConstructFromResourceL();  

            }

            break;

        case EPeninutWindowCtrlIdSwitcherPopupWindow:

            {

            CPeninputLayoutInputmodelChoice* modeSwitchChoice = 

                                                CPeninputLayoutInputmodelChoice::NewL( UiLayout(),

                 EPeninutWindowCtrlIdSwitcherPopupWindow, 

                 (TPluginInputMode)(UiLayout()->PenInputType()));

                 modeSwitchChoice->SetListSkinID( KAknsIIDQsnFrList, KAknsIIDQsnFrPopupSub );

            AddCustomControlGroupL( modeSwitchChoice );

            modeSwitchChoice->AddEventObserver( UiLayout() );   

            }   

            break;

        default:

            {

            }

            break;

        }

    }

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

// CAknFepCtrlBaseWindowExt::ReadShadowInfoL

// (other items were commented in a header)

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

// 

void CAknFepCtrlBaseWindowExt::ReadShadowInfoL( TInt aResId )

    {

    TResourceReader resReader;

    iCoeEnv->CreateResourceReaderLC( resReader, aResId );

    TPtrC bmpFileName = resReader.ReadTPtrC();

    TInt32 imgMajorSkinId = resReader.ReadInt32();

    TAknsItemID id;

    TInt skinitemid;

    for ( TInt i = 0; i < KShadowBmpBr + 1; i++ )

    	{

        const TInt16 bmpId = resReader.ReadInt16();

        const TInt16 bmpMskId = resReader.ReadInt16();

        skinitemid = resReader.ReadInt16();

        id.Set(TInt(imgMajorSkinId), skinitemid);

        if (bmpId != KInvalidImg)

        	{

            CFbsBitmap* shadowImg = NULL;

            CFbsBitmap* shadowMaskImg = NULL;

            if (bmpMskId != KInvalidImg)

                {

                AknsUtils::CreateIconL(skininstance, 

                                       id,

                                       shadowImg,

                                       shadowMaskImg,

                                       bmpFileName,

                                       bmpId,

                                       bmpMskId);

                }

            else

                {

                AknsUtils::CreateIconL(skininstance,

                                       id,

                                       shadowImg,

                                       bmpFileName,

                                       bmpId);

                }

            UiLayout()->SetShadowBmp(shadowImg, shadowMaskImg, TShadowBitmapIndex(i));

        	}

    	}

    CleanupStack::PopAndDestroy( 1 );

    }

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

// CAknFepCtrlBaseWindowExt::ReadBackgroundInfoL

// (other items were commented in a header)

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

// 

void CAknFepCtrlBaseWindowExt::ReadBackgroundInfoL( TInt aResId )

    {

    if( aResId == 0 )

    	return;

    if( BackgroundBmp() )

    	{

    	CFbsBitmap* bkBmp = BackgroundBmp();

    	delete bkBmp;	

    	SetBackgroundBmp( NULL );

    	}

    if( BkMaskBmp() )

    	{

    	CFbsBitmap* bkMaskBmp = BkMaskBmp();

    	delete bkMaskBmp;

		SetBackgroundMaskBmp( NULL );

    	}    

    TResourceReader resReader;

    iCoeEnv->CreateResourceReaderLC( resReader, aResId );

    TPtrC bmpFileName = resReader.ReadTPtrC();

    TInt32 imgMajorSkinId = resReader.ReadInt32();

    TAknsItemID id;

    TInt skinitemid;

    const TInt16 bmpId = resReader.ReadInt16();

    const TInt16 bmpMskId = resReader.ReadInt16();

    skinitemid = resReader.ReadInt16();   

    id.Set(TInt(imgMajorSkinId), skinitemid);

    if (bmpId != KInvalidImg)

    	{

    	CFbsBitmap* backgroundImg = NULL;

    	CFbsBitmap* backgroundMaskImg = NULL;

        if (bmpMskId != KInvalidImg)

            {

            AknsUtils::CreateIconL(skininstance, 

                                   id,

                                   backgroundImg,

                                   backgroundMaskImg,

                                   bmpFileName,

                                   bmpId,

                                   bmpMskId);

            }

        else

            {

            AknsUtils::CreateIconL(skininstance,

                                   id,

                                   backgroundImg,

                                   bmpFileName,