/*

* Copyright (c) 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:  Taskswitcher Fast Swap area UI

 *

*/

#include <gulicon.h>

#include <eikenv.h>

#include <AknUtils.h>

#include <AknIconUtils.h>

#include <AknIconArray.h>

#include <aknstyluspopupmenu.h>

#include <AknQueryDialog.h>

#include <StringLoader.h>

#include <taskswitcher.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknlists.h>

#include <touchfeedback.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include <aknlongtapanimation.h>

#include "tsfastswaparea.h"

#include "tsapplogging.h"

#include "tsfswclient.h"

#include "tsappui.h"

#include "tsdatachangeobserver.h"

#include "tseventcontroler.h"

#include "tsappview.h"

/** command ids for the fsw popup */

enum TPopupCommands

    {

    EFswCmdClose = 10000,

    EFswCmdCloseAll

    };

/** Number of closable applications, to show "close all" option. */

const TInt KTsMaxClosableApps = 2;

/** Default grid item to highlight.*/

const TInt KItemToHighlight = 2;

const TInt KAppKeyTypeShort = 1;

const TInt KAppKeyTypeLong = 2;

const TInt KLayoutItemCount = 4;

const TInt KRedrawTime = 250000; // 0.25 sec

const TInt KRedrawTimeForLayoutSwitch = 700000; // 0.7 sec

const TInt KHighlighActivationTime = 100000; // 100 ms

const TInt KUpdateGridTime = 0; // imediately

const TInt KOrientationSwitchTime = 1000000; // 1 sec

const TInt KLongTapAnimationInitTime = 150000; // 0.15 sec

const TInt KLongTapAnimationTimeout = 1000000; // 1 sec

const TInt KMaxGranularity = 4;

const TUid KTsMenuUid = { 0x101f4cd2 };

const TUid KTsHomescreenUid = { 0x102750f0 };

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

// CTsFastSwapArea::NewL

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

//

CTsFastSwapArea* CTsFastSwapArea::NewL( const TRect& aRect,

    CCoeControl& aParent, CTsDeviceState& aDeviceState, 

    CTsEventControler& aEventHandler )

    {

    CTsFastSwapArea* self = CTsFastSwapArea::NewLC(aRect,

            aParent, aDeviceState, aEventHandler);

    CleanupStack::Pop( self );

    return self;

    }

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

// CTsFastSwapArea::NewLC

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

//

CTsFastSwapArea* CTsFastSwapArea::NewLC( const TRect& aRect,

    CCoeControl& aParent, CTsDeviceState& aDeviceState,

    CTsEventControler& aEventHandler)

    {

    CTsFastSwapArea* self = new (ELeave) CTsFastSwapArea(

            aParent, aDeviceState, aEventHandler);

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    return self;

    }

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

// CTsFastSwapArea::CTsFastSwapArea

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

//

CTsFastSwapArea::CTsFastSwapArea(CCoeControl& aParent,

    CTsDeviceState& aDeviceState,

    CTsEventControler& aEventHandler) :

    iParent(aParent), iDeviceState(aDeviceState), iEvtHandler(aEventHandler),

    iIgnoreLayoutSwitch(EFalse), iWidgetClosingCount(0), iLongTapAnimationRunning(EFalse)

    {

    // no implementation required

    }

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

// CTsFastSwapArea::~CTsFastSwapArea

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

//

CTsFastSwapArea::~CTsFastSwapArea()

    {

    iArray.ResetAndDestroy();

    iIsClosing.Close();

    delete iGrid;

    delete iFSClient;

    delete iPopup;

    delete iHighlightTimer;

    delete iRedrawTimer;

    delete iUpdateGridTimer;

    delete iOrientationSignalTimer;

    delete iLongTapAnimation;

    delete iLongTapAnimationTimer;

    }

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

// CTsFastSwapArea::ConstructL

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

//

