/*

* Copyright (c) 2008-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:    ALFTK utilities

*

*/

// INCLUDE FILES

// Class header

// USER INCLUDE FILES

#include "glxuiutility.h"

#include "glxscreenfurniture.h"

#include "glxskinchangemonitor.h"

// SYSTEM INCLUDE FILES

#include <aknappui.h>

#include <AknUtils.h>

#include <alf/alfcontrolgroup.h>

#include <alf/alfdisplay.h>

#include <alf/alfutil.h>

#include <alf/alfenv.h>

#include <alf/alftexture.h>

#include <alf/alftextstyle.h> 

#include <alf/alftextstylemanager.h>

#include <featmgr.h>

#include <bldvariant.hrh>   // For feature constants

#include <eikenv.h> 

#include <eikappui.h>

#include <aknclearer.h>

// Internal incudes

#include <glxresolutionmanager.h>       // for CGlxResolutionManager

#include <glxsingletonstore.h>      

#include <glxpanic.h>

#include <glxassert.h>                  // for GLX_ASSERT_DEBUG

#include <glxtvconstants.h>             // for ETvConnectionChanged

#include <glxtv.h>                      // for CGlxTv

#include <glxthumbnail.h>

#include <glxsettingsmodel.h>

#include <glxsingletonstore.h>

#include <glxtexturemanager.h>

#include <glxtracer.h>

#include <e32property.h>

//For animation Effects

#include <akntranseffect.h>

#include <akntransitionutils.h>

//Publish-Subscribe from Thumbnail manager

const TUid KTAGDPSNotification = { 0x2001FD51 }; //PS category 

const TInt KForceBackgroundGeneration = 0x00000010; //PS Key 

const TInt KItemsleft = 0x00000008; //PS key value

/**

 * Start Delay for the periodic timer, in microseconds

 */

const TInt KPeriodicStartDelay = 1000000; 

const TInt KIgnoreItemsLeftCount = 5;

//Hg 

//#include <hg/hgcontextutility.h>

// TV size constants

using namespace glxTvOut;

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

// UtilityL

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

//

EXPORT_C CGlxUiUtility* CGlxUiUtility::UtilityL()

	{

	TRACER("CGlxUiUtility::UtilityL()");

	return CGlxSingletonStore::InstanceL(&NewL);

	}

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

// Close

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

//

EXPORT_C void CGlxUiUtility::Close()

	{

	TRACER("CGlxUiUtility::Close()");

    CGlxSingletonStore::Close(this);

	}

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

// 2-phase constructor

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

//

CGlxUiUtility* CGlxUiUtility::NewL() 

    {

    TRACER("CGlxUiUtility::NewL()");

	CGlxUiUtility* obj = new (ELeave) CGlxUiUtility();

	CleanupStack::PushL(obj);

	obj->ConstructL();

	CleanupStack::Pop(obj);

    return obj;

    }

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

// Constructor

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

//

CGlxUiUtility::CGlxUiUtility()

:   iEnv(NULL),iNavigationDirection( EGlxNavigationForwards ),

    iOrientation( EGlxOrientationUninitialised )

    {

    TRACER("CGlxUiUtility::CGlxUiUtility()");

    iAppUi = CCoeEnv::Static()->AppUi();

    }

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

// ConstructL

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

//

void CGlxUiUtility::ConstructL()

    {

    TRACER("CGlxUiUtility::ConstructL()");

    iSettingsModel = CGlxSettingsModel::InstanceL();

    iOrientation = EGlxOrientationDefault; // Always start in default orientation

    if (!iPeriodic)

        {

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

        }

    if (!iPeriodic->IsActive())

        {

        iPeriodic->Start(KPeriodicStartDelay, KMaxTInt,

                TCallBack(&PeriodicCallback, static_cast<TAny*> (this)));

        }

    GridIconSizeL();

    iScreenFurniture = CGlxScreenFurniture::NewL(*this);

    }

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

// Callback from periodic timer

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

//

TInt CGlxUiUtility::PeriodicCallback(TAny* aPtr )

    {

    TRACER("CGlxUiUtility::PeriodicCallback");

    static_cast< CGlxUiUtility* >( aPtr )->CreateAlfEnvCallbackL();

    return KErrNone;

    }

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

// Callback from periodic timer-- non static

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

//

void CGlxUiUtility::CreateAlfEnvCallbackL()

    {

    TRACER("CGlxUiUtility::CreateAlfEnvCallbackL");

    CreateAlfEnvL();

    }

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

// Create ALF env

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

//

