/*

* Copyright (c) 2002-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:  Control container for fastswap.

*

*/

// INCLUDE FILES

#include <gulicon.h>

#include <eikbtgpc.h>

#include <eikmop.h>

#include <AknQueryDialog.h>

#include <eiksrvui.rsg>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#include <avkon.mbg>

#include <AknsFrameBackgroundControlContext.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknIconUtils.h>

#include <eikfrlbd.h>

#include <apgwgnam.h>

#include <AknInfoPopupNoteController.h> // tooltip

#include <AknBidiTextUtils.h> // method ConvertToVisualAndClipL

#include <skinlayout.cdl.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include <featmgr.h>

#include <aknglobalpopupprioritycontroller.h>

#include <centralrepository.h>

#include <AknTasHook.h>

#include <touchfeedback.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

#include <aknmemorycardui.rsg>

#include <aknlongtapanimation.h>

#include <aknstyluspopupmenu.h>

#include <aknpointereventsuppressor.h>

#include <pslninternalcrkeys.h>

#include <AknStatuspaneUtils.h>

#include "AknFastswapWindowControl.h"

#include "AknFastswapWindowGrid.h"

#include "AknCapServerEntry.h"

#include "akntrace.h"

void InvalidateWindows( CCoeControl* aControl )

    {

    if ( aControl )

        {

        if ( aControl->OwnsWindow() )

            {

            ( (RWindow*) aControl->DrawableWindow() )->ClearRedrawStore();

            }

        for ( TInt i = aControl->CountComponentControls() - 1; i >= 0; --i )

            {

            InvalidateWindows( aControl->ComponentControl( i ) );

            }

        }

    }

const TInt KFSWArrayGranularity = 4;

const TInt KMinimumSupportedApps = 20;

const TBool KVerticalOrientation = EFalse;

const TBool KLeftToRight = ETrue;

const TBool KRightToLeft = EFalse;

const TBool KTopToBottom = ETrue;

const TInt KTooltipTimeBefore = 600;

const TInt KTooltipTimeView = 1500;

// Values for touch mode tooltip.

const TInt KTooltipTimeBeforeTouch = 0;  

const TInt KTooltipTimeViewTouch = 0; // Shown until canceled

// Always shown applications spesified in the ui specs.

const TInt KAlwaysShownAppCount = 3;

const TUid KMenuAppUid  = {0x101F4CD2};

const TUid KSearchAppUid  = {0x0EFC346A};

// new idle from 3.2 onwards, old idle uid is 0x101FD64C

const TUid KIdleAppUid  = {0x102750F0}; 

const TInt KApplicationWithoutWG = KErrNotFound;

const TInt KWidgetWithoutWG = KErrGeneral;

// Uid of the Widget application.

const TUid KWidgetAppUid  = {0x10282822};

// Matrix Menu P&S category 

const TUid KFSWMMenuPSCat = {0x101F4CD2};

// Key that stores last used - current view (it is text value)

const TUint KFSWMMenuLastViewKey = 0x01;

// name of folder view

_LIT(KFSWMMenuFolderView, "foldersuite");

const TInt KTimeDelayBeforeAnimation = 200000;  // 0.2 seconds

const TInt KLongTapDelay = 800000;  // 0.8 seconds

const TInt KTimeNeverHappenEvent = 100000000; // 100 seconds 

const TInt KPressedDownEffectTime = 500000;//0.5 seconds

enum TAknCapServerCommands

    {

    EAknCapServerCmdOpen = 0x6100, 

    EAknCapServerCmdClose      

    };

NONSHARABLE_CLASS(CAknFastSwapData) : public CBase, 

                                      public MAknTransitionUtilsObserver

  {

  public:

      CAknFastSwapData(TInt aKey, CAknInfoPopupNoteController* aTooltip);

  private:

      TInt AknTransitionCallback(TInt aEvent, TInt aState = 0,

                                 const TDesC8* aParams = NULL);

  private:

      CAknInfoPopupNoteController* iTooltip;

      TInt iKey;

  };

