/*

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

 *  Name        : hgteleportfastswaparea.cpp

 *  Part of     : Hg Teleport

 *  Description : Teleport Fast Swap area UI

 *  Version     : %version: sa1spcx1#74 %

 *

 *  Copyright © 2008 Nokia.  All rights reserved.

 *  This material, including documentation and any related computer

 *  programs, is protected by copyright controlled by Nokia.  All

 *  rights are reserved.  Copying, including reproducing, storing,

 *  adapting or translating, any or all of this material requires the

 *  prior written consent of Nokia.  This material also contains

 *  confidential information which may not be disclosed to others

 *  without the prior written consent of Nokia.

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

 *

 */

#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 <hgteleport.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknlists.h>

#include <touchfeedback.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include "hgteleportfastswaparea.h"

#include "hgteleportapplogging.h"

#include "hgfswclient.h"

#include "hgteleportappui.h"

#include "hgteleportdatachangeobserver.h"

#include "hgteleporteventcontroler.h"

/** command ids for the fsw popup */

enum TPopupCommands

    {

    EFswCmdClose = 10000,

    EFswCmdCloseAll

    };

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

const TInt KHgMaxClosableApps = 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 = 3;

const TInt KRedrawTime = 250000; // 0.25 sec

const TInt KHighlighActivationTime = 100000; // 100 ms

const TInt KUpdateGridTime = 1000000; // 1 s

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

// CHgTeleportFastSwapArea::NewL

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

//

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

    CCoeControl& aParent, CHgTeleportDeviceState& aDeviceState, 

    CHgTeleportEventControler& aEventHandler )

    {

    CHgTeleportFastSwapArea* self = CHgTeleportFastSwapArea::NewLC(aRect,

            aParent, aDeviceState, aEventHandler);

    CleanupStack::Pop( self );

    return self;

    }

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

// CHgTeleportFastSwapArea::NewLC

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

//

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

    CCoeControl& aParent, CHgTeleportDeviceState& aDeviceState,

    CHgTeleportEventControler& aEventHandler)

    {

    CHgTeleportFastSwapArea* self = new (ELeave) CHgTeleportFastSwapArea(

            aParent, aDeviceState, aEventHandler);

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    return self;

    }

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

// CHgTeleportFastSwapArea::CHgTeleportFastSwapArea

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

//

CHgTeleportFastSwapArea::CHgTeleportFastSwapArea(CCoeControl& aParent,

    CHgTeleportDeviceState& aDeviceState,

    CHgTeleportEventControler& aEventHandler) :

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

    iPreviousNoOfItems(0)

    {

    // no implementation required

    }

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

// CHgTeleportFastSwapArea::~CHgTeleportFastSwapArea

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

//

CHgTeleportFastSwapArea::~CHgTeleportFastSwapArea()

    {

    iArray.ResetAndDestroy();

    delete iGrid;

    delete iFSClient;

    delete iPopup;

    delete iConfirmCloseQuery;

    delete iHighlightTimer;

    delete iRedrawTimer;

    delete iUpdateGridTimer;

    }

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

// CHgTeleportFastSwapArea::ConstructL

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

//

void CHgTeleportFastSwapArea::ConstructL( const TRect& aRect )

    {

    SetContainerWindowL( iParent );

    SetRect( aRect );

    // setup ganes grid

    ReCreateGridL();

    // create stylus popup instance

    PreCreatePopupL();

    // connect to fsw server

    iFSClient = CHgFswClient::NewL();

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

    // add self to device state observer

    iDeviceState.AddObserverL( *this, EDeviceType );

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

    iHighlightTimer->ConstructL();

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

    iRedrawTimer->ConstructL();

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

    iUpdateGridTimer->ConstructL();

    ActivateL();

    }

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

// CHgTeleportFastSwapArea::ReCreateGridL

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

//

void CHgTeleportFastSwapArea::ReCreateGridL()

    {

    MCoeControlObserver* obs = NULL;

    TBool wasHighlight = iDeviceState.DeviceType() == 

                             CHgTeleportDeviceState::EHybrid ? ETrue : EFalse;

    if ( iGrid )

        {

        obs = iGrid->Observer();

        iDeviceState.RemoveObserver(*iGrid);

        wasHighlight = iGrid->IsHighlightVisible();

        delete iGrid;

        iGrid = NULL;

        }

    iGrid = new( ELeave ) CHgTeleportFastSwapGrid;

    iGrid->ConstructL( this );

    iDeviceState.AddObserverL(*iGrid, MHgDeviceStateObserver::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];

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

#ifndef TASKSWITCHER_USE_CUSTOM_LAYOUT

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

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

            empty, empty );

