photosgallery/viewframework/uiutilities/src/glxuiutility.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Thu, 15 Jul 2010 18:39:01 +0300
branchRCL_3
changeset 56 b023a8d2866a
parent 35 420f6808bf21
child 57 ea65f74e6de4
permissions -rw-r--r--
Revision: 201025 Kit: 2010127

/*
* 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>
#include <avkondomainpskeys.h> // Keyguard Status
// 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;
    }    

// -----------------------------------------------------------------------------
// SetGridToolBar
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::SetGridToolBar(CAknToolbar* aToolbar)
    {
    TRACER("CGlxUiUtility::SetGridToolBar()");
    iToolbar = aToolbar;
    }

// -----------------------------------------------------------------------------
// GetGridToolBar
// -----------------------------------------------------------------------------
//
EXPORT_C CAknToolbar* CGlxUiUtility::GetGridToolBar()
    {
    TRACER("CGlxUiUtility::GetGridToolBar()");
    if(iToolbar)
        {
        return iToolbar;
        }
    return NULL;     
    }

// -----------------------------------------------------------------------------
// HandleTvStatusChangedL
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::HandleTvStatusChangedL( TTvChangeType aChangeType )
    {
    TRACER("CGlxUiUtility::HandleTvStatusChangedL()");

    if (aChangeType == ETvDisplayNotVisible) // Visibility event
        {
        iEnv->Release();
        return; // don't redraw the display
        }
    else if (aChangeType == ETvDisplayIsVisible) // Visibility event
        {
        iEnv->RestoreL();
        }
    else // TV Connection event
        {
        GLX_ASSERT_DEBUG( (aChangeType == ETvConnectionChanged),
                Panic( EGlxPanicLogicError ),
                "Expected TV Connection Changed" );

        if ( iGlxTvOut->IsConnected() )
            {
            // Remove the TV Diplay - a ETvConnectionChanged may result from
            // the user changing the central repository TV values.
            DestroyTvOutDisplay();
            CreateTvOutDisplayL();
            }
        else
            {
            DestroyTvOutDisplay();
            // Set the display size to that of the phone
            iGlxResolutionManager->SetScreenSizeL( DisplaySize() );
            }
        }
        
    if (iTvDisplay)
        {
        iTvDisplay->SetDirty(); // redraw
        }        
    }
    
// -----------------------------------------------------------------------------
// SetRotatedImageSize
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::SetRotatedImageSize(TSize aRotatedImageSize)
    {
    iRotatedImageSize = aRotatedImageSize;
    }

// -----------------------------------------------------------------------------
// SetRotatedImageSize
// -----------------------------------------------------------------------------
//
EXPORT_C TSize CGlxUiUtility::GetRotatedImageSize()
    {
    return iRotatedImageSize;
    }

void  CGlxUiUtility::HandleActionL (const TAlfActionCommand &aActionCommand) 
    {
    TRACER("CGlxUiUtility::HandleActionL()");
   	
   	if(aActionCommand.Id() == KAlfActionIdDeviceLayoutChanged  )
   	    {   	  
    	// check if tv-out is connected
        if ( iGlxTvOut->IsConnected() )
            {
        	// The primary (phone) display has changed orientation
        	DestroyTvOutDisplay();
            CreateTvOutDisplayL(); //@ will generate false positive in codescanner
            }
        else
            {
            // reset the screen size in case the orientation changed for example
            iGlxResolutionManager->SetScreenSizeL( DisplaySize() );
            }
   	    }
    }
  
// -----------------------------------------------------------------------------
// DestroyTvOutDisplay
// -----------------------------------------------------------------------------
//
void CGlxUiUtility::DestroyTvOutDisplay()
    {
    TRACER("CGlxUiUtility::DestroyTvOutDisplay()");
    if (iTvDisplay)
        {
        delete iTvDisplay;
        iTvDisplay = NULL; 

        iEnv->PauseRefresh();

        // Disable Primary Window Visibility events
        CCoeControl* contl =
                (CCoeControl*) iEnv->PrimaryDisplay().ObjectProvider();
        contl->DrawableWindow()->DisableVisibilityChangeEvents();
        }
    }
       
        
// -----------------------------------------------------------------------------
// CreateTvOutDisplayL
// -----------------------------------------------------------------------------
//
void CGlxUiUtility::CreateTvOutDisplayL()
	{
	TRACER("CGlxUiUtility::CreateTvOutDisplayL()");
	
	// Get the TV Out display size buffer in pixels
    TSize tvOutDisplaySz = iGlxTvOut->ScreenSizeL();
    
    // Calculate the TV Out buffer by using
    // A) aspect ratio that matches the phone screen and 
    // B) size that fills the TV so that either width or height of TV is fully  
    //             used (in practice height is always restricting dimension). 
    TSize phoneDisplaySz   = DisplaySize();
  
    // Scale the tv display size to match that of the phone display size
    tvOutDisplaySz = TSize (tvOutDisplaySz.iHeight * phoneDisplaySz.iWidth 
                          / phoneDisplaySz.iHeight, tvOutDisplaySz.iHeight );
    const TRect tvOutDisplayBuffer( tvOutDisplaySz );
 
	// Set the TV screen size    
    iGlxResolutionManager->SetScreenSizeL( tvOutDisplaySz );   
	}

// -----------------------------------------------------------------------------
// AddSkinChangeObserverL
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::AddSkinChangeObserverL(
        MGlxSkinChangeObserver& aObserver)
    {
    TRACER("CGlxUiUtility::AddSkinChangeObserverL()");
    iGlxSkinChangeMonitor->AddSkinChangeObserverL( aObserver );
    }

// -----------------------------------------------------------------------------
// RemoveSkinChangeObserver
// -----------------------------------------------------------------------------
//    
EXPORT_C void CGlxUiUtility::RemoveSkinChangeObserver(
        MGlxSkinChangeObserver& aObserver)
    {
    TRACER("CGlxUiUtility::RemoveSkinChangeObserver()");
    iGlxSkinChangeMonitor->RemoveSkinChangeObserver( aObserver );
    }

// -----------------------------------------------------------------------------
// ScreenFurniture
// -----------------------------------------------------------------------------
//
EXPORT_C CGlxScreenFurniture* CGlxUiUtility::ScreenFurniture()
    {
    return iScreenFurniture;
    }

// -----------------------------------------------------------------------------
// Context Utility for Teleport
// -----------------------------------------------------------------------------
//
/*EXPORT_C CHgContextUtility* CGlxUiUtility::ContextUtility()
    {
    return iContextUtility;
    }
*/
// -----------------------------------------------------------------------------
// IsPenSupported
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CGlxUiUtility::IsPenSupported()
    {
    TRACER("CGlxUiUtility::IsPenSupported");

    return AknLayoutUtils::PenEnabled();
    }