void CTsFastSwapArea::ConstructL( const TRect& aRect )

    {

    SetContainerWindowL( iParent );

    SetRect( aRect );

    // setup grid

    ReCreateGridL();

    // create stylus popup instance

    PreCreatePopupL();

    // connect to fsw server

    iFSClient = CTsFswClient::NewL();

    iEvtHandler.ReInitPhysicsL(GridWorldSize(), ViewSize(), ETrue);

    // add self to device state observer

    iDeviceState.AddObserverL( *this, EDeviceType );

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

    iHighlightTimer->ConstructL();

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

    iRedrawTimer->ConstructL();

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

    iUpdateGridTimer->ConstructL();

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

    iOrientationSignalTimer->ConstructL();

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

    iLongTapAnimationTimer->ConstructL();

    iActivateOnPointerRelease = TPoint();

    iHandlePointerCandidate = EFalse;

    ActivateL();

    }

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

// CTsFastSwapArea::ReCreateGridL

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

//

void CTsFastSwapArea::ReCreateGridL()

    {

    MCoeControlObserver* obs = NULL;

    TBool wasHighlight = iDeviceState.DeviceType() == 

                             CTsDeviceState::EHybrid ? ETrue : EFalse;

    if ( iGrid )

        {

        obs = iGrid->Observer();

        iDeviceState.RemoveObserver(*iGrid);

        wasHighlight = iGrid->IsHighlightVisible();

        delete iGrid;

        iGrid = NULL;

        }

    iGrid = new( ELeave ) CTsFastSwapGrid;

    iGrid->ConstructL( this );

	iGrid->DisableSingleClick(ETrue);//enables highlight on pointer

    iDeviceState.AddObserverL(*iGrid, MTsDeviceStateObserver::ESkin);

    AknListBoxLayouts::SetupStandardGrid( *iGrid );

    // Setup layout

    LayoutGridL();

    if( wasHighlight )

        {

        iGrid->ShowHighlight();

        }

    else

        {

        iGrid->HideHighlight();

        }

    // Setup empty text

    HBufC* text = StringLoader::LoadLC( R_TS_FSW_NO_APPS );

    iGrid->SetEmptyGridTextL( *text );

    CleanupStack::PopAndDestroy( text );

    // Setup grid observers

    if ( obs )

        {

        iGrid->SetObserver( obs );

        }

    iGrid->SetListBoxObserver(this);

    iGrid->SetFastSwapGridObserver(this);

    iGrid->SetContainerWindowL(*this);

    // Make sure that there is an ActivateL call even when we are not

    // called from ConstructL. (in order to have the grid's parent ptr set properly)

    ActivateL();

    }

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

// CTsFastSwapArea::LayoutGridL

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

//