CAknFastSwapData::CAknFastSwapData( TInt aKey, 

                                    CAknInfoPopupNoteController* aTooltip )

    : iTooltip( aTooltip ), iKey( aKey )

    {

    }

TInt CAknFastSwapData::AknTransitionCallback(TInt aEvent, TInt /*aState*/,

                                             const TDesC8* /*aParams*/)

    {

    _AKNTRACE_FUNC_ENTER; 

    iTooltip->ShowInfoPopupNote();

    CAknTransitionUtils::RemoveObserver( this, aEvent );

    _AKNTRACE_FUNC_EXIT; 

    return KErrNone;

    }

NONSHARABLE_CLASS(CAknAlwaysShownAppList) : public CBase

    {

    public:

       // always shown application info  

       // used in the always shown application list

       struct SAlwaysShownAppInfo

            {

            TUid iAppUid;

            TInt iWgId;

            };    

    public:

        static CAknAlwaysShownAppList* NewL( CAknFastSwapWindowControl& aParent );

        CAknAlwaysShownAppList( CAknFastSwapWindowControl& aParent );

        ~CAknAlwaysShownAppList();

        /**

        * Initializes the list that stores applications that are always 

        * shown in the fast swap provided they have been installed

        * in the phone rom

        * @return   -

        */        

        void InitializeAlwaysShownListL();

        /**

        * Add window group id to spesific appication (=uid)

        * @return   -    

        * @param    TUid aAppUid the application uid      

        * @param    TInt aWgId the window group where task resides 

        */        

        void AddWgGroupToAlwaysShownList( TUid aAppUid, TInt aWgId ); 

        /**

        * If application uid exists in the always shown application list 

        * @return   ETrue  application uid exists in the list

        *           EFalse application uid doesn't exist in the list

        * @param    TUid aAppUid the application uid

        */        

        TBool IsAlwaysShownApp( TUid aAppUid );

        /**

        * If application window group exists in the always shown application list 

        * @return   ETrue  wg exists in the list

        *           EFalse wg doesn't exist in the list

        * @param    TInt aWgId the application window group      

        */        

        TBool IsAlwaysShownApp( TInt aWgId );

        /**

        *

        * Map Tasklist application index to application Uid

        * @return   TUid application Uid

        *  

        * @param    TInt aIndex index of tasklist item arrays

        */ 

        TUid IndexToAppUid( TInt aIndex );

    public:

        RArray<SAlwaysShownAppInfo>* iAppList;

    private:

        void ConstructL();

    private:

        // the list of applications always shown in the fsw

        CAknFastSwapWindowControl& iParent;

    };

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

// CAknFastSwapWindowControl::NewL

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

//  

CAknAlwaysShownAppList* CAknAlwaysShownAppList::NewL( CAknFastSwapWindowControl& aParent )

    {

    _AKNTRACE_FUNC_ENTER;    

    CAknAlwaysShownAppList* self = new (ELeave) CAknAlwaysShownAppList( aParent );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); //self

    _AKNTRACE_FUNC_EXIT;    

    return self;

    }

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

// CAknFastSwapWindowControl::CAknAlwaysShownAppList

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

//  

CAknAlwaysShownAppList::CAknAlwaysShownAppList( CAknFastSwapWindowControl& aParent )

: iParent( aParent )

    {

    }

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

// CAknFastSwapWindowControl::~CAknAlwaysShownAppList

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

//

