/*

* Copyright (c) 2008-2008 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:  Implementation for button base and dragbar

*

*/

#include <coemain.h>

#include <barsread.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <peninputlayout.h>

#include <AknBidiTextUtils.h>

#include <peninputcommonbutton.h>

#include <StringLoader.h>

#include "peninputscrollablelist.h"

const TInt KCtrlIdPageUp = 1;

const TInt KCtrlIdPageDown = 2;

const TInt KInvalidResId = -1;

const TInt KInvalidBmp = -1;

const TInt KDisplayTextLen = KMaxItemTextLength + KAknBidiExtraSpacePerLine;

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

                                                                  TInt aControlId,

                                                                  TSize aItemSize,

                                                                  TInt aHorizontalMargin,

                                                                  TInt aVerticalMargin,

                                                                  TSize aNaviSize,

                                                                  TSize aNaviInnerSize)

    {

    CFepLayoutScrollableList* self = NewLC(aUiLayout, 

                                           aControlId,

                                           aItemSize,

                                           aHorizontalMargin,

                                           aVerticalMargin,

                                           aNaviSize,

                                           aNaviInnerSize);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CFepLayoutScrollableList* CFepLayoutScrollableList::NewLC(CFepUiLayout* aUiLayout,

                                                                   TInt aControlId,

                                                                   TSize aItemSize,

                                                                   TInt aHorizontalMargin,

                                                                   TInt aVerticalMargin,

                                                                   TSize aNaviSize,

                                                                   TSize aNaviInnerSize)

    {

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

                                                                          aControlId,

                                                                          aItemSize,

                                                                          aHorizontalMargin,

                                                                          aVerticalMargin,

                                                                          aNaviSize,

                                                                          aNaviInnerSize);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

EXPORT_C CFepLayoutScrollableList::~CFepLayoutScrollableList()

    {

    //iBmpList.ResetAndDestroy();

    //iBmpList.Close();

    //delete iPageInfoFormat;

    delete iPageInfo;

    iItemRects.Close();

    delete iSeperationBmp;

    delete iSeperationMaskBmp;

    }

EXPORT_C void CFepLayoutScrollableList::ConstructFromResourceL()

    {

    if (iResourceId == KInvalidResId)

        {

        User::Leave(KErrArgument);

        }

	//delete the old bmp res

	delete iSeperationBmp;

	delete iSeperationMaskBmp;

	iSeperationBmp = NULL;

	iSeperationMaskBmp = NULL;

    TResourceReader reader;

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

    TPtrC bmpFileName = reader.ReadTPtrC();

    TInt imgMajorSkinId = reader.ReadInt32();

    TInt32 pageUpId = reader.ReadInt32();

    TInt32 pageDownId = reader.ReadInt32();

    TAknsItemID id;

    //read seperation line res

    const TInt16 bmpId = reader.ReadInt16();

    const TInt16 bmpMskId = reader.ReadInt16();

    // read skin item id

    const TInt skinitemid = reader.ReadInt16();

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

    if (bmpId != KInvalidBmp)

        {

    	if (bmpMskId != KInvalidBmp)

    		{

		    AknsUtils::CreateColorIconL( AknsUtils::SkinInstance(),

						         id,

						         KAknsIIDQsnIconColors,

						         EAknsCIQsnIconColorsCG30,

						         iSeperationBmp,

						         iSeperationMaskBmp,

						         bmpFileName,

						         bmpId,

						         bmpMskId,

						         AKN_LAF_COLOR( 0 ) );    		                     

            }

        else

            {

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

    	                           id,

    	                           iSeperationBmp,

    	                           bmpFileName,

    	                           bmpId);

            }

        }

    CleanupStack::PopAndDestroy(1); // reader

    TResourceReader pageUpReader;

    CCoeEnv::Static()->CreateResourceReaderLC(pageUpReader, pageUpId);

    iPageUp->ConstructFromResourceL(pageUpReader);

    CleanupStack::PopAndDestroy(1); // pageUpReader, imgreader

    TResourceReader pageDownReader;

    CCoeEnv::Static()->CreateResourceReaderLC(pageDownReader, pageDownId);

    iPageDown->ConstructFromResourceL(pageDownReader);

    CleanupStack::PopAndDestroy(1); // pageDownReader, imgreader

    }

