/*

* 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 <tstaskswitcher.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknlists.h>

#include <touchfeedback.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include "tsfastswaparea.h"

#include "tsapplogging.h"

#include "tsfswclient.h"

#include "tsappui.h"

#include "tsdatachangeobserver.h"

#include "tseventcontroler.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;

/** Interval until which no change in the fsw content is rendered

    after starting the closing of an application. */

const TInt KRefreshDelayAfterClose = 2; // seconds

/** Uid of Active Idle application. 

    Used when movind Ai to specified position.*/

const TUid KAiUid = TUid::Uid( 0x102750F0 );

/** Position of Ai in fsw grid.*/

const TInt KAiPosition = 0;

/** Default grid item to highlight.*/

const TInt KItemToHighlight = 3;

const TInt KAppKeyTypeShort = 1;

const TInt KAppKeyTypeLong = 2;

const TInt KLayoutItemCount = 4;

const TInt KRedrawTime = 250000; // 0.25 sec

const TInt KHighlighActivationTime = 100000; // 100 ms

const TInt KUpdateGridTime = 1000000; // 1 s

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

// 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),

    iPreviousNoOfItems(0)

    {

    // no implementation required

    }

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

// CTsFastSwapArea::~CTsFastSwapArea

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

//

CTsFastSwapArea::~CTsFastSwapArea()

    {

    iArray.ResetAndDestroy();

    delete iGrid;

    delete iFSClient;

    delete iPopup;

    delete iHighlightTimer;

    delete iRedrawTimer;

    delete iUpdateGridTimer;

    }

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

// CTsFastSwapArea::ConstructL

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

//

void CTsFastSwapArea::ConstructL( const TRect& aRect )

    {

    SetContainerWindowL( iParent );

    SetRect( aRect );

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

    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 );

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

    AknListBoxLayouts::SetupStandardGrid( *iGrid );

    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);

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

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

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

    TAknLayoutScalableParameterLimits gridParams = 

        AknLayoutScalable_Apps::cell_tport_appsw_pane_ParamLimits( variety );

    TPoint empty( ELayoutEmpty, ELayoutEmpty );

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

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

            empty, empty );

    // Setup text layout

    TAknLayoutText textLayout;

    textLayout.LayoutText(

            Rect(),

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

    // Because textLayout.BaselineOffset() does not work (missing lib entry),

    // we need to calculate offset ourselves

    TInt baselineOffset = textLayout.TextRect().iBr.iY - textLayout.TextRect().iTl.iY;

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

                                          textLayout.Font() /*Font type*/,

                                          textLayout.TextRect().iTl.iX /*Left margin*/, 0 /*unused*/,

                                          baselineOffset /*Baseline*/, 0 /*Text width*/,

                                          textLayout.Align() /*Text alignment*/,

                                          TPoint(0,0) /*Start pos*/,

                                          TPoint(0,0) /*End pos*/);

    // Setup grid observers

    if ( obs )

        {

        iGrid->SetObserver( obs );

        }

    iGrid->SetListBoxObserver(this);

    iGrid->SetFastSwapGridObserver(this);

    iGrid->SetContainerWindowL(*this);

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

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

    // Update state

    HandleDeviceStateChanged( EDeviceType );

    if( wasHighlight )

        {

        iGrid->ShowHighlight();

        }

    else

        {

        iGrid->HideHighlight();

        }

    // 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::GetFastSwapAreaRects

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

//

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

    {

    TAknLayoutRect gridAppPane;

    TAknLayoutRect gridItem;

    TAknLayoutRect gridImage;

    TAknLayoutRect gridNextItem;

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

    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);

    }

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

// 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 )

        {

        // Grid needs to be recreated to proper reinitilize

        // data with new layout values

        TInt selIdx = SelectedIndex();

        TRAPD(err, 

              ReCreateGridL();

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

        if ( err != KErrNone )

            {

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

            }

        HandleFswContentChanged();

        iGrid->SetCurrentDataIndex(selIdx);

        UpdateGrid(ETrue, EFalse);

        DrawDeferred();

        }

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

        // Move other app to foreground and then move ourselves to background.

        // Order is important and cannot be reversed.

        iFSClient->SwitchToApp( wgId );

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

        // Therefore ts must be moved to background.

        CTsAppUi* appui =

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

        appui->MoveAppToBackground( AknTransEffect::EApplicationStartRect );

        }

    }

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

