/*

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

#include <ganes/HgList.h>

#include <ganes/HgItem.h>

#include "HgLayoutData.h"

#include "HgDrawUtils.h"

#include <aknphysics.h>

#include "HgConstants.h"

#include "HgMarquee.h"

#include <AknIconUtils.h>

#include <avkon.mbg>

#include <AknUtils.h> //AknLayoutUtils

#include <gdi.h> // CFont

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknsConstants.h>

#include <AknsFrameBackgroundControlContext.h>

#include <gulicon.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

// UI Constants

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

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

// CHgList::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CHgList::ConstructL (const TRect& aRect, RWsSession* aSession )

    {

    // Inherited classes might use some custom layout data, so lets use the

    // default one only if not yet initialized.

    if( !iLayoutData )

        iLayoutData = CHgListLayoutData::NewL();

    CHgScroller::ConstructL( aRect, aSession );

    // Activate the window, which makes it ready to be drawn

    ActivateL ( );

    }

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

// CHgList::CHgList()

// C++ default constructor can NOT contain any code, that might leave.

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

//

CHgList::CHgList( TInt aItemCount, 

        CGulIcon* aDefaultIcon )

: CHgScroller( aItemCount, aDefaultIcon ),

    iColor( KRgbBlack ),

    iColorBack( AKN_LAF_COLOR( 0 ) ),

    iHighlightedColor( KRgbBlack ),

    iHighlightedColorBack( AKN_LAF_COLOR( 0 ) )    

    {

    SetFlags(EHgScrollerSearchWithQWERTY); // Set QWERTY search on

    }

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

// CHgList::~CHgList()

// Destructor.

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

//

EXPORT_C CHgList::~CHgList ( )

    {

    delete iLayoutData;

    }

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

// CHgList::InitItemsL()

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

//

void CHgList::InitItemsL()

    {

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

        {

        iItems.Append(CHgItem::NewL());

        }

    }

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

// CHgList::DrawHighlight()

// Called by Draw function to draw the higlighted item effect.

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

//

void CHgList::DrawHighlight( const TRect& aRect, TRgb& aTextColor ) const

    {

    // Init drawing options

    TRect outerRect( aRect );

    TRect innerRect( aRect );

    innerRect.Shrink(KListHighlightInnerRectShrink,KListHighlightInnerRectShrink);

    CWindowGc& gc = SystemGc();

    // Draw "selected item" rect for the row. Bitmaps to draw the rect are feched from 

    // current skin instance.

    if( HasHighlight() )

        {

        if( iPointerDown && !iPanning && iFocusedIndex != KErrNotFound && iSelectionToFocusedItem )

            {

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

                                        gc,

                                        outerRect,

                                        innerRect,

                                        KAknsIIDQsnFrListPressed,

                                        KAknsIIDQsnFrListCenterPressed );

            }

        else

            {

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

                                        gc,

                                        outerRect,

                                        innerRect,

                                        KAknsIIDQsnFrList,

                                        KAknsIIDQsnFrListCenter );

            }

        aTextColor = iHighlightedColor;

        }

    else if( iPointerDown && !iPanning )

        {

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

                                    gc,

                                    outerRect,

                                    innerRect,

                                    KAknsIIDQsnFrList,

                                    KAknsIIDQsnFrListCenter );

        }

    }

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

// CHgList::HandleSizeChanged()

// Called by framework when the view size is changed.

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

//

void CHgList::HandleSizeChanged ( )

    {

    iLandscapeScrolling = EFalse; // list always scrolls in portrait mode

    iRows = iItemCount;

    // Resolve colors for normal and higlighted items            

    if ( AknsUtils::AvkonSkinEnabled() )

        {

        // this does not modify color unless it gets a correct one

        // no real need to check errors

        AknsUtils::GetCachedColor( 

                AknsUtils::SkinInstance(),

                iColor,

                KAknsIIDQsnTextColors,

                EAknsCIQsnTextColorsCG6 );                

        AknsUtils::GetCachedColor( 

                AknsUtils::SkinInstance(),

                iHighlightedColor,

                KAknsIIDQsnTextColors,

                EAknsCIQsnTextColorsCG10 );

        }

    iLayoutData->SetBaseLayout(AknLayoutScalable_Avkon::list_gen_pane(0));

    if( iFlags & CHgScroller::EHgScrollerFlatStatusPane )

        {

        iListOffset = TPoint(0,0);

        }

    else

        {

        TAknLayoutRect foobar;

        foobar.LayoutRect(Rect(), AknLayoutScalable_Avkon::listscroll_gen_pane(0));

        iWidth = foobar.Rect().Width();

        iHeight = foobar.Rect().Height();

        iListOffset = foobar.Rect().iTl;

        }

    }

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

// CHgList::DoDraw()

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

//

void CHgList::DoDraw(const TRect& /*aRect*/ ) const

    {

    // Calculate the displacement. How much of the first row is showing.

    TInt ydiff = (iViewPosition.iY-(iHeight/2))%(iRowHeight);

    CWindowGc& gc = SystemGc();

    if( iItemCount == 0 )

        {

        if( iEmptyText )

            iDrawUtils->DrawEmptyText(gc, Rect(), *iEmptyText, iColor);

        }

    else

        {

        // Get the row rect

        TAknLayoutRect layout;

        layout.LayoutRect(ListRect(), iLayoutData->ItemLayout());

        ResetClippingRect(gc);

        // Draw rows

        for(TInt i = iCurrentRow; i < iRows && i < iItems.Count(); ++i)

            {

            // Topleft position of the row.

            TPoint point(

                    0, 

                    ((i-iCurrentRow)*iRowHeight) - ydiff);

            if( i < 0 || point.iY < iListOffset.iY - layout.Rect().Height() )

                continue; // Not a real row

            else if( point.iY + iListOffset.iY > iHeight )

                break; // Row is now showing on the screen, we can stop. 

            TRect rect(layout.Rect());

            // Move to correct y-position

            rect.Move(point);

            DrawItem( i, rect );

            }

        gc.CancelClippingRect();

        }

    }