EXPORT_C void CFepLayoutScrollableList::SizeChanged(TSize aItemSize,

                                                    TInt aHorizontalMargin,

                                                    TInt aVerticalMargin,

                                                    TSize aNaviSize,

                                                    TSize aNaviInnerSize)

    {

    iItemSize = aItemSize;

    iHorizontalMargin = aHorizontalMargin;

    iVerticalMargin = aVerticalMargin;

    iNaviSize = aNaviSize;

    iNaviInnerSize = aNaviInnerSize;

    }

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

                                                        TRgb aFontColor)

    {

    iFont = aFont;

    iFontColor = aFontColor;

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

    }

EXPORT_C void CFepLayoutScrollableList::Draw()

    {

    if (Hiden() || !Ready() || Rect().Size() == TSize(0,0))

        {

        return;

        }

    // draw background of whole control

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

    //mask bitmaps

    TRect rect = Rect();

  	DrawOpaqueMaskBackground();

    TRect innerRect = rect;

    innerRect.Shrink(4, 4);

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

    gc->Activate(BitmapDevice());

    gc->Clear(rect);

	AknsDrawUtils::DrawFrame(AknsUtils::SkinInstance(), 

	                         *gc, 

	                         rect, 

	                         innerRect,

	                         iBgFrId,

	                         KAknsIIDDefault);

    // draw item

    for (TInt i = iCurrentPage * iOnePageItemCnt; 

         i < (iCurrentPage + 1) * iOnePageItemCnt && i < ItemArray().Count();

         i++)

        {

        DrawItem(i);

        }

    // draw scroll area

    if (iNaviBtnShown)

        {

        iPageUp->Draw();

        iPageDown->Draw();

        DrawPageInfo();

        }   

    }

EXPORT_C void CFepLayoutScrollableList::DrawPageInfo()

    {

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

    //TPtr ptr = iPageInfo->Des();

    //FORMATPAGEINFO(ptr, *iPageInfoFormat, iCurrentPage + 1, iTotalPages);

    TRAP_IGNORE(UpdatePageInfoL( iCurrentPage + 1, iTotalPages ));

    if( iPageInfoLineSet )

        {

        TRgb color( KRgbBlack );  // sane default for nonskinned case

        TAknLayoutText textLayout;

        textLayout.LayoutText(iScrollRect, iPageInfoTextLine );

	    TAknsQsnTextColorsIndex clrIndex;

	    clrIndex = EAknsCIQsnTextColorsCG20;

	    if ( AknsUtils::AvkonSkinEnabled() )

	        {

	        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

	                               color, KAknsIIDQsnTextColors, clrIndex );

	        }

	    textLayout.DrawText(*gc, iPageInfo->Des(), EFalse, color);

        }

    else

        {

        gc->UseFont(iFont);

        gc->SetBrushStyle(CGraphicsContext::ENullBrush);

        gc->SetBrushColor(KRgbBlack);

        gc->SetPenColor(iFontColor);

        gc->SetPenStyle(CGraphicsContext::ESolidPen);

        gc->SetPenSize(PenSize());

        gc->DrawText(iPageInfo->Des(),

                     iPageInfoRect,

                     iBaselineOffset,

                     CGraphicsContext::ECenter);

        gc->DiscardFont();

        }

    }

EXPORT_C TInt CFepLayoutScrollableList::HitTest(const TPoint& aPoint)

    {

    if( !Contains( aPoint ) )

        {

        return EListOutside;

        }

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

        {

        if (iItemRects[i].Contains(aPoint))

            {

            if ((iCurrentPage * iOnePageItemCnt + i) < ItemArray().Count())

                return (iCurrentPage * iOnePageItemCnt + i);

            else 

                break;

            }

        }

    return EListInsideNoneListItem;    

    }