// -----------------------------------------------------------------------------
// GridIconSize
// -----------------------------------------------------------------------------
//	
void CGlxUiUtility::GridIconSizeL()
    {
    TRACER("CGlxUiUtility::GridIconSize()");
    // Sets up TLS, must be done before FeatureManager is used.
    FeatureManager::InitializeLibL();

    if (FeatureManager::FeatureSupported(KFeatureIdLayout640_360_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout360_640_Touch))
        {
        iGridIconSize = TSize(111, 83);
        }
    else if (FeatureManager::FeatureSupported(KFeatureIdLayout640_480_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout480_640_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout640_480)
            || FeatureManager::FeatureSupported(KFeatureIdLayout480_640))
        {
        iGridIconSize = TSize(146, 110);
        }
    else
        {
        iGridIconSize = TSize(146, 110);
        }
    // Frees the TLS. Must be done after FeatureManager is used.
    FeatureManager::UnInitializeLib();
    }


 
EXPORT_C TBool CGlxUiUtility::IsExitingState()
    {
    TRACER("CGlxUiUtility::ExitingState");
    return iIsExiting;
    }

EXPORT_C void CGlxUiUtility::SetExitingState(TBool aIsExiting)
    {
    TRACER("CGlxUiUtility::SetExitingState");
    iIsExiting = aIsExiting;
    }


// -----------------------------------------------------------------------------
// VisibleItemsInPageGranularityL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::VisibleItemsInPageGranularityL()
    {
    TRACER("CGlxUiUtility::VisibleItemsInPageGranularityL");

    //TBD: In MCL 9.1/Corolla env currently the feature flags 
    //KFeatureIdLayout640_480 and KFeatureIdLayout480_640 are not defined.
    //so making the default granularity as 21 instead of 15.
    //Need to replace with KGlxDefaultVisibleItemsGranularity after
    //getting the feature flag.
    TInt ret = KGlxVGAVisibleItemsGranularity;
    FeatureManager::InitializeLibL();

    if (FeatureManager::FeatureSupported(KFeatureIdLayout640_360_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout360_640_Touch))
        {
        ret = KGlxQHDVisibleItemsGranularity;
        }
    else if (FeatureManager::FeatureSupported(KFeatureIdLayout640_480_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout480_640_Touch)
            || FeatureManager::FeatureSupported(KFeatureIdLayout640_480)
            || FeatureManager::FeatureSupported(KFeatureIdLayout480_640))
        {
        ret = KGlxVGAVisibleItemsGranularity;
        }
    FeatureManager::UnInitializeLib();
    return ret;
    }

