/*

* 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 <WidgetRegistryConstants.h>

#include <WidgetRegistryData.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(CAknWidgetList) : public CBase

    {

    public:

        static CAknWidgetList* NewL( CAknFastSwapWindowControl& aParent );

        /** Destructor */

        ~CAknWidgetList();

        /**

         * Initializes the list that stores widgets.

         * @return   -

         */        

        void InitializeWidgetListL();

        /**

         * Check if a uid is the uid of the widget application.

         * @param    aAppUid The application uid to be checked.

         * @return   ETrue application uid belongs to widget application - EFalse otherwise.

         */

        TBool IsWidgetAppUI( TUid aAppUid );

        /**

         * Check if the window group id value refers to widget.

         * @param aWgId window group id.

         * @return ETrue if window group id has value that refers to widget.

         */

        TBool IsWidget( TInt aWgId );

        /**

         * Map tasklist application index to application Uid.

         *  

         * @param    aIndex index of tasklist item array.

         * @param    aAlwaysShownCount number of applications that are always shown on

                     the active applications list.

         * @return   application Uid

         */

        TUid IndexToAppUid( TInt aIndex, TInt aAlwaysShownCount );

    private:

        /** Constructor */

        CAknWidgetList( CAknFastSwapWindowControl& aParent );

        void ConstructL();

        void ResetArrayOfWidgetInfo( RWidgetInfoArray& aWidgetInfoArr );

        static void CleanupConnect( TAny* aThis );

    public:

        /** Contains list of widgets that are currently running */

        RWidgetInfoArray iRunningWidgets;

    private:

        CAknFastSwapWindowControl& iParent;

        RWidgetRegistryClientSession iWidgetRegistryClientSession;

    };

CAknWidgetList* CAknWidgetList::NewL( CAknFastSwapWindowControl& aParent )

    {

    _AKNTRACE_FUNC_ENTER;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); //self

    _AKNTRACE_FUNC_EXIT;

    return self;

    }

CAknWidgetList::CAknWidgetList( CAknFastSwapWindowControl& aParent ): iParent( aParent )

    {

    }

CAknWidgetList::~CAknWidgetList()

    {

    _AKNTRACE_FUNC_ENTER;    

    ResetArrayOfWidgetInfo( iRunningWidgets );        

    iRunningWidgets.Reset();

    _AKNTRACE_FUNC_EXIT;

    }

void CAknWidgetList::ConstructL()

    {

    }

void CAknWidgetList::CleanupConnect( TAny* aThis )

    {

    _AKNTRACE_FUNC_ENTER;

     (( CAknWidgetList*)aThis)->iWidgetRegistryClientSession.Disconnect();   

    _AKNTRACE_FUNC_EXIT;

    }

void CAknWidgetList::InitializeWidgetListL()

    {

    _AKNTRACE_FUNC_ENTER;

    ResetArrayOfWidgetInfo( iRunningWidgets );

    iRunningWidgets.Reset();

    User::LeaveIfError( iWidgetRegistryClientSession.Connect() );

    CleanupStack::PushL( TCleanupItem( CleanupConnect, this) );

    iWidgetRegistryClientSession.RunningWidgetsL(iRunningWidgets);

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

        {

        if ( !iWidgetRegistryClientSession.IsWidgetInFullView(iRunningWidgets[i]->iUid) )

            {

            delete iRunningWidgets[i];

            iRunningWidgets.Remove(i);

            }

        }

    CleanupStack::Pop(); // clean WidgetRegistryClientSession item

    iWidgetRegistryClientSession.Disconnect();

    _AKNTRACE_FUNC_EXIT;

    }

TBool CAknWidgetList::IsWidgetAppUI( TUid aAppUid )

    {

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

	           __FUNCTION__, aAppUid.iUid );

    return (aAppUid == KWidgetAppUid);

    }

TBool CAknWidgetList::IsWidget( TInt aWgId )

    {

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

	           __FUNCTION__, aWgId );

    return (aWgId == KWidgetWithoutWG);

    }

TUid CAknWidgetList::IndexToAppUid( TInt aIndex, TInt aAlwaysShownCount )

    {

    _AKNTRACE( "[%s] aIndex = %d aAlwaysShownCount = %d",

    		   __FUNCTION__, aIndex, aAlwaysShownCount );

    return iRunningWidgets[aIndex + iRunningWidgets.Count() + 

        aAlwaysShownCount - iParent.iNumberOfWGs]->iUid;

    }

void CAknWidgetList::ResetArrayOfWidgetInfo( 

    RWidgetInfoArray& aWidgetInfoArr )

    {

    _AKNTRACE_FUNC_ENTER;

    for ( TInt i = 0; i < aWidgetInfoArr.Count(); i++ )

        {

        CWidgetInfo *item = aWidgetInfoArr[i];

        delete item ; 

        }

    _AKNTRACE_FUNC_EXIT;

    }

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.