/*

* 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 "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 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 KMaxGranularity = 4;

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

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

    {

    // no implementation required

    }

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

// CTsFastSwapArea::~CTsFastSwapArea

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

//

CTsFastSwapArea::~CTsFastSwapArea()

    {

    iArray.ResetAndDestroy();

    delete iGrid;

    delete iFSClient;

    delete iPopup;

    delete iHighlightTimer;

    delete iRedrawTimer;

    delete iUpdateGridTimer;

    delete iOrientationSignalTimer;

    }

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

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

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

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

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

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

    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,

    TRgb highlightTextColor;

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

            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG11 );

    CFormattedCellListBoxData::TColors colors;

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

    colors.iHighlightedText = highlightTextColor;

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

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

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

    // 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 && !iIgnoreLayoutSwitch )

        {

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

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

        // 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. Ignore orientation updates, it

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

        iIgnoreLayoutSwitch = ETrue;

        CTsAppUi* appui =

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

        appui->MoveAppToBackground( CTsAppUi::EActivationTransition );

        iIgnoreLayoutSwitch = EFalse;

        // Orientation update

        iPrevScreenOrientation = -1; // force orientation reinit

        iOrientationSignalTimer->Cancel();

        iOrientationSignalTimer->After(KOrientationSwitchTime);

        }

    }

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

// 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 selIdx = SelectedIndex();

        if ( selIdx > aIndex && selIdx > 0 )

            {

            selIdx--;

            }

        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 ( aIndex == newItemCount )

            {

            newItemCount--;

            iGrid->SetCurrentDataIndex(newItemCount);

            }

        else

            {

            iGrid->SetCurrentDataIndex(selIdx);

            }

        // Orientation update

        iPrevScreenOrientation = GetCurrentScreenOrientation();

        iOrientationSignalTimer->Cancel();

        iOrientationSignalTimer->After(KOrientationSwitchTime);

        }

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

        }

    }

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

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

    }