/*

* 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:  Taskswitcher Fast Swap area UI

 *

*/

#include <avkon.mbg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknsFrameBackgroundControlContext.h>

#include <touchfeedback.h>

#include "tsfastswapgrid.h"

#include "tsapplogging.h"

 /* ================================================================================

  * CTsFastSwapGrid

  * ================================================================================

  */

const TInt KCloseIconRedrawTime = 300000; // 0.3 second

const TInt KStrokeThickness = 1;

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

// CTsFastSwapGrid::CTsFastSwapGrid

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

//

CTsFastSwapGrid::CTsFastSwapGrid()

: CAknGrid(),

  iCloseIconHitIdx( KErrNotFound ),

  iBehaviour( ETouchOnly ),

  iHighlightVisible( EFalse ),

  iAknEventHandlingEnabled(ETrue)

    {

    }

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

// CTsFastSwapGrid::~CTsFastSwapGrid

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

//

CTsFastSwapGrid::~CTsFastSwapGrid()

    {

    iCloseItems.Close();

    delete iCloseIconRedrawTimer;

    }

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

// CTsFastSwapGrid::ConstructL

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

//

void CTsFastSwapGrid::ConstructL( const CCoeControl* aParent )

    {

    TSLOG_CONTEXT( CTsFastSwapGrid::ConstructL, TSLOG_LOCAL );

    TSLOG_IN();

    iParent = aParent;

    CAknGrid::ConstructL( aParent, EAknListBoxSelectionGrid );

    SetPrimaryScrollingType(CAknGridView::EScrollFollowsItemsAndLoops);

    SetSecondaryScrollingType(CAknGridView::EScrollFollowsItemsAndLoops);

    iCloseIconRedrawTimer = new (ELeave) CTsFastSwapTimer( *this );

    iCloseIconRedrawTimer->ConstructL();

    TSLOG_OUT();

    }

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

// CTsFastSwapGrid::HandlePointerEventL

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

//