// CTsFastSwapArea::TryCloseAppL

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

//

void CTsFastSwapArea::TryCloseAppL( TInt aIndex,

        TBool aSuppressRendering )

    {

    TSLOG_CONTEXT( TryCloseAppL, TSLOG_LOCAL );

    TSLOG2_IN( "%d %d", aIndex, aSuppressRendering );

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

        {

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

        iFSClient->CloseApp( wgId );

        // The fsw content will change sooner or later

        // but the updated content (without the closed app) will not

        // come very fast. It looks better to the user if the item

        // in the grid is removed right here, right now.

        // If the app does not close for some reason then this is

        // not fully correct but the app will then reappear on the next

        // content-changed notification anyway.

        delete iArray[aIndex];

        iArray.Remove( aIndex );

        NotifyChange();

        if ( !aSuppressRendering )

            {

            RenderContentL();

            }

        // Update item selection on the screen if last item was deleted

        TInt newItemCount = GridItemCount();

        if ( aIndex == newItemCount )

            {

            newItemCount--;

            iGrid->SetCurrentDataIndex(newItemCount);

            }

        iTimeOfLastClose.HomeTime();

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapArea::TryCloseAllL

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

//

void CTsFastSwapArea::TryCloseAllL()

    {

    // note the direction of the loop, this is needed because

    // TryCloseAppL may modify the array

    TBool changed = EFalse;

    for ( TInt i = iArray.Count() - 1; i >= 0; --i )

        {

        if ( CanClose( i ) )

            {

            TryCloseAppL( i, ETrue );

            changed = ETrue;

            }

        }

    if ( changed )

        {

        RenderContentL();

        RestoreSelectedIndex();

        iGrid->DrawNow();

        }

    }

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

// CTsFastSwapArea::CanClose

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

//

TBool CTsFastSwapArea::CanClose( TInt aIndex ) const

    {

    CTsFswEntry* e = iArray[aIndex];

    return !e->AlwaysShown() && !e->SystemApp();

    }

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

// CTsFastSwapArea::CanCloseOthers

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

//

TBool CTsFastSwapArea::CanCloseAll( TInt aSelectedItem ) const

    {

    TInt count( 0 );

    // Count number of closable applications and if number exceeds 2 finish

    // counting, because it is already enough to show the option.

    for ( TInt i = iArray.Count(); --i >= 0 && count < KTsMaxClosableApps; )

        {

        if ( CanClose( i ) )

            {

            count++;

            }

        }

    return ( count >= KTsMaxClosableApps ) ||

           ( count && !CanClose( aSelectedItem ) );

    }

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

// CTsFastSwapArea::HandleFswContentChanged

// From MTsFswObserver

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

//

void CTsFastSwapArea::HandleFswContentChanged()

    {

    TSLOG_CONTEXT( HandleFswContentChanged, TSLOG_LOCAL );

    TSLOG_IN();

    TRAPD( err, HandleFswContentChangedL() );

    if ( err != KErrNone )

        {

        TSLOG1( TSLOG_INFO, "leave occured: %d", err );

        }

    TSLOG_OUT();

    }

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

// CTsFastSwapArea::HandleFswContentChangedL

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

//

void CTsFastSwapArea::HandleFswContentChangedL()

    {

    TSLOG_CONTEXT( HandleFswContentChangedL, TSLOG_LOCAL );

    TSLOG_IN();

    // If there was an app close operation started during the last

    // few seconds then stop, to prevent flickering.

    TTime now;

    now.HomeTime();

    TTimeIntervalSeconds iv;

    if ( now.SecondsFrom( iTimeOfLastClose, iv ) == KErrNone

            && iv.Int() <= KRefreshDelayAfterClose )