void CTsFastSwapArea::LayoutGridL()

    {

    RArray<TAknLayoutRect> rects;

    CleanupClosePushL(rects);

    rects.ReserveL(KLayoutItemCount);

    GetFastSwapAreaRects(rects);

    TAknLayoutRect gridAppPane = rects[0];

    TAknLayoutRect gridItem = rects[1];

    TAknLayoutRect gridImage = rects[2];

    TAknLayoutRect gridNextItem = rects[3];

    CleanupStack::PopAndDestroy(&rects);

    iGrid->SetRect(gridAppPane.Rect());

    TInt variety;

    TBool disable = GetVariety(variety);

    if ( disable )

        {

        TRAP_IGNORE(static_cast<CTsAppUi*>(iEikonEnv->AppUi())->RequestPopUpL());

        }

    variety = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0; // double check to avoid layout panic

    TAknLayoutScalableParameterLimits gridParams = 

        AknLayoutScalable_Apps::cell_tport_appsw_pane_ParamLimits( variety );

    TPoint empty( ELayoutEmpty, ELayoutEmpty );

    // Setup bitmap layout

    AknListBoxLayouts::SetupFormGfxCell( *iGrid, iGrid->ItemDrawer(), 0,

            AknLayoutScalable_Apps::cell_tport_appsw_pane_g1( variety ).LayoutLine(),

            empty, empty );

    // Setup text layout

    AknListBoxLayouts::SetupFormTextCell(*iGrid, iGrid->ItemDrawer(), 1,

            AknLayoutScalable_Apps::cell_tport_appsw_pane_t1( variety ).LayoutLine(),

            empty, empty);

    // Text colors

    TRgb textColor;

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

            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );

    TRgb highlightTextColor;

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

            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG11 );

    CFormattedCellListBoxData::TColors colors;

    colors.iText = textColor;

    colors.iBack = iGrid->ItemDrawer()->BackColor();

    colors.iHighlightedText = highlightTextColor;

    colors.iHighlightedBack = iGrid->ItemDrawer()->HighlightedBackColor();

    iGrid->ItemDrawer()->FormattedCellData()->SetSubCellColorsL(1, colors);

    iGrid->SetStrokeColors(textColor, highlightTextColor);

    if ( AknLayoutUtils::LayoutMirrored() )

        {

        iGridItemGap = gridItem.Rect().iTl.iX - gridNextItem.Rect().iBr.iX;

        }

    else

        {

        iGridItemGap = gridNextItem.Rect().iTl.iX - gridItem.Rect().iBr.iX;

        }

    iMaxItemsOnScreen = Rect().Width() / gridItem.Rect().Width();

    if ( iMaxItemsOnScreen > 1 )

        {

        TInt widthWithGaps =

            (iMaxItemsOnScreen - 1) * iGridItemGap + iMaxItemsOnScreen * gridItem.Rect().Width();

        if ( widthWithGaps > Rect().Width() )

            {

            iMaxItemsOnScreen--;

            }

        }

    iGridItemWidth = gridItem.Rect().Width();

    // Update item drawer

    iGrid->UpdateItemDrawerLayoutDataL();

    // Update state

    HandleDeviceStateChanged( EDeviceType );

    if ( disable )

        {

        TRAP_IGNORE(static_cast<CTsAppUi*>(iEikonEnv->AppUi())->DisablePopUpL());

        }

    }

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

// CTsFastSwapArea::LayoutGridView

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

//

void CTsFastSwapArea::LayoutGridViewL( TInt aItemCount )

    {

    RArray<TAknLayoutRect> rects;

    CleanupClosePushL(rects);

    rects.ReserveL(KLayoutItemCount);

    GetFastSwapAreaRects(rects);

    TAknLayoutRect gridItem = rects[1];

    CleanupStack::PopAndDestroy(&rects);

    if ( aItemCount )

        {

        iGrid->ItemDrawer()->ColumnData()->SetDrawBackground(EFalse);

        static_cast<CTsAppView*>(&iParent)->EnableDragEvents(ETrue);

        if ( AknLayoutUtils::LayoutMirrored() )

            {

            iGrid->SetLayoutL( EFalse, EFalse, ETrue, aItemCount, 1, gridItem.Rect().Size(), iGridItemGap );

            }

        else

            {

            iGrid->SetLayoutL( EFalse, ETrue, ETrue, aItemCount, 1, gridItem.Rect().Size(), iGridItemGap );

            }

        }

    else

        {

        iGrid->ItemDrawer()->ColumnData()->SetDrawBackground(ETrue);

        static_cast<CTsAppView*>(&iParent)->EnableDragEvents(EFalse);

        }

    // Update scrollbar frame

    if( iGrid->ScrollBarFrame() )

        {

        iGrid->SetScrollBarFrame(NULL,CEikListBox::EOwnedExternally);

        }

    }

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

// CTsFastSwapArea::GetFastSwapAreaRects

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

//