#else

    TRect imageRect;

    TRect textRect;

    TInt leftMargin = ( KFswItemWidth - KFswImageSize ) / 2;

    TInt topMargin = ( KFswItemHeight - KFswImageSize - KFswTextHeight ) / 3;

    textRect.iTl = TPoint( leftMargin, topMargin );

    textRect.iBr = TPoint( leftMargin + KFswImageSize, topMargin + KFswTextHeight );

    imageRect.iTl = TPoint( leftMargin, topMargin * 2 + KFswTextHeight );

    imageRect.iBr = TPoint( leftMargin + KFswImageSize, topMargin * 2 + KFswTextHeight + KFswImageSize );

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

                                         imageRect.iTl.iX  /*Left pos*/, imageRect.iTl.iY /*Top pos*/,

                                         0 /*unused*/, 0 /*unused*/,

                                         imageRect.Width() /*Icon width*/,

                                         imageRect.Height() /*Icon height*/,

                                         imageRect.iTl /*Start pos*/,

                                         imageRect.iBr /*End pos*/ );

#endif

    // Setup text layout

    TRgb textColor;

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

            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG9 );

    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

#ifndef TASKSWITCHER_USE_CUSTOM_LAYOUT

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

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

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

                                          textColor.Color16() /*color*/,

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

#else    

    TInt baselineOffset = textRect.iBr.iY - textRect.iTl.iY;

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

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

                                          textColor.Color16() /*color*/,

                                          textRect.iTl.iX /*Left margin*/, 0 /*unused*/,

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

                                          CGraphicsContext::ECenter /*Text alignment*/,

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

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

#endif

    // Setup grid observers

    if ( obs )

        {

        iGrid->SetObserver( obs );

        }

    iGrid->SetListBoxObserver(this);

    iGrid->SetFastSwapGridObserver(this);

    iGrid->SetContainerWindowL(*this);

#ifndef TASKSWITCHER_USE_CUSTOM_LAYOUT

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

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

#else

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

    iGridItemWidth = KFswItemWidth;

#endif

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

    }

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

// CHgTeleportFastSwapArea::GetFastSwapAreaRects

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

//

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

    {

    TAknLayoutRect gridAppPane;

    TAknLayoutRect gridItem;

    TAknLayoutRect gridImage;

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

    }

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

// CHgTeleportFastSwapArea::Setup

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

//

void CHgTeleportFastSwapArea::Setup( MCoeControlObserver& aControlObserver )

    {

    iGrid->SetObserver( &aControlObserver );

    }

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

// CHgTeleportFastSwapArea::SizeChanged

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

//

void CHgTeleportFastSwapArea::SizeChanged()

    {

    HGLOG_CONTEXT( CHgTeleportFastSwapArea::SizeChanged, HGLOG_LOCAL );

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

            {

            HGLOG1( HGLOG_INFO, "ReCreateGridL leaves with %d", err );

            }

        HandleFswContentChanged();

        iGrid->SetCurrentDataIndex(selIdx);

        UpdateGrid(ETrue, EFalse);

        DrawDeferred();

        }

    HGLOG_OUT();

    }

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

// CHgTeleportFastSwapArea::Draw

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

//

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

    {

    CWindowGc& gc = SystemGc();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

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

    AknsDrawUtils::Background( skin,

           cc,

           this,

           gc,

           Rect() );

    }

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

// CHgTeleportFastSwapArea::SwitchToApp

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

//

void CHgTeleportFastSwapArea::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 teleport if the activated app is closed.

        // Therefore teleport must be moved to background.

        CHgTeleportAppUi* appui =

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

        appui->MoveAppToBackground( AknTransEffect::EApplicationStartRect );

        }

    }

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

// CHgTeleportFastSwapArea::TryCloseAppL

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

//

void CHgTeleportFastSwapArea::TryCloseAppL( TInt aIndex,

        TBool aSuppressRendering )

    {

    HGLOG_CONTEXT( TryCloseAppL, HGLOG_LOCAL );

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

        }

    HGLOG_OUT();

    }

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

// CHgTeleportFastSwapArea::TryCloseAppWithQueryL

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

//

void CHgTeleportFastSwapArea::TryCloseAppWithQueryL( TInt aIndex )

    {

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

            && CanClose( aIndex )

            && ConfirmCloseL( aIndex ) )

        {

        TryCloseAppL( aIndex );

        }

    }

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

// CHgTeleportFastSwapArea::TryCloseAllL

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

//

void CHgTeleportFastSwapArea::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();

        }

    }

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

// CHgTeleportFastSwapArea::CanClose

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

//

TBool CHgTeleportFastSwapArea::CanClose( TInt aIndex ) const

    {

    CHgFswEntry* e = iArray[aIndex];

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

    }

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

// CHgTeleportFastSwapArea::CanCloseOthers

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

//

TBool CHgTeleportFastSwapArea::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 < KHgMaxClosableApps; )

        {

        if ( CanClose( i ) )

            {

            count++;

            }

        }

    return ( count >= KHgMaxClosableApps ) ||

           ( count && !CanClose( aSelectedItem ) );

    }

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

// CHgTeleportFastSwapArea::HandleFswContentChanged

// From MHgFswObserver

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

//

void CHgTeleportFastSwapArea::HandleFswContentChanged()

    {

    HGLOG_CONTEXT( HandleFswContentChanged, HGLOG_LOCAL );

    HGLOG_IN();

    TRAPD( err, HandleFswContentChangedL() );

    if ( err != KErrNone )

        {

        HGLOG1( HGLOG_INFO, "leave occured: %d", err );

        }