void CFepLayoutScrollableList::ScrollPageUp()

    {

    if (iCurrentPage >= 0 && iCurrentPage <= (iTotalPages - 1))

        {

        if (iCurrentPage == 0)

        	{

        	iCurrentPage = iTotalPages - 1;

        	}

        else

        	{

            iCurrentPage--;

        	}

        UpdateNaviButtonStates();

        Draw();

        UpdateArea( Rect(), EFalse);    

        }

#ifdef RD_TACTILE_FEEDBACK        

	UpdateFeedbackArea();

#endif // RD_TACTILE_FEEDBACK		

    }

void CFepLayoutScrollableList::ScrollPageDown()

    {

    if (iCurrentPage >= 0 && iCurrentPage <= (iTotalPages - 1))

        {

        if (iCurrentPage == iTotalPages - 1)

        	{

        	iCurrentPage = 0;

        	}

        else

        	{

            iCurrentPage++;

        	}

        UpdateNaviButtonStates();

        Draw();

        UpdateArea( Rect(), EFalse);    

        }

#ifdef RD_TACTILE_FEEDBACK

	UpdateFeedbackArea();

#endif // RD_TACTILE_FEEDBACK		

    }

EXPORT_C void CFepLayoutScrollableList::UpdateNaviButtonStates()

    {

    iPageUp->SetDimmed( iTotalPages == 1 );

    iPageDown->SetDimmed(iTotalPages == 1 );

    }

EXPORT_C void CFepLayoutScrollableList::CalcPageInfo()

    {

    iCurrentPage = 0;

    iTotalPages = (ItemArray().Count() + iOnePageItemCnt - 1) / iOnePageItemCnt;

    UpdateNaviButtonStates();

    }

EXPORT_C void CFepLayoutScrollableList::CalculateItemWidth()

    {

    iItemSize.iWidth = iInitItemWidth;

    const RPointerArray<SItem>& allItems = ItemArray();

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

        {

        TInt itemWidth = iFont->TextWidthInPixels( allItems[i]->iText );

        if( itemWidth > iItemSize.iWidth )

            {

            iItemSize.iWidth = itemWidth;

            }

        }

    TPixelsTwipsAndRotation ptScreenSize;             

    CCoeEnv::Static()->ScreenDevice()->

                            GetDefaultScreenSizeAndRotation(ptScreenSize); 

    // calculate the length exclude the item

	TInt naviWidth = iNaviBtnShown? iNaviSize.iWidth : 0;                      

	TInt len = 4*iHorizontalMargin + naviWidth;

    if( iItemSize.iWidth + len > ptScreenSize.iPixelSize.iWidth)    

        {

        iItemSize.iWidth = ptScreenSize.iPixelSize.iWidth - len;

        }

    }

