/*

* 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: 

*

*/

#include <barsread.h>

#include <eiklabel.h>

#include <eikimage.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <AknLayoutDef.h>

#include <AknLayout.lag>

#include <avkon.mbg>

#include "AknPanic.h"

#include "aknPopupHeadingPane.h"

#include "akntextcontrol.h"

#include "AknBitmapAnimation.h"

#include "aknconsts.h"

#include <AknsDrawUtils.h>

#include <StringLoader.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknbutton.h>

#include "AknHeadingPaneTouchObserver.h"

// ================= Extension class ========================

NONSHARABLE_CLASS(CAknPopupHeadingPaneExtension) : public CBase

    {

    public:

        CAknPopupHeadingPaneExtension();

        ~CAknPopupHeadingPaneExtension();

    public: // data 

		TAknsItemID iFrameId;

		TAknsItemID iFrameCenterId;

		MAknHeadingPaneTouchObserver* iTouchObserver;

    };

CAknPopupHeadingPaneExtension::CAknPopupHeadingPaneExtension()

    {

    }

CAknPopupHeadingPaneExtension::~CAknPopupHeadingPaneExtension()

    {

    }

class CAknPopupHeadingAttributes: public CBase, public MCoeControlObserver

    {

    public:

        void SetEnableCloseButton();

        TBool IsEnableCloseButton() const;

        static TInt CallBackByOneShot(TAny* aThisPtr);

    public: // from MCoeControlObserver

        virtual void HandleControlEventL(CCoeControl *aControl, TCoeEvent aEventType);

    public:

        CAknPopupHeadingPane::THeadingPaneLayout iLayout;

        CCoeBrushAndPenContext* iBrushAndPenContext;

        CAknTextControl*    iPage;

        CAknButton*         iCloseButton;

        CAsyncCallBack*     iAsyncOneShot;

        TInt iCurrentPage;

        TInt iMaxPage;

        TBool iEnableCloseButton;

        ~CAknPopupHeadingAttributes()

            {

            if (iAsyncOneShot)

                {

                iAsyncOneShot->Cancel();

                delete iAsyncOneShot;

                iAsyncOneShot = NULL;

                }

            delete iBrushAndPenContext;

            delete iPage;

            delete iCloseButton;

            }

    };

void CAknPopupHeadingAttributes::SetEnableCloseButton()

    {

    CAknEnv* env = CAknEnv::Static();

    TBool japaneseUi = (env && env->IsFeatureLanguage(KFeatureIdJapanese))?

                        ETrue : EFalse;

    if (AknLayoutUtils::PenEnabled() && japaneseUi)

        {

        iEnableCloseButton = ETrue;

        }

    else

        {

        iEnableCloseButton = EFalse;

        }

    }

TBool CAknPopupHeadingAttributes::IsEnableCloseButton() const

    {

    return iEnableCloseButton;

    }

/**

 * Call back function:

 */

TInt CAknPopupHeadingAttributes::CallBackByOneShot(TAny* /*aThisPtr*/)

    {

    // Simulate RSK down key event

    TKeyEvent key;

    key.iCode = EKeyCBA2; // = EKeyDevice1

    // Special flag that implies the simulated key event is sent by this  call back function

    key.iModifiers = EModifierKeyboardExtend;

    key.iScanCode = EStdKeyDevice1;

    key.iRepeats = 0;

    TRAP_IGNORE( CCoeEnv::Static()->SimulateKeyEventL(key, EEventKey) );

    return KErrNone;

    }

void CAknPopupHeadingAttributes::HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType)

    {

    if (aControl == iCloseButton)

        {

        // Handle the event sent by Close button control

        switch (aEventType)

            {

            case MCoeControlObserver::EEventRequestExit:

                {

                if (!iAsyncOneShot)

                	{

                    iAsyncOneShot = new (ELeave) CAsyncCallBack(EPriorityHigh);

                    // setting call back

                    TCallBack callback(CallBackByOneShot, this);

                    iAsyncOneShot->Set(callback);

                    iAsyncOneShot->CallBack();

                	}

                }

                break;

            default:

                break;

            }

        }

    }

EXPORT_C CAknPopupHeadingPane::~CAknPopupHeadingPane()

    {

    AknsUtils::DeregisterControlPosition(this);

    delete iExtension;

    delete iPrompt;

    delete iHeaderImage;

    delete iAnimation;

    delete iAttributes;

    }