// -----------------------------------------------------------------------------
// StartTNMDaemon
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::StartTNMDaemon()
    {
    TRACER("CGlxUiUtility::StartTNMDaemon");
    return RProperty::Set(KTAGDPSNotification, KForceBackgroundGeneration,
            ETrue);
    }

// -----------------------------------------------------------------------------
// StopTNMDaemon
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::StopTNMDaemon()
    {
    TRACER("CGlxUiUtility:: StopTNMDaemon");
    return RProperty::Set(KTAGDPSNotification, KForceBackgroundGeneration,
            EFalse);
    }

// -----------------------------------------------------------------------------
// GetItemsLeftCount
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::GetItemsLeftCount()
    {
    TRACER("CGlxUiUtility::GetItemsLeftCount");
    TInt itemsLeftCount = 0;
    TInt err =
            RProperty::Get(KTAGDPSNotification, KItemsleft, itemsLeftCount);
    GLX_LOG_INFO1("GetItemsLeftCount: GetItemsLeftCount %d", itemsLeftCount);

    // In case of error, enter in the next view. Don't block photos permanently.
    // [Though this use case is very unlikely]
    if (err != KErrNone)
        {
        GLX_LOG_INFO1("GetItemsLeftCount: RProperty::Get errorcode %d", err);
        itemsLeftCount = 0;
        }

    // This case is added as per UI-Improvements.
    // Use case: Take a pic. open photos from Menu (not "Goto photos")
    // Progress bar SHOULD NOT be displayed.
    if ((itemsLeftCount != KErrNotReady) && (itemsLeftCount
            <= KIgnoreItemsLeftCount))
        {
        GLX_LOG_INFO("GetItemsLeftCount( < KIgnoreItemsLeftCount )");
        itemsLeftCount = 0;
        }

    return itemsLeftCount;
    }

// -----------------------------------------------------------------------------
// DisplayScreenClearer
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::DisplayScreenClearerL()
    {
    TRACER("CGlxUiUtility::DisplayScreenClearerL");
    if(!iClearer && CAknTransitionUtils::TransitionsEnabled(
            AknTransEffect::EFullScreenTransitionsOff))
        {
        iClearer = CAknLocalScreenClearer::NewL( ETrue );
        }
    }

// -----------------------------------------------------------------------------
// DisplayScreenClearer
// -----------------------------------------------------------------------------
//
EXPORT_C void CGlxUiUtility::DestroyScreenClearer()
    {
    TRACER("CGlxUiUtility::DestroyScreenClearer");
    if(iClearer)
        {
        delete iClearer;
        iClearer = NULL;
        }
    }

// -----------------------------------------------------------------------------
// SetTNMDaemonPSKeyvalue
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::SetTNMDaemonPSKeyvalue()
    {
    TRACER("CGlxUiUtility::SetTNMDaemonPSKeyvalue");
    TInt ret = RProperty::Define(KTAGDPSNotification, KItemsleft,
            RProperty::EInt);
    GLX_LOG_INFO1("CGlxUiUtility::SetTNMDaemon()RProperty::Define %d", ret);
    if (ret == KErrNone)
        {
        ret = RProperty::Set(KTAGDPSNotification, KItemsleft, KErrNotReady);
        GLX_LOG_INFO1("CGlxUiUtility::SetTNMDaemon() RProperty::Set %d", ret);
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// GetKeyguardStatus
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGlxUiUtility::GetKeyguardStatus()
    {
    TRACER("CGlxUiUtility::GetKeyguardStatus");
    TInt keyguardStatus = KErrNone;
    RProperty::Get(KPSUidAvkonDomain, KAknKeyguardStatus, keyguardStatus);
    GLX_LOG_INFO1("CGlxUiUtility::GetKeyguardStatus() keyguardStatus=%d", keyguardStatus);
    return keyguardStatus;
    }
// End of file