void CGlxUiUtility::CreateAlfEnvL()

    {

    TRACER("CGlxUiUtility::CreateAlfEnvL");

    if (iPeriodic->IsActive())

        {

        iPeriodic->Cancel();

        }

    iEnv = CAlfEnv::Static();

    if (!iEnv)

       {

       iEnv = CAlfEnv::NewL();

       }

    else

       {

       iShared = ETrue;

       }

    iGlxTextureManager = CGlxTextureManager::NewL(iEnv->TextureManager());

    //Skin change observer

    iGlxSkinChangeMonitor = CGlxSkinChangeMonitor::NewL();

    iAppUi->AddToStackL(iGlxSkinChangeMonitor);

    // Add TextureManager as a skin change event observer here itself because

    // calling CGlxHuiUtility::Utility() in CGlxTextureManager creates a recursive call

    // to CGlxTextureManager::NewL which again calls CGlxHuiUtility::Utility() and so on.

    AddSkinChangeObserverL( *iGlxTextureManager );    

    TRect rect;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, rect ); 

    iAlfDisplay = &iEnv->NewDisplayL(rect,

            CAlfEnv::ENewDisplayAsCoeControl | CAlfEnv::ENewDisplayFullScreen );

     iEnv->AddActionObserverL (this);

    // create the resoltuion manager - needs to be informed when screen size 

    // changes

    iGlxResolutionManager = CGlxResolutionManager::NewL();

    iGlxTvOut = CGlxTv::NewL(*this);

    // Is the TV Out display on

    // Note that this also sets the initial size for the resolution manager

    HandleTvStatusChangedL( ETvConnectionChanged );

    }

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

// Destructor

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

//

CGlxUiUtility::~CGlxUiUtility()

    {

    TRACER("CGlxUiUtility::~CGlxUiUtility()");

    GLX_LOG_INFO("~CGlxUiUtility");

    if(iClearer)

        {

        delete iClearer;

        }

    if(iScreenFurniture)

        {

        delete iScreenFurniture;

        }

    if(iGlxTvOut)

        {

        // Destroy TV Out related objects

        delete iGlxTvOut;

        }

    if(iGlxResolutionManager)

        {

        delete iGlxResolutionManager;

        }

    DestroyTvOutDisplay();

	if( iGlxTextureManager )

		{

	    RemoveSkinChangeObserver( *iGlxTextureManager ); 

	    delete iGlxTextureManager;   	

		}

    if(iAlfDisplay)

        {

        delete iAlfDisplay;

        }

    if(iEnv)

       {

       iEnv->RemoveActionObserver(this);

       }

    if ( iGlxSkinChangeMonitor )

        {

        iAppUi->RemoveFromStack(iGlxSkinChangeMonitor);

        delete iGlxSkinChangeMonitor;

        }

    if (!iShared)

        {

        delete iEnv;

        }

    iTextStyles.Close();

    if ( iSettingsModel )

        {

        iSettingsModel->Close();

        }    

	if (iPeriodic)

        {

        iPeriodic->Cancel();

        delete iPeriodic;

        }

    }

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

// Env

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

//

EXPORT_C CAlfEnv* CGlxUiUtility::Env()

	{

	TRACER("CGlxUiUtility::EnvL()");

	if(!iEnv)

	    {

        TRAP_IGNORE(CreateAlfEnvL());

	    }

	return iEnv;

	}

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

// Display

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

//

EXPORT_C CAlfDisplay* CGlxUiUtility::Display() const

	{

	TRACER("CGlxUiUtility::Display()");

	return iAlfDisplay;

	}

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

// ShowAlfDisplay

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

EXPORT_C void CGlxUiUtility::ShowAlfDisplayL()

	{

	TRACER("CGlxUiUtility::ShowAlfDisplayL()");

	// make it visible as well

	CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    CCoeControl* contl =

            (CCoeControl*) uiUtility->Display()->ObjectProvider();

    contl->MakeVisible(ETrue);

	uiUtility->Close();

	// no need to do anything else, the coecontrol handles the visibility

	}

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

// HideAlfDisplay

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

EXPORT_C void CGlxUiUtility::HideAlfDisplayL()

	{

	TRACER("CGlxUiUtility::HideAlfDisplayL()");

	// make it invisible as well (this might be all that is needed)

	CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    CCoeControl* contl =

            (CCoeControl*) uiUtility->Display()->ObjectProvider();

	contl->MakeVisible (EFalse);

	uiUtility->Close();

	// no need to do anything else, the coecontrol handles the visibility

	}

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

// GlxTextureManager

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

//