EXPORT_C void CAknPopupHeadingPane::ConstructL(TPtrC aText)

    {

    if ( ! iAttributes )

        {

        iAttributes = new ( ELeave ) CAknPopupHeadingAttributes;

        iAttributes->iBrushAndPenContext=CCoeBrushAndPenContext::NewL();

        iAttributes->iBrushAndPenContext->SetBrushStyle(CGraphicsContext::ENullBrush);

        SetControlContext(iAttributes->iBrushAndPenContext);        

        }

    if (!iPrompt)

        {

        iPrompt = CAknTextControl::NewL();

        iPrompt->SetContainerWindowL(*this);

        }

    if (!iAttributes->iPage)

        {

        iAttributes->iPage = CAknTextControl::NewL();

        iAttributes->iPage->SetContainerWindowL(*this);

        iAttributes->iPage->MakeVisible(EFalse);

        }

    if (!iAttributes->iCloseButton)

        {

        TResourceReader reader;

        CEikonEnv::Static()->CreateResourceReaderLC( reader, R_AVKON_SCT_HEADING_CLOSE_BUTTON );

        iAttributes->iCloseButton = CAknButton::NewL(reader);

        iAttributes->iCloseButton->SetContainerWindowL(*this);

        iAttributes->iCloseButton->SetObserver(iAttributes);

        iAttributes->iCloseButton->SetRequestExit( ETrue );

        iAttributes->iCloseButton->MakeVisible(EFalse);

        CleanupStack::PopAndDestroy(); //reader buffer

        iAttributes->SetEnableCloseButton();

        }

    if ( !iExtension )

        {

        iExtension = new (ELeave) CAknPopupHeadingPaneExtension;    

        }

    iExtension->iFrameId = KAknsIIDQsnFrPopupHeading;

    iExtension->iFrameCenterId = KAknsIIDQsnFrPopupHeadingCenter;

    SetTextL(aText);

    SetNonFocusing();

    iAttributes->iLayout = EQueryHeadingPane; // QueryHeadingPane by default

    }

EXPORT_C void CAknPopupHeadingPane::ConstructFromResourceL(TResourceReader &aReader)

    {

    if ( ! iAttributes )

        {

        iAttributes = new ( ELeave ) CAknPopupHeadingAttributes;

        iAttributes->iBrushAndPenContext=CCoeBrushAndPenContext::NewL();

        iAttributes->iBrushAndPenContext->SetBrushStyle(CGraphicsContext::ENullBrush);

        SetControlContext(iAttributes->iBrushAndPenContext);        

        }

    if (!iPrompt)

        {

        iPrompt = CAknTextControl::NewL();

        iPrompt->SetContainerWindowL(*this);

        }

    if (!iAttributes->iPage)

        {

        iAttributes->iPage = CAknTextControl::NewL();

        iAttributes->iPage->SetContainerWindowL(*this);

        iAttributes->iPage->MakeVisible(EFalse);

        }

    if (!iAttributes->iCloseButton)

        {

        TResourceReader reader;

        CEikonEnv::Static()->CreateResourceReaderLC( reader, R_AVKON_SCT_HEADING_CLOSE_BUTTON );

        iAttributes->iCloseButton = CAknButton::NewL(reader);

        iAttributes->iCloseButton->SetContainerWindowL(*this);

        iAttributes->iCloseButton->MakeVisible(EFalse);

        iAttributes->iCloseButton->SetObserver(iAttributes);

        iAttributes->iCloseButton->SetRequestExit( ETrue );

        CleanupStack::PopAndDestroy(); //reader buffer

        iAttributes->SetEnableCloseButton();

        }

    SetTextL(aReader.ReadTPtrC());

    HBufC* bitmapFile = aReader.ReadHBufCL();        // bmp filename

    TInt bitmapId = aReader.ReadInt16();        // bmp id

    TInt maskId = aReader.ReadInt16();        // bmp mask id

    if (bitmapFile != NULL)

        {

        CleanupStack::PushL(bitmapFile);                        

        iHeaderImage = new (ELeave) CEikImage;

        iHeaderImage->SetContainerWindowL(*this);

        iHeaderImage->SetNonFocusing();

        iHeaderImage->SetAlignment(EHCenterVCenter);

        if (bitmapId != -1)

            {

            CFbsBitmap* bitmap;                

            if (maskId != -1)

                {

                CFbsBitmap* mask;

                AknIconUtils::CreateIconLC(bitmap, mask, *bitmapFile, bitmapId, maskId);

                TAknLayoutRect layout;

                layout.LayoutRect(Rect(), AknLayoutScalable_Avkon::heading_pane_g2()); // Icon

                User::LeaveIfError(AknIconUtils::SetSize(bitmap, layout.Rect().Size()));

                iHeaderImage->SetPicture(bitmap, mask);

                iHeaderImage->SetPictureOwnedExternally(EFalse);

                CleanupStack::Pop(2);    //bitmap, mask

                }

            else

                {

                bitmap = AknIconUtils::CreateIconL(*bitmapFile, bitmapId);

                CleanupStack::PushL(bitmap);

                TAknLayoutRect layout;

                layout.LayoutRect(Rect(), AknLayoutScalable_Avkon::heading_pane_g2()); // Icon

                User::LeaveIfError(AknIconUtils::SetSize(bitmap, layout.Rect().Size()));

                iHeaderImage->SetPicture(bitmap);

                iHeaderImage->SetPictureOwnedExternally(EFalse);

                CleanupStack::Pop();    //bitmap

                }

            }

        CleanupStack::PopAndDestroy();        // bitmapFile

        }    

    TInt animationId = aReader.ReadUint32();

    if (animationId != 0)

        {

        if (!iAnimation)

            {// no animation previously set

            SetHeaderAnimationL(animationId);

            }

        }

    iHeadingLayoutRef = aReader.ReadUint32();

	// extension needed for heading skinning    

    if ( !iExtension )

        {

        iExtension = new (ELeave) CAknPopupHeadingPaneExtension;    

        }

	iExtension->iFrameId = KAknsIIDQsnFrPopupHeading;  

	iExtension->iFrameCenterId = KAknsIIDQsnFrPopupHeadingCenter;        

    SetNonFocusing();

    }