EXPORT_C void CFepLayoutScrollableList::DrawItem(TInt aItemIndex, TBool aItemActive)

    {

    // aItemIndex is relative to whole item array

    TBool isSpecial = ((aItemIndex == ItemArray().Count() - 1) && iSpecialItemOn);

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

    TRect itemRect = iItemRects[aItemIndex % iOnePageItemCnt];

    TBool isFocus = aItemIndex == iCurFocusItem;

    if ( isSpecial )

        {

	    //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(itemRect);	    

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

	    gc->Activate(BitmapDevice());        

        TRect sepRect = itemRect;

        sepRect.iBr.iY = sepRect.iTl.iY + 2;

        sepRect.Move( 0, -4 );

    	SetListSeperationRect( sepRect );

        // draw background frame of special item		

		if( iSeperationBmp )

			{

			TRect srcRect( TPoint( 0, 0 ), iSeperationBmp->SizeInPixels() );

			if( iSeperationMaskBmp )

				{

				gc->BitBltMasked( iSeperationRect.iTl, 

								  iSeperationBmp, 

								  srcRect,

								  iSeperationMaskBmp,

								  ETrue);

				}

			else

				{

				gc->BitBlt( iSeperationRect.iTl,

							iSeperationBmp,

							srcRect );

				}

			}

        }

    if( isFocus )

    	{

        //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(itemRect);

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

        gc->Activate(BitmapDevice());   

	      // draw frame

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

	    TRect innerRect = itemRect;

	    innerRect.Shrink(7, 7);

        AknsDrawUtils::DrawFrame(skin, 

                                 *gc, 

	                             itemRect,

	                             innerRect,

                                 aItemActive ? iItemActiveFrId : iItemFrId,

                                 KAknsIIDDefault); 

        }

    // draw text

    if (iTextLineSet)

        {

        gc->SetBrushStyle(CGraphicsContext::ENullBrush);

        gc->SetBrushColor(KRgbBlack); 

	    TRgb color( KRgbBlack );  // sane default for nonskinned case

        TAknLayoutText textLayout;

        textLayout.LayoutText(itemRect, 

                              iTextLine);

	    TAknsQsnTextColorsIndex clrIndex;

	    clrIndex = isFocus ? EAknsCIQsnTextColorsCG10 : EAknsCIQsnTextColorsCG20;

	    if ( AknsUtils::AvkonSkinEnabled() )

	        {

	        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

	                               color, KAknsIIDQsnTextColors, clrIndex );

	        }

	    textLayout.DrawText(*gc, ItemArray()[aItemIndex]->iText, ETrue, color);

        }

    else if (iFont)

        {

        gc->UseFont(iFont);

        gc->SetBrushStyle(CGraphicsContext::ENullBrush);

        gc->SetBrushColor(KRgbBlack);

        gc->SetPenColor(iFontColor);

        gc->SetPenStyle(CGraphicsContext::ESolidPen);

        gc->SetPenSize(PenSize());

        if (iFont->TextWidthInPixels(ItemArray()[aItemIndex]->iText) > itemRect.Width())

            {

            TBuf<KDisplayTextLen> buf;

            AknBidiTextUtils::ConvertToVisualAndClip(ItemArray()[aItemIndex]->iText,

                                                     buf,

                                                     *iFont,

                                                     itemRect.Width(),

                                                     itemRect.Width());

            gc->DrawText(buf, 

                         itemRect,

                         iBaselineOffset,

                         CGraphicsContext::ELeft);  

            }

        else

            {

            gc->DrawText(ItemArray()[aItemIndex]->iText,

                         itemRect,

                         iBaselineOffset,

                         CGraphicsContext::ELeft);

            }

        gc->DiscardFont();

        }    

    }

EXPORT_C void CFepLayoutScrollableList::ConstructL()

    {

    CFepLayoutPopupWnd::ConstructL();

    //create page up/down buttons

    iPageUp = CAknFepCtrlCommonButton::NewL(

                                     UiLayout(), 

                                     KCtrlIdPageUp,

                                     KAknsIIDQsnFrButtonNormal,

                                     KAknsIIDQsnFrButtonPressed,

                                     KAknsIIDQsnFrButtonInactive);

    iPageUp->AddEventObserver( this );

    iPageDown = CAknFepCtrlCommonButton::NewL(

                                     UiLayout(), 

                                     KCtrlIdPageDown,

                                     KAknsIIDQsnFrButtonNormal,

                                     KAknsIIDQsnFrButtonPressed,

                                     KAknsIIDQsnFrButtonInactive);

    iPageDown->AddEventObserver( this );

    AddControlL( iPageUp );

    AddControlL( iPageDown );

    }

EXPORT_C CFepLayoutScrollableList::CFepLayoutScrollableList(CFepUiLayout* aUiLayout,

                                                   TInt aControlId,

                                                   TSize aItemSize,

                                                   TInt aHorizontalMargin,

                                                   TInt aVerticalMargin,