void CTsFastSwapArea::GetFastSwapAreaRects( RArray<TAknLayoutRect>& aRects )

    {

    TAknLayoutRect gridAppPane;

    TAknLayoutRect gridItem;

    TAknLayoutRect gridImage;

    TAknLayoutRect gridNextItem;

    TInt variety;

    TBool disable = GetVariety(variety);

    if ( disable )

        {

        TRAP_IGNORE(static_cast<CTsAppUi*>(iEikonEnv->AppUi())->RequestPopUpL());

        }

    variety = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0; // double check to avoid layout panic

    gridAppPane.LayoutRect( Rect(), 

            AknLayoutScalable_Apps::tport_appsw_pane( variety ) );

    aRects.Append(gridAppPane);

    gridItem.LayoutRect( gridAppPane.Rect(),

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

    aRects.Append(gridItem);

    gridImage.LayoutRect( gridItem.Rect(),

            AknLayoutScalable_Apps::cell_tport_appsw_pane_g1( variety ) ); 

    aRects.Append(gridImage);

    gridNextItem.LayoutRect( gridAppPane.Rect(),

            AknLayoutScalable_Apps::cell_tport_appsw_pane_cp03( variety ) );

    aRects.Append(gridNextItem);

    if ( disable )

        {

        TRAP_IGNORE(static_cast<CTsAppUi*>(iEikonEnv->AppUi())->DisablePopUpL());

        }

    }

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

// CTsFastSwapArea::Setup

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

//

void CTsFastSwapArea::Setup( MCoeControlObserver& aControlObserver )

    {

    iGrid->SetObserver( &aControlObserver );

    }

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

// CTsFastSwapArea::SizeChanged

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

//

void CTsFastSwapArea::SizeChanged()

    {

    TSLOG_CONTEXT( CTsFastSwapArea::SizeChanged, TSLOG_LOCAL );

    TSLOG_IN();

    if ( iGrid && !iIgnoreLayoutSwitch )

        {

        // Cancel ongoing pointer event

        iHandlePointerCandidate = EFalse;

        // Grid needs to be recreated to proper reinitilize

        // data with new layout values

        TInt selIdx = SelectedIndex();

        TRAPD(err,

              LayoutGridL();

              LayoutGridViewL( iArray.Count() );

              iEvtHandler.ReInitPhysicsL( GridWorldSize(), ViewSize(), ETrue );

              );

        if ( err != KErrNone )

            {

            TSLOG1( TSLOG_INFO, "LayoutGridL leaves with %d", err );

            }

        // Update grid view

        iGrid->SetCurrentDataIndex(selIdx);

        UpdateGrid(ETrue, EFalse);

        iGrid->DrawDeferred();

        // Order full redraw after switch

        if(iRedrawTimer)

            {

            iRedrawTimer->Cancel();

            iRedrawTimer->After(KRedrawTimeForLayoutSwitch);

            }

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapArea::Draw

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

//

void CTsFastSwapArea::Draw( const TRect& /*aRect*/ ) const

    {

//    CWindowGc& gc = SystemGc();

//    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

//    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

//    AknsDrawUtils::Background( skin,

//           cc,

//           this,

//           gc,

//           Rect() );

    }

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

// CTsFastSwapArea::SwitchToApp

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

//

void CTsFastSwapArea::SwitchToApp( TInt aIndex )

    {

    if ( aIndex >= 0 && aIndex < iArray.Count() )

        {

        TInt wgId = iArray[aIndex]->WgId();

        TUid appUid = iArray[aIndex]->AppUid();

        SwitchToApp( wgId, appUid );

        }

    }

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

// CTsFastSwapArea::SwitchToApp

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

//

void CTsFastSwapArea::SwitchToApp( const TUid& aUid )

    {

    TApaTaskList taskList( iEikonEnv->WsSession() );

    TApaTask task = taskList.FindApp( aUid );

    TInt wgId = task.WgId();

    SwitchToApp( wgId, aUid );

    }

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

// CTsFastSwapArea::SwitchToApp

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

//

void CTsFastSwapArea::SwitchToApp( TInt aWgId, const TUid& aUid )

    {

    CTsAppUi* appui =

        static_cast<CTsAppUi*>( iEikonEnv->AppUi() );

    TBool effectsEnabled = appui->EffectsEnabled();

    // Move other app to foreground

    if ( !effectsEnabled )

        {

        iFSClient->SwitchToApp( aWgId );

        }

    // We do not want to come back to ts if the activated app is closed.

    // Therefore ts must be moved to background. Ignore orientation updates, it

    // will be done after task switcher is sent to background

    iIgnoreLayoutSwitch = ETrue;

    appui->MoveAppToBackground( CTsAppUi::EActivationTransition, aUid, aWgId );

    iIgnoreLayoutSwitch = EFalse;