EXPORT_C void CAknPopupHeadingPane::SetTextL(TPtrC aText)

    {

    __ASSERT_DEBUG(iPrompt,Panic(EAknPanicNullPointer));

    iPrompt->SetTextL(aText);

    __ASSERT_DEBUG(iAttributes->iPage,Panic(EAknPanicNullPointer));

    // Reset page number when be more than one page

    if (iAttributes->iMaxPage > 1)

        {

        HBufC* page = PageTextL();

        CleanupStack::PushL(page);

        iAttributes->iPage->SetTextL(*page);

        CleanupStack::PopAndDestroy(); // page

        }

    DoSetPromptL();

    if (!Rect().IsEmpty())

        {

        SizeChanged();

        }

    }

EXPORT_C void CAknPopupHeadingPane::SetHeaderImageOwnedL(CEikImage *aImage)

    { 

    delete iHeaderImage;

    iHeaderImage = aImage;

    if ( iHeaderImage )

        {

        iHeaderImage->SetContainerWindowL(*this);

        iHeaderImage->SetNonFocusing();

        iHeaderImage->SetAlignment(EHCenterVCenter);

        }

    DoSetPromptL();

    if (!Rect().IsEmpty())

        {

        SizeChanged();

        }

    }

EXPORT_C void CAknPopupHeadingPane::SetHeaderImageL(CEikImage *aImage)

    {

    if ( !iHeaderImage )

        {

        iHeaderImage = new (ELeave) CEikImage;

        iHeaderImage->SetContainerWindowL(*this);

        iHeaderImage->SetNonFocusing();

        iHeaderImage->SetAlignment(EHCenterVCenter);

        }

    CFbsBitmap* bitmap = new  (ELeave) CFbsBitmap();

    CleanupStack::PushL(bitmap);                

    CFbsBitmap* mask = new (ELeave) CFbsBitmap();                 

    bitmap->Duplicate(aImage->Bitmap()->Handle());

    mask->Duplicate(aImage->Mask()->Handle());

    iHeaderImage->SetPicture(bitmap, mask); 

    iHeaderImage->SetPictureOwnedExternally(EFalse);

    CleanupStack::Pop(); // bitmap

    DoSetPromptL();

    if (!Rect().IsEmpty())

        {

        SizeChanged();

        }

    }    

EXPORT_C void CAknPopupHeadingPane::SetHeaderAnimationL( TInt aResourceId )

    {

    if (aResourceId <= 0)

        {

        return;

        }

    // If header image set, delete it!

    delete iHeaderImage;

    iHeaderImage = NULL;

    delete iAnimation;

    iAnimation = NULL;

    iAnimation = CAknBitmapAnimation::NewL();

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC(reader,aResourceId);

    iAnimation->ConstructFromResourceL(reader);

    CleanupStack::PopAndDestroy(); //reader buffer

    iAnimation->SetContainerWindowL(*this);

    iAnimation->SetNonFocusing();

    DoSetPromptL();

    if (!Rect().IsEmpty())

        {

        SizeChanged();

        }

    }

