/*

* Copyright (c) 2009 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 <coemain.h>

#include <AknsItemID.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <peninputlayout.h>

#include <skinlayout.cdl.h>

#include <AknsDrawUtils.h>

#include "peninputselectionlist.h"

// constant definition

const TInt KInvalidResId = -1;

const TInt KInvalidBmp = -1;

const TInt KInvalidItemIndex = -1;

EXPORT_C CPenInputSelectionList* CPenInputSelectionList::NewL(CFepUiLayout* aUiLayout,

                                                              TInt aControlId,

                                                              TPoint aTopLeftPoint,

                                                              TSize aItemSize,

                                                              TInt aItemHorizontalMargin)

    {

    CPenInputSelectionList* self = new (ELeave) CPenInputSelectionList(aUiLayout,

                                                                       aControlId,

                                                                       aTopLeftPoint,

                                                                       aItemSize,

                                                                       aItemHorizontalMargin);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CPenInputSelectionList::~CPenInputSelectionList()

    {

    iItemList.Reset();

    iItemList.Close();

    iBmpList.ResetAndDestroy();

    iBmpList.Close();

    }

void CPenInputSelectionList::RecalculateCtrlRect()

    {

    if (iItemList.Count() == 0)

        {

        SetRect(TRect(0, 0, 0, 0));

        }

    else

        {

        SetRect(TRect(iItemList[0].iRect.iTl,

                iItemList[iItemList.Count() - 1].iRect.iBr));

        }

    }

EXPORT_C void CPenInputSelectionList::SizeChanged(TPoint aTopLeftPoint,

                                                  TSize aItemSize,

                                                  TInt aItemHorizontalMargin)

    {

    iTopLeftPoint = aTopLeftPoint;

    iItemSize = aItemSize;

    iItemHorizontalMargin = aItemHorizontalMargin;

    for (TInt i = 0; i < iItemList.Count(); i++)

        {

        iItemList[i].iRect = TRect(TPoint(aTopLeftPoint.iX,

                                          aTopLeftPoint.iY + 

                                          i * (aItemHorizontalMargin + iItemSize.iHeight)),

                                   aItemSize);

        }

    RecalculateCtrlRect();

    }

EXPORT_C void CPenInputSelectionList::SetItemsL(const RPointerArray<HBufC>& aItemList)

    {

    Hide(ETrue);

    iItemList.Reset();

    for (TInt i = 0; i < aItemList.Count(); i++)

        {

        SItem item(TRect(TPoint(iTopLeftPoint.iX,

                               iTopLeftPoint.iY + i * (iItemHorizontalMargin + iItemSize.iHeight)),

                         iItemSize),

                   *aItemList[i]);

        iItemList.AppendL(item);

        }

    RecalculateCtrlRect();

    }

EXPORT_C void CPenInputSelectionList::AddItemL(const TDesC& aItem)

    {

    SItem item(TRect(TPoint(iTopLeftPoint.iX,

                            iTopLeftPoint.iY + iItemList.Count() * (iItemHorizontalMargin + 

                            iItemSize.iHeight)),iItemSize), aItem);

    iItemList.AppendL(item);

    RecalculateCtrlRect();

    }

EXPORT_C void  CPenInputSelectionList::RemoveItem(TInt aItemIndex)

    {

    if (aItemIndex < 0 || aItemIndex >= iItemList.Count())

        {

        return;

        }

    iItemList.Remove(aItemIndex);

    for (TInt i = aItemIndex; i < iItemList.Count(); i++)

        {

        iItemList[i].iRect.Move(-iItemHorizontalMargin, 0);

        }

    RecalculateCtrlRect();

    }

EXPORT_C void CPenInputSelectionList::RemoveAllItems()

    {

    iItemList.Reset();

    RecalculateCtrlRect();

    }

EXPORT_C void CPenInputSelectionList::ConstructFromResourceL()

    {

    if (iResourceId == KInvalidResId)

    	{

    	User::Leave(KErrArgument);

    	}

    iBmpList.ResetAndDestroy();

    TResourceReader reader;

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

    TPtrC bmpFileName = reader.ReadTPtrC();

    TInt imgMajorSkinId = reader.ReadInt32();

    TAknsItemID id;

    for (TInt i = 0; i < EBmpLastType + 1; i+=2)

        {

        TInt bmpid = reader.ReadInt16();

        TInt maskid = reader.ReadInt16();

        TInt minorskinid = reader.ReadInt16();

        id.Set(imgMajorSkinId, minorskinid);

        CFbsBitmap* bmp = NULL;

        CFbsBitmap* maskbmp = NULL;

        if (bmpid != KInvalidBmp)

            {

            if (maskid != KInvalidBmp)

                {

        		AknsUtils::CreateIconL(AknsUtils::SkinInstance(),

        		                       id,

        		                       bmp,

        		                       maskbmp,

        		                       bmpFileName,

        		                       bmpid,

        		                       maskid);

                AknIconUtils::SetSize(maskbmp, iItemSize, EAspectRatioNotPreserved);

                }

            else

                {

        	    AknsUtils::CreateIconL(AknsUtils::SkinInstance(),

        	                           id,

        	                           bmp,

        	                           bmpFileName,

        	                           bmpid);

                }

            AknIconUtils::SetSize(bmp, iItemSize, EAspectRatioNotPreserved);

            }

        iBmpList.AppendL(bmp);

        iBmpList.AppendL(maskbmp);

        }

    CleanupStack::PopAndDestroy(); // reader

    }

EXPORT_C void CPenInputSelectionList::SetTextProperty(const CFont* aFont,

                                                      TRgb aFontColor)

    {

    iFont = aFont;

    iFontColor = aFontColor;

    iBaselineOffset = iItemSize.iHeight/2 + aFont->AscentInPixels()/2;

    }

TInt CPenInputSelectionList::HitTest(const TPoint& aPoint)

    {

    if (!Rect().Contains(aPoint))

        {

        return KErrGeneral;

        }

    for (TInt i = 0; i < iItemList.Count(); i++)

        {

        if (iItemList[i].iRect.Contains(aPoint))

            {

            return i;

            }

        }

    return KErrNotFound;    

    }

EXPORT_C CFepUiBaseCtrl* CPenInputSelectionList::HandlePointerDownEventL(const TPoint& aPoint)

    {

    CFepUiBaseCtrl::HandlePointerDownEventL(aPoint);

    TInt index = HitTest(aPoint);

    if (index >= 0)

        {

        if (index != iFocusItemIndex)

            {

            TInt prev = iFocusItemIndex;

            iFocusItemIndex = index;

            if (prev != KInvalidItemIndex)

                {

                DrawItem(prev);

                }

            DrawItem(iFocusItemIndex);

            }

        }

    else if (index == KErrGeneral)

        {

        SetPointerDown(EFalse);

        CloseWindow();

        }

    return this;    

    }

EXPORT_C CFepUiBaseCtrl* CPenInputSelectionList::HandlePointerUpEventL(const TPoint& aPoint)

    {

    CFepUiBaseCtrl::HandlePointerUpEventL(aPoint);

    TInt index = HitTest(aPoint);

    if (index >= 0)

        {

        CloseWindow();

        if (iFocusItemIndex != KInvalidItemIndex)

            {

            TPtrC ptr;

            ptr.Set(reinterpret_cast<TText*>(&iFocusItemIndex), sizeof(TInt)/sizeof(TText));

            ReportEvent(iEventId, ptr);

            }

        }

    iFocusItemIndex = KInvalidItemIndex;

    return this;    

    }

EXPORT_C CFepUiBaseCtrl* CPenInputSelectionList::HandlePointerMoveEventL(const TPoint& aPoint)

    {

    CFepUiBaseCtrl::HandlePointerMoveEventL(aPoint);

    if (PointerDown())

        {

        TInt index = HitTest(aPoint);

        if (index != iFocusItemIndex && index != KInvalidItemIndex)

            {

            TInt prev = iFocusItemIndex;

            iFocusItemIndex = index;

            if( prev != -1 )

                {

                DrawItem(prev);

                }

            DrawItem(iFocusItemIndex);

            }

        }

    return this;

    }

EXPORT_C void CPenInputSelectionList::Display()

    {

    //Hide(EFalse);

    BringToTop();

    Draw();

    }

EXPORT_C void CPenInputSelectionList::CloseWindow()

    {

    Hide(ETrue);

    RemoveAllItems();

    }

CPenInputSelectionList::CPenInputSelectionList(CFepUiLayout* aUiLayout,

                                               TInt aControlId,

                                               TPoint aTopLeftPoint,

                                               TSize aItemSize,

                                               TInt aItemHorizontalMargin)

    :CFepUiBaseCtrl(TRect(0, 0, 0, 0), aUiLayout, aControlId),

     iTopLeftPoint(aTopLeftPoint),

     iItemSize(aItemSize),

     iItemHorizontalMargin(aItemHorizontalMargin),

     iFocusItemIndex(KInvalidItemIndex),

     iFrId(KAknsIIDQsnFrPopupSub),

     iCenterFrId(KAknsIIDQsnFrPopupCenterSubmenu)

    {

    SetControlType(EUserCtrlBase | ECtrlBaseCtrl);

    }

void CPenInputSelectionList::ConstructL()

    {

    BaseConstructL();

    Hide(ETrue);

    }

void CPenInputSelectionList::Draw()

    {

	if(!AbleToDraw())

        return;

    for (TInt i = 0; i < iItemList.Count(); i++)

        {

        DrawItem(i);

        }

    UiLayout()->UpdateArea(this, this->Rect(), EFalse);

    }

void CPenInputSelectionList::DrawItem(TInt aItemIndex)

    {

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

    //mask bitmaps

    gc->Activate( MaskBitmapDevice() );

    gc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    gc->SetBrushColor(TRgb(KOpaqueColor));//Non transparent at all

    gc->SetPenStyle(CGraphicsContext::ESolidPen );

    gc->SetPenSize(PenSize());

    gc->SetPenColor(TRgb(KOpaqueColor) );

    gc->DrawRect(iItemList[aItemIndex].iRect);

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

    gc->Activate(BitmapDevice());   

	// draw frame

	MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRect outerRect;

    TRect innerRect;

    CalculateFrameRects( iItemList[aItemIndex].iRect, outerRect, innerRect);

    AknsDrawUtils::DrawFrame(

	    skin, *gc, 

	    outerRect, innerRect, 

	    iFrId, iCenterFrId); 

    // draw text

    if (iTextLineSet)

        {

        TAknLayoutText textLayout;

        textLayout.LayoutText(iItemList[aItemIndex].iRect, 

                              iTextLine);

        textLayout.DrawText(*gc, iItemList[aItemIndex].iText);

        }

    else if (iFont)

        {

        gc->UseFont(iFont);

        gc->SetBrushStyle(CGraphicsContext::ENullBrush);

        gc->SetBrushColor(KRgbBlack);

        gc->SetPenColor(iFontColor);

        gc->SetPenStyle(CGraphicsContext::ESolidPen);

        gc->SetPenSize(PenSize());

        gc->DrawText(iItemList[aItemIndex].iText,

                     iItemList[aItemIndex].iRect,

                     iBaselineOffset,

                     CGraphicsContext::ECenter);

        gc->DiscardFont();

        }    

    }

void CPenInputSelectionList::CalculateFrameRects( const TRect aRect,

												  TRect& aOuterRect, 

												  TRect& aInnerRect ) const

    {

    TRect windowRect = aRect;

    TAknLayoutRect topLeft;

    topLeft.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_2());

    TAknLayoutRect bottomRight;

    bottomRight.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_5());

    aOuterRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);

    aInnerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);

    }

// End Of File