EXPORT_C CGlxTextureManager& CGlxUiUtility::GlxTextureManager()

	{

	TRACER("CGlxUiUtility::GlxTextureManager()");

	__ASSERT_ALWAYS(iGlxTextureManager, Panic(EGlxPanicLogicError));

    return *iGlxTextureManager;

	}

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

// ViewNavigationDirection

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

//

EXPORT_C TGlxNavigationDirection CGlxUiUtility::ViewNavigationDirection()

    {

    TRACER("CGlxUiUtility::ViewNavigationDirection()");

    return iNavigationDirection;

    }

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

// SetViewNavigationDirection

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

//

EXPORT_C void CGlxUiUtility::SetViewNavigationDirection(

        TGlxNavigationDirection aDirection)

    {

    TRACER("CGlxUiUtility::SetViewNavigationDirection()");

    iNavigationDirection = aDirection;

    }

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

// DisplaySize

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

//

EXPORT_C TSize CGlxUiUtility::DisplaySize() const

    {

    TRACER("CGlxUiUtility::DisplaySize()");

    const TRect& rect = CEikonEnv::Static()->EikAppUi()->ApplicationRect();

	return rect.Size();

    }

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

// TextStyleIdL

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

//

EXPORT_C TInt CGlxUiUtility::TextStyleIdL(TInt aFontId, TInt aSizeInPixels)

    {

    TRACER("CGlxUiUtility::TextStyleIdL()");

    TInt id = 0;

    TBool found = EFalse;

    TInt index = 0;

    TInt count = iTextStyles.Count();

    // Look for existing style with this font and size

    while(index < count && !found)

        {

        if(iTextStyles[index].iSizeInPixels == aSizeInPixels &&

           iTextStyles[index].iFontId == aFontId)

            {

            // found it. Prepare to return found id

            id = iTextStyles[index].iStyleId;

            found = ETrue;

            }

        else

            {

            // check next style

            index++;

            }

        }

    if(!found)

        {

        // Create a new style based on the required font

        CAlfTextStyleManager& styleMan = iEnv->TextStyleManager();

        // remember its id for return later

        id = styleMan.CreatePlatformTextStyleL(aFontId);

        // Get style. It is not owned

        CAlfTextStyle* style = styleMan.TextStyle(id);

        // Set this style to have required size and to be normal weight

        style->SetTextSizeInPixels(aSizeInPixels);

        style->SetBold(EFalse);

        // Add this style to list

        TGlxTextStyle textStyle(aFontId, aSizeInPixels, id);

        iTextStyles.AppendL(textStyle);

        }

    return id;

    }

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

// SetAppOrientationL

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

//

EXPORT_C void CGlxUiUtility::SetAppOrientationL(TGlxOrientation aOrientation)

    {

    TRACER("CGlxUiUtility::SetAppOrientationL()");

    GLX_LOG_INFO1( "CGlxUiUtility::SetAppOrientationL(%d)", aOrientation );

    if ( iOrientation != aOrientation )

        {

        CAknAppUiBase::TAppUiOrientation orientation(

                                CAknAppUiBase::EAppUiOrientationUnspecified);

        switch ( aOrientation )

            {

            case EGlxOrientationTextEntry:

                if ( iSettingsModel->IsTextEntryPortrait() )

                    {

                    orientation = CAknAppUiBase::EAppUiOrientationPortrait;

                    break;

                    }

                // else fall through to EGlxOrientationDefault

            case EGlxOrientationDefault:

                {

                if ( CGlxSettingsModel::ELandscape

                        == iSettingsModel->SupportedOrientations() )

                    {

                    orientation = CAknAppUiBase::EAppUiOrientationLandscape;

                    }

                else

                    {

                    orientation = CAknAppUiBase::EAppUiOrientationAutomatic;

                    }

                }

                break;

            case EGlxOrientationLandscape:

                orientation = CAknAppUiBase::EAppUiOrientationLandscape;

                break;

            default:

                Panic(EGlxPanicIllegalArgument);

                break;

            }

        static_cast<CAknAppUiBase*>(iAppUi)->SetOrientationL(orientation);

        iOrientation = aOrientation;

        }

    }

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

// AppOrientation

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

//

EXPORT_C TGlxOrientation CGlxUiUtility::AppOrientation() const

    {

    TRACER("CGlxUiUtility::AppOrientation()");

    return iOrientation;

    }

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

// GetGridIconSize

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

//  

EXPORT_C TSize CGlxUiUtility::GetGridIconSize()

    {

	 TRACER("CGlxUiUtility::GetGridIconSize()");

    return iGridIconSize;

    }    

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