EXPORT_C void CAknPopupHeadingPane::SetLayout( THeadingPaneLayout aLayout )

    {

    iAttributes->iLayout = aLayout;

    }

void CAknPopupHeadingPane::DoSetPromptL()

    {

    __ASSERT_DEBUG(iPrompt,Panic(EAknPanicNullPointer));

    CArrayFixFlat<TInt>* lineWidths = new(ELeave)CArrayFixFlat<TInt>(1);

    CleanupStack::PushL(lineWidths);

    TAknTextComponentLayout textLayout = AknLayoutScalable_Avkon::heading_pane_t1(0);

    if (iHeaderImage || iAnimation)

        {

        textLayout = AknLayoutScalable_Avkon::heading_pane_t1(2);

        }

    if (iAttributes->iPage->IsVisible())

        {

        TInt varietyIndex = (AknLayoutUtils::PenEnabled())? 3 : 1;

        textLayout = AknLayoutScalable_Avkon::heading_pane_t1(varietyIndex);

        }

    TRect parentRect;

    TAknLayoutRect popupRect;

    if(!AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, parentRect))

        {

        parentRect = iAvkonAppUi->ClientRect();

        }

    popupRect.LayoutRect(parentRect, AknLayoutScalable_Avkon::popup_window_general(1));

    TAknLayoutRect headingRect;

    TAknWindowComponentLayout headingPaneLayout;

    if (iAttributes->iLayout == EMessageQueryHeadingPane)

        {

        headingPaneLayout = AknLayoutScalable_Avkon::heading_pane_cp5();        

        }

    else

        {

        headingPaneLayout = AknLayoutScalable_Avkon::heading_pane(0);

        }

    headingRect.LayoutRect(TRect(TPoint(0,0),popupRect.Rect().Size()), headingPaneLayout);

    parentRect = headingRect.Rect();

    TAknLayoutText textRect;

    textRect.LayoutText(parentRect, textLayout);

    lineWidths->AppendL(textRect.TextRect().Width());           

    const CFont* promptFont = AknLayoutUtils::FontFromId( textLayout.Font() );

    iPrompt->ParseTextL(promptFont, lineWidths);      

    CleanupStack::PopAndDestroy(); //lineWidths

    lineWidths = new(ELeave)CArrayFixFlat<TInt>(1);

    CleanupStack::PushL(lineWidths);

    TInt varietyIndex = (iAttributes->IsEnableCloseButton())? 1 : 0;

    textLayout = AknLayoutScalable_Avkon::heading_pane_t2(varietyIndex);

    textRect.LayoutText(parentRect, textLayout);

    lineWidths->AppendL(textRect.TextRect().Width());

    const CFont* fontUsed = AknLayoutUtils::FontFromId( textLayout.Font() );

    iAttributes->iPage->ParseTextL(fontUsed, lineWidths);

    CleanupStack::PopAndDestroy(); //lineWidths

    }

EXPORT_C void CAknPopupHeadingPane::SizeChanged()

    {

    if (iAttributes->iLayout == EQueryHeadingPane)

        {

        LayoutQueryHeadingPane();

        }

    else if (iAttributes->iLayout == EColourSelectionGridHeadingPane)

        {

        LayoutColourSelectionGridHeadingPane();

        }

    else if (iAttributes->iLayout == EMessageQueryHeadingPane)

        {

        LayoutMessageQueryHeadingPane();

        }

    else

        {

        LayoutListHeadingPane();

        }

    if (iHeaderImage)

        {

        TAknLayoutRect layout;

        layout.LayoutRect(Rect(), AknLayoutScalable_Avkon::heading_pane_g2());

        AknIconUtils::SetSize(CONST_CAST(CFbsBitmap*, iHeaderImage->Bitmap()), layout.Rect().Size());    	

        }

    AknsUtils::RegisterControlPosition(this);

    }

void CAknPopupHeadingPane::LayoutQueryHeadingPane()

    {

    TRect parentRect = Rect();

    TAknLayoutRect headingLayoutRect;

    headingLayoutRect.LayoutRect(parentRect, AknLayoutScalable_Avkon::heading_pane(0));

    TRect headingrect(headingLayoutRect.Rect());