CAknAlwaysShownAppList::~CAknAlwaysShownAppList()

    {

    _AKNTRACE_FUNC_ENTER;

    if (iAppList)

        {

        iAppList->Close();

        }

    delete iAppList;

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknFastSwapWindowControl::ConstructL

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

//

void CAknAlwaysShownAppList::ConstructL()

    {

    // the list for always shown applications in the fast swap

    iAppList = new (ELeave) RArray<SAlwaysShownAppInfo>();    

    }

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

// CAknFastSwapWindowControl::InitializeAlwaysShownListL

// Applications that are always shown in fast swap are stored 

// in different their own list whether they exist

// in the phone rom or not

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

//

void CAknAlwaysShownAppList::InitializeAlwaysShownListL()

    {

    _AKNTRACE_FUNC_ENTER;

    iAppList->Close();

    // order of always shown applications

    TUid uidArray[] = {KMenuAppUid, KSearchAppUid, KIdleAppUid};

    TApaAppInfo applicationInfo;

    SAlwaysShownAppInfo fixedAppInfo;

    for ( TInt index = 0; index < KAlwaysShownAppCount; index++)

        {

        // if exists in phone rom

        if (  iParent.iAppArcSession.GetAppInfo(applicationInfo, uidArray[index]) != KErrNotFound )

            {

            fixedAppInfo.iAppUid = uidArray[index];

            // list is created without known window groups

            fixedAppInfo.iWgId = KApplicationWithoutWG;

            iAppList->AppendL( fixedAppInfo );

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknFastSwapWindowControl::AddWgGroupToAlwaysShownList

// The window groups are stored with the application uids

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

//

void CAknAlwaysShownAppList::AddWgGroupToAlwaysShownList( TUid aAppUid, TInt aWgId )

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aAppUid = %d aWgId = %d", 

    		   __FUNCTION__, aAppUid.iUid, aWgId );

    for ( TInt index = 0; index < iAppList->Count(); index++)

        {

        if ( (*iAppList)[index].iAppUid == aAppUid )

            {

            (*iAppList)[index].iWgId = aWgId;

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknFastSwapWindowControl::IsAlwaysShownApp

// If application uid exists in the always shown application list 

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

//

TBool CAknAlwaysShownAppList::IsAlwaysShownApp( TUid aAppUid )

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aAppUid = %d", __FUNCTION__, aAppUid.iUid );

    for ( TInt index = 0; index < iAppList->Count(); index++)

        {

        if ( (*iAppList)[index].iAppUid == aAppUid )

            {

            _AKNTRACE_FUNC_EXIT;

            return ETrue;

            }

        }

    _AKNTRACE_FUNC_EXIT;

    return EFalse;

    }

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

// CAknFastSwapWindowControl::IsAlwaysShownApp

// If application window group exists in the always shown application list 

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

//

TBool CAknAlwaysShownAppList::IsAlwaysShownApp( TInt aWgId )

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aWgId = %d", __FUNCTION__, aWgId );

    for ( TInt index = 0; index < iAppList->Count(); index++)

        {

        if ( (*iAppList)[index].iWgId == aWgId )

            {

            _AKNTRACE_FUNC_EXIT;

            return ETrue;

            }

        }

    _AKNTRACE_FUNC_EXIT;

    return EFalse;

    }

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

// CAknFastSwapWindowControl::IndexToAppUid

// Map Tasklist application index to application Uid

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

//

TUid CAknAlwaysShownAppList::IndexToAppUid( TInt aIndex )

    {

    _AKNTRACE( "[%s] aIndex = %d", __FUNCTION__, aIndex );

    return (*iAppList)[aIndex + iAppList->Count() - iParent.iNumberOfWGs].iAppUid;

    }

CAknGridView::TScrollingType KVerticalScrollingType = CAknGridView::EScrollFollowsItemsAndLoops;

CAknGridView::TScrollingType KHorizontalScrollingType = CAknGridView::EScrollFollowsItemsAndLoops;

_LIT(KTab,"\t");

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CAknFastSwapWindowControl::CAknFastSwapWindowControl(CAknCapAppServerAppUi& aAppUi)

  iIsStylusPopupShow(EFalse), iState( EWaiting )

    { 

    AKNTASHOOK_ADD( this, "CAknFastSwapWindowControl" );

    }

// Symbian OS default constructor can leave.

void CAknFastSwapWindowControl::ConstructL()

    {

    _AKNTRACE_FUNC_ENTER; 

    GfxTransEffect::Enable();

    CreateWindowL();

    SetComponentsToInheritVisibility();

    Window().SetShadowDisabled( ETrue );

    Window().SetPointerGrab( ETrue );

    SetGloballyCapturing( ETrue );

    if( iTransparencyEnabled )

        {

        Window().SetRequiredDisplayMode( EColor16MA );

        TInt err = Window().SetTransparencyAlphaChannel();

        if ( err == KErrNone )

            {

            Window().SetBackgroundColor(~0);

            }

        }

    CreateCbaL();

    CreateGridL();

    CreateItemArraysL();

    CreateTooltipL();

    CreateLabelL();

    UpdateHeadingIconL();

    //create animation

    iLongTapAnimation = CAknLongTapAnimation::NewL( EFalse );

    iThemesAppRepository = CRepository::NewL( KCRUidThemes );

    //create TimeOut

    iTimeOut = CPeriodic::NewL(CActive::EPriorityStandard); 

    iToolTipTimer = CPeriodic::NewL(CActive::EPriorityStandard); 

    CreateComponentArrayL();

    // create control context

    TRect nullRect( 0, 0 , 0, 0 );

    iFrameContext = CAknsFrameBackgroundControlContext::NewL(

        KAknsIIDQsnFrPopup, nullRect, nullRect, EFalse);

    // the list for always shown applications in the fast swap

    iAlwaysShownList = CAknAlwaysShownAppList::NewL( *this );

    MakeVisible( EFalse );

    _AKNTRACE_FUNC_EXIT; 

    }

// Destructor

CAknFastSwapWindowControl::~CAknFastSwapWindowControl()

    {

    _AKNTRACE_FUNC_ENTER;

    AKNTASHOOK_REMOVE();

    AknGlobalPopupPriorityController::RemovePopupPriority(*this);

    GfxTransEffect::Deregister( this );

    iAppArcSession.Close();

    ClearItemArrays( ETrue ); 

    if ( iGrid )

        {

        AknsUtils::DeregisterControlPosition( iGrid );

        }

    delete iAlwaysShownList;

    FadeBackground( EFalse );

    delete iFrameContext;

    delete iGrid; // destroys also iIconArray and scrollbar frame

    delete iShownWgIds;

    if ( iAllWgIds )

        {

        iAllWgIds->Close();

        }

    CAknFastSwapData *data = 

        (CAknFastSwapData*)CAknTransitionUtils::GetData( (TInt)this );

    if ( data )

        {

        CAknTransitionUtils::RemoveObserver( data,

            CAknTransitionUtils::EEventControlTransitionFinished );

        CAknTransitionUtils::RemoveData( (TInt)this );

        delete data;

        }

    delete iItemTextArray;

    delete iAllWgIds;

    delete iDefaultAppIcon;

    delete iCba;

    delete iConfirmCloseDialog;

    delete iHeadingIcon;

    delete iTooltip;

    delete iLabel;

    delete iPopupMenu;

    delete iLongTapAnimation;

    delete iTimeOut;

    delete iToolTipTimer;

    delete iThemesAppRepository;

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknFastSwapWindowControl::RunFastSwapL

// Function that is called from CEikServAppUi to launch

// task switching. Updates all relevant data (see more detailed

// description from the functions called) and brings the

// window to foreground

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

//

void CAknFastSwapWindowControl::RunFastSwapL()

    {

    _AKNTRACE_FUNC_ENTER;

    if ( iIsDisplayed )

        {

        _AKNTRACE_FUNC_EXIT;

        return;

        }

    TInt effectValue( 0 );

    iThemesAppRepository->Get( KThemesTransitionEffects, effectValue );

    if ( effectValue == 0 )     /* TAT on */

        {

        MTouchFeedback* feedback = MTouchFeedback::Instance();

        if ( feedback )

            {

            feedback->InstantFeedback( ETouchFeedbackPopupOpen );

            }

        }

    GfxTransEffect::Register( this, KGfxTaskSwapperControlUid, EFalse );

    GfxTransEffect::Abort();

    TPoint dPoint( iGrid->PositionRelativeToScreen() );

    TRect dRect( iGrid->Rect() );

    dRect.Move( dPoint );