void CHgList::ResetClippingRect( CWindowGc& aGc ) const

    {

    if( !(iFlags & CHgScroller::EHgScrollerFlatStatusPane) )

        aGc.SetClippingRect( TRect(iListOffset, TSize(iWidth, iHeight+2)) );

    }

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

// CHgList::TotalSize()

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

//

TSize CHgList::TotalSize() const 

    {

    return TSize( iWidth, iRows*iRowHeight );

    }

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

// CHgList::GetSelected()

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

//

TInt CHgList::GetSelected( TPoint aPosition ) const

    {

    // Real position is current screen pos + world pos

    TInt y = aPosition.iY + (iViewPosition.iY - (iHeight/2)) - iListOffset.iY;

    y /= iRowHeight;

    return y >= iItems.Count() || y < 0 ? KErrNotFound : y;

    }

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

// CHgList::DoHandleKeyEvent()

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

//

TBool CHgList::DoHandleKeyEvent(const TKeyEvent& aKeyEvent)

    {        

    TBool ret = ETrue;

    switch( aKeyEvent.iCode )

        {

        case EKeyUpArrow:

            HandleUpArrow();

            break;

        case EKeyDownArrow:

            HandleDownArrow();

            break;

        case EKeyLeftArrow:

        case EKeyRightArrow:

        default:

            ret = EFalse;

            break;

        }

    return ret;

    }

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

// CHgList::HandleDownArrow()

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

//

void CHgList::HandleDownArrow()

    {

    if( iSelectedIndex == KErrNotFound )

        {

        SelectDefaultItem();

        }

    else

        {

        if( iSelectedIndex <= iRows - 1 )

            {

            const TInt nextIndex = iSelectedIndex == (iRows - 1) ? 

                0 : iSelectedIndex + 1;

            if( iSelectionMode == ESelectionMark )

                {

                Mark( iSelectedIndex );

                Mark( nextIndex );

                }

            else if( iSelectionMode == ESelectionUnMark )

                {

                UnMark( iSelectedIndex );

                UnMark( nextIndex );

                }

            iSelectedIndex = nextIndex;

            FitSelectionToView();

            SelectionChanged();

            DrawDeferred();

            }

        }

    }

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

// CHgList::HandleUpArrow()

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

//

void CHgList::HandleUpArrow()

    {    

    if( iSelectedIndex == KErrNotFound )

        {

        SelectDefaultItem();

        }

    else

        {

        if( iSelectedIndex >= 0 )

            {

            const TInt nextIndex = iSelectedIndex == 0 ? 

                iRows - 1 : iSelectedIndex - 1;

            if( iSelectionMode == ESelectionMark )

                {

                Mark( iSelectedIndex );

                Mark( nextIndex );

                }

            else if( iSelectionMode == ESelectionUnMark )

                {

                UnMark( iSelectedIndex );

                UnMark( nextIndex );

                }

            iSelectedIndex = nextIndex;

            FitSelectionToView();

            SelectionChanged();

            DrawDeferred();

            }

        }

    }

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

// CHgList::FitSelectionToView()

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

//

void CHgList::FitSelectionToView()

    {

    FitRowToView( iSelectedIndex );

    }

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

// CHgList::ListRect()

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

//

TRect CHgList::ListRect() const

    {

    TRect rect(iListOffset, TSize(iWidth,iHeight));

    TAknLayoutRect areaaftersb;

    areaaftersb.LayoutRect(rect, iLayoutData->BaseLayout());

    return areaaftersb.Rect();

    }

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

// CHgList::SelectDefaultItem()

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

//

void CHgList::SelectDefaultItem()

    {

    iSelectedIndex = iCurrentRow;

    FitSelectionToView();

    SelectionChanged();

    DrawDeferred();

    }

TInt CHgList::CurrentIndex()

    {

    return iCurrentRow;

    }

TBool CHgList::IsDisplayed( TInt aIndex )

    {

    TInt start = CurrentIndex();

    TInt rowsPerView = ItemsOnScreen();

    if( (iViewPosition.iY-(iHeight/2))%(iRowHeight) )

        ++rowsPerView;

    TInt end = start + rowsPerView;

    return aIndex >= start && aIndex <= end;

    }

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

// CHgList::FitTopItemToView()

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

//

void CHgList::FitTopItemToView( TInt aIndex )

    {

    // Higlighted item is set to top of the list

    TInt newPos = aIndex*iRowHeight + iHeight/2;

    if( ItemsOnScreen() >= iItems.Count() )

        {

        newPos = iHeight/2;

        }

    else

        {

        const TInt endMid = TotalSize().iHeight - iHeight/2;

        if( newPos > endMid )

            {

            // We are presenting last items in the list

            newPos = endMid;

            }

        }

    iViewPosition.iY = newPos;

    HandleViewPositionChanged();    

    }

// End of File