void CTsFastSwapGrid::HandlePointerEventL( const TPointerEvent &aPointerEvent )

    {

    TSLOG_CONTEXT( CTsFastSwapGrid::HandlePointerEventL, TSLOG_LOCAL );

    TSLOG_IN();

    TBool eventHandled( EFalse );

    if ( aPointerEvent.iType == TPointerEvent::EButton1Up ||

         aPointerEvent.iType == TPointerEvent::EButton1Down )

        {

        // Check if close icon has been hit

        // Find hit item

        TInt hitItem( KErrNotFound );

        for ( TInt i = 0; i < Model()->NumberOfItems(); i++ )

            {

            if ( GridView()->XYPosToItemIndex( aPointerEvent.iParentPosition, i ) )

                {

                hitItem = i;

                break;

                }

            }

        if ( hitItem != KErrNotFound && CanCloseItem( hitItem ) )

            {

            // Item found, check if close icon has been hit

            TPoint itemPos = GridView()->ItemPos( hitItem );

            TSize itemSize = GridView()->ItemSize( hitItem );

            TRect itemRect( itemPos, itemSize );

            CTsGridItemDrawer* itemDrawer =

                static_cast<CTsGridItemDrawer*>( ItemDrawer() );

            TRect closeIconRect = itemDrawer->GetCloseButtonRect( itemRect );

            if ( closeIconRect.Contains( aPointerEvent.iParentPosition ) )

                {

                // Close icon hit

                TInt hitDataIdx(hitItem);

                if ( AknLayoutUtils::LayoutMirrored() )

                    {

                    // Calculate logical item index

                    hitDataIdx = Model()->ItemTextArray()->MdcaCount() - 1 - hitItem;

                    }

                iCloseIconHitIdx = hitDataIdx;

                eventHandled = ETrue;

                if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

                    {

                    // Update current item and redraw grid

                    SetCurrentItemIndex( hitItem );

                    DrawNow();

                    iCloseIconRedrawTimer->Cancel();

                    iCloseIconRedrawTimer->After(KCloseIconRedrawTime);

                    }

                else

                    {

                    // Pointer up

                    if ( iFastSwapGridObserver )

                        {

                        MTouchFeedback* feedback = MTouchFeedback::Instance();

                        feedback->InstantFeedback(this,

                                                  ETouchFeedbackBasicButton, 

                                                  ETouchFeedbackVibra, 

                                                  aPointerEvent);

                        }

                    if ( GridBehaviour() == EHybrid )

                        {

                        ShowHighlight();

                        }

                    else

                        {

                        Redraw();

                        }

                    iFastSwapGridObserver->HandleCloseEventL( hitDataIdx );

                    ResetCloseHit();

                    }

                }

            }

        }

    if ( !eventHandled )

        {

        CTsGridItemDrawer* itemDrawer =

            static_cast<CTsGridItemDrawer*>( ItemDrawer() );

        if( aPointerEvent.iType == TPointerEvent::EButton1Down )

            {

            itemDrawer->SetRedrawBackground( ETrue );

            }

        else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

            {

            itemDrawer->SetRedrawBackground( EFalse );

            }

        if ( iAknEventHandlingEnabled )

            {

            CAknGrid::HandlePointerEventL( aPointerEvent );

            }

        Redraw();

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapGrid::HandleDeviceStateChanged

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

//

void CTsFastSwapGrid::HandleDeviceStateChanged( TChangeType aChangeType )

    {

    TSLOG_CONTEXT( CTsFastSwapGrid::HandleDeviceStateChanged, TSLOG_LOCAL );

    TSLOG_IN();

    if ( aChangeType == ESkin )

        {

        LoadCloseIconAndStrokeParams();

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapGrid::HandleResourceChange

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

//

void CTsFastSwapGrid::HandleResourceChange( TInt aType )

    {

    TSLOG_CONTEXT( CTsFastSwapGrid::HandleResourceChange, TSLOG_LOCAL );

    TSLOG_IN();

    if ( aType != KEikDynamicLayoutVariantSwitch &&

         Model()->ItemTextArray()->MdcaCount() )

        {

        CAknGrid::HandleResourceChange( aType );

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapGrid::SizeChanged

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

//

void CTsFastSwapGrid::SizeChanged()

    {

    }

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

// CTsFastSwapGrid::Draw

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

//

void CTsFastSwapGrid::Draw( const TRect& aRect ) const

    {

    CAknGrid::Draw(aRect);

    if ( !Model()->ItemTextArray()->MdcaCount() )

        {

        GridView()->DrawEmptyList();

        }

    }

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

// CTsFastSwapGrid::SetFastSwapGridObserver

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

//

void CTsFastSwapGrid::SetFastSwapGridObserver( MTsFastSwapGridObserver* aObserver )

    {

    iFastSwapGridObserver = aObserver;

    }

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

// CTsFastSwapGrid::CreateItemDrawerL

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

//

void CTsFastSwapGrid::CreateItemDrawerL()

    {

    TSLOG_CONTEXT( CTsFastSwapGrid::CreateItemDrawerL, TSLOG_LOCAL );

    TSLOG_IN();

    CFormattedCellGridData* data = CFormattedCellGridData::NewL();

    CleanupStack::PushL( data );

    CTsGridItemDrawer* itemDrawer =

        new ( ELeave ) CTsGridItemDrawer( this, data );

    iItemDrawer = itemDrawer;

    CleanupStack::Pop( data );

    TSLOG_OUT();

    }

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

// CTsFastSwapGrid::UpdateItemDrawerLayoutDataL

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

//

void CTsFastSwapGrid::UpdateItemDrawerLayoutDataL()

    {

    CTsGridItemDrawer* itemDrawer =

        static_cast<CTsGridItemDrawer*>( ItemDrawer() );

    TPixelsAndRotation screenSize;

    iEikonEnv->ScreenDevice()->GetDefaultScreenSizeAndRotation(screenSize);

    TRect availableRect = TRect( TPoint(0,0), screenSize.iPixelSize );

    itemDrawer->SetScreenRect(availableRect);

    TAknLayoutRect fastSwapAreaPane;

    TInt variety = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

    fastSwapAreaPane.LayoutRect( availableRect,

            AknLayoutScalable_Apps::tport_appsw_pane( variety ) );

    const TInt leftOffset = iParent->Rect().iTl.iX;

    const TInt rightOffset = availableRect.Width() - iParent->Rect().iBr.iX;

    SetVisibleViewRect(fastSwapAreaPane.Rect());

    itemDrawer->SetEdgeOffset( leftOffset, rightOffset );

    LoadCloseIconAndStrokeParams();

    }

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

// CTsFastSwapGrid::EnableAknEventHandling

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

//

void CTsFastSwapGrid::EnableAknEventHandling( TBool aEnable )

    {

    iAknEventHandlingEnabled = aEnable;

    }

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

// CTsFastSwapGrid::TimerCompletedL

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

//

void CTsFastSwapGrid::TimerCompletedL( CTsFastSwapTimer* aSource )

    {

    if ( aSource == iCloseIconRedrawTimer )

        {

        ResetCloseHit();

        }

    }

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

// CTsFastSwapGrid::SetCloseItemsL

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

//

void CTsFastSwapGrid::SetCloseItemsL( RArray<TInt>& aItemIndex )

    {

    iCloseItems.Close();

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

        {

        iCloseItems.AppendL( aItemIndex[i] );

        }

    }

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

// CTsFastSwapGrid::CanCloseItem

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

//

TBool CTsFastSwapGrid::CanCloseItem( TInt aItemIndex )

    {

    return iCloseItems.Find(aItemIndex) != KErrNotFound;

    }

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

// CTsFastSwapGrid::ItemCloseHit

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

//

TBool CTsFastSwapGrid::IsItemCloseHit( TInt aItemIndex )

    {

    return iCloseIconHitIdx == aItemIndex;

    }

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

// CTsFastSwapGrid::ResetCloseHit

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

//

void CTsFastSwapGrid::ResetCloseHit()

    {

    iCloseIconHitIdx = KErrNotFound;

    }

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

// CTsFastSwapGrid::SetStrokeColor

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

//

void CTsFastSwapGrid::SetStrokeColors( TRgb aColor,

                                       TRgb aHighlightedColor )

    {

    static_cast<CTsGridItemDrawer*>(iItemDrawer)->SetStrokeColors(aColor, aHighlightedColor);

    }

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

// CTsFastSwapGrid::SetStrokeItemsL

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

//

void CTsFastSwapGrid::SetStrokeItemsL( RArray<TInt>& aItemIndex )

    {

    static_cast<CTsGridItemDrawer*>(iItemDrawer)->SetStrokeItemsL(aItemIndex);

    }

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

// CTsFastSwapGrid::SetBehaviour

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

//

void CTsFastSwapGrid::SetGridBehaviour( TFastSwapGridBehaviour aBehaviour )

    {

    iBehaviour = aBehaviour;

    switch ( iBehaviour )

        {

        case ETouchOnly:

            {

            HideHighlight();

            }

            break;

        default:

            {

            ShowHighlight();

            }

            break;

        }

    }

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

// CTsFastSwapGrid::GridBehaviour

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

//

CTsFastSwapGrid::TFastSwapGridBehaviour CTsFastSwapGrid::GridBehaviour()

    {

    return iBehaviour;

    }

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

// CTsFastSwapGrid::ShowHighlight

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

//

void CTsFastSwapGrid::ShowHighlight()

    {

    if ( !iHighlightVisible )

        {

        // Draw highlight

        iHighlightVisible = ETrue;

        Redraw();

        }

    }

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

// CTsFastSwapGrid::HideHighlight

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

//

void CTsFastSwapGrid::HideHighlight()

    {

    if ( iHighlightVisible )

        {

        iHighlightVisible = EFalse;

        Redraw();

        }

    }

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

// CTsFastSwapGrid::IsHighlightVisible

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

//

TBool CTsFastSwapGrid::IsHighlightVisible()

    {

    return iHighlightVisible;

    }

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

// CTsFastSwapGrid::SetVisibleViewRect

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

//

void CTsFastSwapGrid::SetVisibleViewRect( const TRect aRect )

    {

    iVisibleViewRect = aRect;

    }

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

// CTsFastSwapGrid::VisibleViewRect

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

//

TRect CTsFastSwapGrid::VisibleViewRect()

    {

    TRect retVal;

    TRect emptyRect = TRect( 0, 0, 0, 0 );

    if ( iVisibleViewRect == emptyRect )

        {

        retVal = Rect();

        }

    else

        {

        retVal = iVisibleViewRect;

        }

    return retVal;

    }

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

// CTsFastSwapGrid::LoadCloseIconAndStrokeParams

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

//

void CTsFastSwapGrid::LoadCloseIconAndStrokeParams()

    {

    // Load and set close icon

    CFbsBitmap* icon = NULL;

    CFbsBitmap* iconMask = NULL;

    CFbsBitmap* iconPressed = NULL;

    CFbsBitmap* iconPressedMask = NULL;

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

                KAknsIIDQgnIndiTsButtonClose,

                icon,

                iconMask,

                KAvkonBitmapFile,

                EMbmAvkonQgn_indi_button_preview_close,

                EMbmAvkonQgn_indi_button_preview_close_mask

                ));

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

                KAknsIIDQgnIndiTsButtonClosePressed,

                iconPressed,

                iconPressedMask,

                KAvkonBitmapFile,

                EMbmAvkonQgn_indi_button_preview_close,

                EMbmAvkonQgn_indi_button_preview_close_mask

                ));

    TAknLayoutRect gridItem;

    TAknLayoutRect gridImage;

    TAknLayoutRect gridCloseButton;

    TAknLayoutRect gridCloseIcon;

    TInt variety = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;

            AknLayoutScalable_Apps::cell_tport_appsw_pane( variety, 0, 0 ) );