psln/pslnengine/src/PslnModel.cpp
changeset 0 2f259fa3e83a
child 9 0aa5fbdfbc30
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/psln/pslnengine/src/PslnModel.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,2098 @@
+/*
+* Copyright (c) 2002-2007 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:  Model class for Psln application.
+*
+*/
+
+
+// Psln specific.
+#include "PslnModel.h"
+#include "PslnDiskUtil.h"
+#include "PslnFeatures.h"
+#include "PslnSkinEntry.h"
+#include "PslnSkinStore.h"
+#include "PslnEcomListener.h"
+#include "PslnDebug.h"
+#include "PslnConst.h"
+
+// Wrapper for wallpaper utils.
+#include "pslnwallpaperutilsloader.h"
+#include "pslnbrowserlaunchloader.h"
+
+// Resources
+#include <psln.rsg>
+#include <pslnskinnames.rsg>
+
+// Generic
+#include <StringLoader.h>
+#include <data_caging_path_literals.hrh>
+#include <f32file.h>
+#include <hal.h>
+
+// UI libraries
+#include <AknsSkinUID.h>
+#include <AknsConstants.h>
+#include <eikenv.h>
+#include <AknQueryDialog.h>
+
+// Misc
+#include <bautils.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL
+
+// Central Repository and Publish&Subscribe keys.
+#include <centralrepository.h>
+#include <e32property.h>
+#include "pslninternalcrkeys.h"
+#include <AknSkinsInternalCRKeys.h>             // wallpaper, screen saver
+#include <ScreensaverInternalCRKeys.h>          // KScreenSaverObject
+#include <ScreensaverInternalPSKeys.h>          // KScreenSaverPreviewMode
+#include <cenrepnotifyhandler.h>
+
+// For enabling first component transition effect
+#include <gfxtranseffect/gfxtranseffect.h>
+#include <akntranseffect.h>
+#ifdef RD_MULTIPLE_DRIVE
+#include <driveinfo.h>
+#endif //RD_MULTIPLE_DRIVE
+
+
+// CONSTANTS
+// Path of skin files.
+_LIT( KPslnSkinNamesFile,"z:PslnSkinNames.rsc" );
+// Preview mode activated.
+const TInt KPslnActivatePreviewMode = 1;
+
+// Default item index.
+const TInt KPslnDefaultItemIndex = 0;
+
+// Screen saver type: user defined text
+const TInt KPslnSsText = 0;
+// Screen saver type: date & time
+const TInt KPslnSsDate = 1;
+// Screen saver type: object
+const TInt KPslnSsObject = 3;
+// Screen saver type: none
+const TInt KPslnSsNone = 4;
+
+// Granularity of screen saver array.
+const TInt KPslnSsArrayGranularity = 5;
+// Length of drive number descriptor.
+const TInt KPslnDriveNumberLength = 2;
+// Free RAM required when activating transition effects.
+const TInt KPslnTransitionEffectRAMThreshold = 2000000;
+// Maximum of text length in text screensaver for APAC.
+// For western variant, value is taken directly from resources.
+const TInt KPslnSsTextDialogAPACMaxLength = 7;
+// Path to wallpaper utils.
+_LIT( KPslnWallpaperUtilsLoaderName, 
+     "\\system\\libs\\PslnWallpaperUtilsLoader.dll");
+_LIT( KPslnBrowserLaunchLoaderName, 
+     "\\system\\libs\\PslnBrowserLaunchLoader.dll");
+// Screen saver UID is stored like [ss_uid]. This is the end mark.
+_LIT( KPslnScreenSaverUidEndMark, "]" );
+
+// CLASS DECLARATIONS
+
+class CPslnActivationGuard : public CBase
+    {
+    public:
+        virtual ~CPslnActivationGuard()
+            {
+            PSLN_TRACE_DEBUG("CPslnActivationGuard::destructor");
+            iModel->SkinSrvSession().EnableSkinChangeNotify();
+            }
+
+        static CPslnActivationGuard* NewL( CPslnModel* aModel )
+            {
+            PSLN_TRACE_DEBUG("CPslnActivationGuard::NewL");
+            CPslnActivationGuard* self = new (ELeave) CPslnActivationGuard();
+            self->iModel = aModel;
+            PSLN_TRACE_DEBUG("CPslnActivationGuard DisableSkinChangeNotify");
+            aModel->SkinSrvSession().DisableSkinChangeNotify();
+            return self;
+            }
+
+    private:
+        CPslnModel* iModel;
+    };
+
+// TYPE DEFINITIONS
+// Wallpaper Utils entry.
+typedef TAny* (*NewWallpaperUtilsL)();
+
+// Browser Launcher entry.
+typedef TAny* (*NewBrowserLauncherL)();
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+// -----------------------------------------------------------------------------
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CPslnModel* CPslnModel::NewL( MAknsSkinChangeObserver* aObserver )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::NewL");
+    CPslnModel* self = new(ELeave) CPslnModel;
+
+    CleanupStack::PushL( self );
+    self->ConstructL( aObserver );
+    CleanupStack::Pop( self );
+
+    PSLN_TRACE_DEBUG("CPslnModel::NewL OK");
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// Two-phased constructor. Simpler version for PslnFramework use.
+// Deprecated.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CPslnModel* CPslnModel::NewL()
+    {
+    CPslnModel* self = new(ELeave) CPslnModel;
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// Destructor
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CPslnModel::~CPslnModel()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::destructor");
+
+    delete iSkinsRepository;
+    delete iScreenSaverRepository;
+    iSkinSrvSession.Close();
+
+    while( iSkinNames.Count() )
+        {
+        delete iSkinNames[0].iListName;
+        delete iSkinNames[0].iTitleName;
+        iSkinNames.Remove(0);
+        }
+    iSkinNames.Close();
+
+    delete iScreensaverFilenameArr;
+    delete iScreensaverNameArr;
+    iScreensaverCapsArr.Reset();
+
+    delete iSkinStore;
+    if( iVisibleSkinArr )
+        {
+        iVisibleSkinArr->ResetAndDestroy();
+        delete iVisibleSkinArr;
+        }
+    delete iScreenSaverInfo;
+
+    delete iWallpaperSetter;
+    if( iInternalState.IsSet( EPslnModelStateWallpaperDllLoaded  ) )
+        {
+        iWallpaperDll.Close();
+        }
+
+    delete iBrowserLauncher;
+    if( iInternalState.IsSet( EPslnModelStateBrowserLaunchDllLoaded ) )
+        {
+        iBrowserLaunchDll.Close();
+        }
+
+    // If client is bad-behaving and has not cancelled listening, 
+    // cancel itself.
+    if ( iScreenSaverListener )
+        {
+        if ( iScreenSaverListener->IsActive() )
+            {
+            iScreenSaverListener->Cancel();
+            }
+        delete iScreenSaverListener;
+        // NUllified here, just in case if client later decides to try and
+        // destroy this.
+        iScreenSaverListener = NULL;
+        }
+        
+    if(iThemesAppCenRepNotifyHandler)
+        {
+        iThemesAppCenRepNotifyHandler->StopListening();
+        delete iThemesAppCenRepNotifyHandler;
+        }
+    delete iThemesAppRepository;
+    }
+
+// -----------------------------------------------------------------------------
+// Activate a Skin.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::ActivateSkinL(
+    const TDesC8& /*aPreviewType*/,
+    const TInt /*aActiveSkinIndex*/ )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL -- depricated!!");
+    User::Leave( KErrNotSupported );
+    return EFalse;
+    }
+
+// -----------------------------------------------------------------------------
+// Activate a screen saver.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::ActivateScreenSaver( const TInt aItemIndex, 
+    TPslnScreenSaverActivation aActivationType )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateScreenSaver");
+    TRAPD( err, ActivateScreenSaverL( aItemIndex, aActivationType ) );
+    PSLN_TRACE_DEBUG1("CPslnModel::ActivateScreenSaver %d", err );
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::GuardActivationLC
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void  CPslnModel::GuardActivationLC()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GuardActivationLC");
+    CleanupStack::PushL( CPslnActivationGuard::NewL( this ) );
+    }
+
+// -----------------------------------------------------------------------------
+// Download a skin.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::DownloadSkinL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL BEGIN");
+    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Load DLL");
+    LoadBrowserLaunchL();
+    if ( iBrowserLauncher )
+        {
+        PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Launch embedded browser");
+        TRAPD( error, 
+               iBrowserLauncher->LaunchBrowserStandaloneL( ) );
+        if ( error != KErrNone )
+            {
+            PSLN_TRACE_DEBUG1("CPslnModel::DownloadSkinL Handle exit: %d", error );
+            }
+        if ( error == KErrNoMemory )
+            {
+            PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL OOM");
+            User::Leave( error );
+            }
+        }
+    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL END");
+    }
+
+// -----------------------------------------------------------------------------
+// Set Background image path name.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::SetBackgroundImagePath( const TDesC& aImagePath )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::SetBackgroundImagePath");
+
+    TRAP_IGNORE( LoadWallpaperUtilsL() );
+    TInt retVal = KErrNone;
+    if ( iWallpaperSetter )
+        {
+        if( aImagePath.Length() > 0 )
+            {
+            retVal = iWallpaperSetter->SetIdleWallpaper(
+                aImagePath, 
+                CCoeEnv::Static(),
+                R_PSLN_SKINS_LOADING_IMAGE,
+                R_PSLN_GENERAL_WAIT_NOTE );
+            }
+        else
+            {
+            retVal = iWallpaperSetter->SetIdleWallpaper( KNullDesC, NULL );
+            }
+        }
+    else
+        {
+        retVal = KErrNoMemory;
+        }
+    return retVal;
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::InvokeSSPluginFunctionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::InvokeSSPluginFunctionL(
+    TInt aIndex,
+    TScPluginCaps aFunction )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::InvokeSSPluginFunctionL");
+    if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )
+        {
+        User::Leave( KErrNotFound );
+        }
+
+    if( aIndex >= iScreensaverFilenameArr->MdcaCount() )
+        {
+        User::Leave( KErrArgument );
+        }
+        
+    if(aFunction == EScpCapsConfigure &&
+       aIndex == GetScreenSaverIndexByFileName(KPslnScreenSaverTypeText))
+        {
+        TBool ret = QueryAndSetScreensaverTextL();
+        if ( !ret )
+            {
+            User::Leave( KErrCancel );
+            }
+        return;
+        }
+
+    // Convert the UID of the given screensaver plugin from text to integer
+    // The string format of the UID: [12345678]
+    // The number inside the brackets in hexadecimal format
+    TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );
+    // Skip the first character: '['
+    lex.Get();
+    TUint screenSaverPluginImpUid;
+    // Get the UID
+    TInt err = lex.Val( screenSaverPluginImpUid, EHex );
+    PSLN_TRACE_DEBUG1("CPslnModel::InvokeSSPluginFunctionL lexed: %d", err );
+    User::LeaveIfError( err );
+
+    CScreensaverPluginInterfaceDefinition* plugin =
+        CScreensaverPluginInterfaceDefinition::NewL(
+        TUid::Uid( screenSaverPluginImpUid ) );
+    CleanupStack::PushL( plugin );
+
+    err = plugin->PluginFunction( aFunction, iEikEnv );
+    PSLN_TRACE_DEBUG1("CPslnModel::InvokeSSPluginFunctionL call return: %d", err );
+    CleanupStack::PopAndDestroy( plugin );
+
+    if( err == KErrCancel && aIndex == CurrentPropertyIndexL( KPslnScreenSettingId ) )
+        {
+        SetScreenSaverToDefault();
+        }
+    
+    User::LeaveIfError( err );
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::PerformCompleteUpdateL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::PerformCompleteUpdateL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL");
+
+    if ( iInternalState.IsClear( EPslnModelStateSkinNamesLoaded ) )
+        {
+        LoadSkinNamesResourceL();
+        }
+    UpdateFromServerL();
+    SetActiveSkinL();
+
+    PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL COMPLETED");
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::LoadScreensaverArrayL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::LoadScreensaverArrayL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::LoadScreensaverArrayL");
+
+    // Destroy old arrays, if any
+    delete iScreensaverNameArr;
+    iScreensaverNameArr = NULL;
+    delete iScreensaverFilenameArr;
+    iScreensaverFilenameArr = NULL;
+    iScreensaverCapsArr.Reset();
+
+    // Load default items
+    iScreensaverNameArr = iEikEnv->ReadDesC16ArrayResourceL(
+        R_SCREEN_SAVER_SETTING_PAGE_LBX );
+
+    // Add descriptors for system screensavers
+    iScreensaverFilenameArr =
+        new (ELeave) CDesC16ArrayFlat( KPslnSsArrayGranularity );
+    iScreensaverFilenameArr->AppendL( KPslnScreenSaverTypeDateTime );
+    iScreensaverFilenameArr->AppendL( KPslnScreenSaverTypeText );
+
+    // System screensavers have no capabilities
+    User::LeaveIfError( iScreensaverCapsArr.Append( EFalse ) );
+    User::LeaveIfError( iScreensaverCapsArr.Append( EScpCapsConfigure ) );
+
+    if ( IsSupportScreenSaverNoneOption() )
+        {
+        iScreensaverFilenameArr->InsertL(0, KPslnScreenSaverTypeNone ); 
+        User::LeaveIfError( iScreensaverCapsArr.Insert( 0, EFalse ) );
+        }
+    else
+        {
+        iScreensaverNameArr->Delete(0);
+        }
+
+    FindAndAppendScreensaversL();
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::VisibleSkin
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CPslnSkinEntry* CPslnModel::VisibleSkin( const TInt aIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::VisibleSkin");
+    if ( !iSkinStore )
+        {
+        TRAPD( err, iSkinStore = CPslnSkinStore::NewL( this ) );
+        if ( err != KErrNone )
+            {
+            return NULL;
+            }
+        }
+    CPslnSkinEntry* visibleSkin = NULL;
+    if ( iVisibleSkinArr )
+        {
+        if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )
+            {
+            CPslnSkinNameEntry* nameEntry = (*iVisibleSkinArr)[aIndex];
+            visibleSkin = iSkinStore->Find(
+                nameEntry->PkgID(), nameEntry->Location() );
+            }
+        }
+    return visibleSkin;
+    }
+
+// -----------------------------------------------------------------------------
+// Get a skin's name by index.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::GetSkinNameByIndex( const TInt aIndex, TDes& aSkinName,
+    const TPslnSkinNameType aType ) const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetSkinNameByIndex");
+
+    TAknsPkgID pid = KAknsNullPkgID;
+    if ( iVisibleSkinArr )
+        {
+        if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )
+            {
+            pid = (*iVisibleSkinArr)[aIndex]->PkgID();
+            }
+        }
+
+    GetSkinNameByPID( pid, aSkinName, aType );
+    }
+
+// -----------------------------------------------------------------------------
+// Return if the selected skin is activated.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsActiveSkinSelected( TInt aSkinIndex ) const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::IsActiveOfSkinSelected");
+
+    TInt skinIndex = iCurrentSkinIndex;
+    if ( aSkinIndex >= 0 )
+        {
+        skinIndex = aSkinIndex;
+        }
+    return ( iActiveSkinIndex == skinIndex );
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::LocationOfSkin
+// Deprecated.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TAknSkinSrvSkinPackageLocation CPslnModel::LocationOfSkin(
+    const TInt aIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::LocationOfSkin");
+    TAknSkinSrvSkinPackageLocation skinLocation = EAknsSrvPhone;
+    CPslnSkinEntry* entry = VisibleSkin( aIndex );
+    if( entry )
+        {
+        skinLocation = entry->Location();
+        }
+    return skinLocation;
+    }
+
+// -----------------------------------------------------------------------------
+// Return the active skin index.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::ActiveSkinIndex () const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActiveSkinIndex");
+    return iActiveSkinIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// Return the skin index of the selection currently active.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::CurrentSelectedSkinIndex () const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::CurrentSelectedSkinIndex");
+    return iCurrentSkinIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// Get number of skins.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::NumberOfSkins() const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::NumberOfSkins");
+    TInt numberOfSkins = 0;
+    if ( iVisibleSkinArr )
+        {
+        numberOfSkins = iVisibleSkinArr->Count();
+        }
+    return numberOfSkins;
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::ScreensaverNames
+// ---------------------------------------------------------------------------
+//
+EXPORT_C const MDesC16Array& CPslnModel::ScreensaverNames() const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ScreensaverNames");
+    return *iScreensaverNameArr;
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::ScreensaverHasCapability
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::ScreensaverHasCapability(
+    const TInt aIndex,
+    const TScPluginCaps aCapability ) const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ScreensaverHasCapability");
+    if( ( aIndex < 0 ) || ( aIndex >= iScreensaverCapsArr.Count() ) )
+        {
+        return EFalse;
+        }
+
+    return ( iScreensaverCapsArr[ aIndex ] & aCapability );
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::ProtectionOfSkin
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TAknsSkinSrvSkinProtectionType CPslnModel::ProtectionOfSkin(
+    const TInt aIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ProtectionOfSkin");
+    TAknsSkinSrvSkinProtectionType skinProtectionType = EAknsSrvNoProtection;
+    CPslnSkinEntry* entry = VisibleSkin( aIndex );
+    if( entry )
+        {
+        skinProtectionType = entry->Protection();
+        }
+    return skinProtectionType;
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::IsValidForActivation
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsValidForActivation( const TInt aItemIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::IsValidForActivation");
+    CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );
+    return ( skinEntry && !skinEntry->IsCorrupted() );
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::IsValidForPreview
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsValidForPreview( const TInt aItemIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::IsValidForPreview");
+    CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );
+    if( !skinEntry )
+        {
+        return EFalse;
+        }
+        
+    if( skinEntry->IsCorrupted() )
+        {
+        return EFalse;
+        }
+    TInt type = skinEntry->Protection();
+    if( type != EAknsSrvNoProtection && type != EAknsSrvProtected )
+        {
+        return EFalse;
+        }
+        
+    TBool skinFileExist = SkinFileExist( aItemIndex );
+    if( !skinFileExist )
+        {
+        return EFalse;
+        }
+
+    return ETrue;
+    }
+
+// -----------------------------------------------------------------------------
+// Checks if the skin support animated background.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsSupportAnimBg( TInt aItemIndex )
+    {
+    CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );
+    return skinEntry && skinEntry->IsSupportAnimBg();
+    }
+	
+// -----------------------------------------------------------------------------
+// Set current selected skin index.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::SetCurrentSelectedSkinIndex(
+    const TInt aCurrentSkinIndex )
+    {
+    PSLN_TRACE_DEBUG1("CPslnModel::SetCurrentSelectedSkinIndex:%d", aCurrentSkinIndex );
+    if ( aCurrentSkinIndex >= 0 )
+        {
+        iCurrentSkinIndex = aCurrentSkinIndex;
+        }
+    // If given index is negative, assume that first skin is selected.
+    else
+        {
+        iCurrentSkinIndex = 0;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::SetCurrentPropertyType
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::SetCurrentPropertyType(
+    const TInt /*aProperty*/, const TInt /*aCurItemIndex*/ )
+    {
+    // deprecated.
+    return KErrNotSupported;
+    }
+
+// -----------------------------------------------------------------------------
+// Get a Skin's Properties Type index.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::CurrentPropertyIndex( const TInt aProperty )
+    {
+    PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex:%d", aProperty );
+    TInt currentIndex = KErrNotFound;
+    TRAP_IGNORE( currentIndex = CurrentPropertyIndexL( aProperty ) );
+    PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex return:%d", currentIndex );
+    return currentIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// Starts to listen for ECOM screensaver changes.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::EnableScreenSaverNotifications(
+    const TBool& aActive, MPslnScreenSaverECOMObserver& aObserver )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::EnableScreenSaverNotifications" );
+    if ( aActive )
+        {
+        // Create listening class (active object)
+        TRAP_IGNORE(
+            iScreenSaverListener = CPslnEcomListener::NewL( *this, aObserver ) );
+        }
+    else
+        {
+        // Check if model has already destroyed this.
+        if ( iScreenSaverListener )
+            {
+            if ( iScreenSaverListener->IsActive() )
+                {
+                iScreenSaverListener->Cancel();
+                }
+            delete iScreenSaverListener;
+            iScreenSaverListener = NULL;
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// Activates skin. This overloaded version knows in which state the activation 
+// is requested.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::ActivateSkinL(
+    const TDesC8& /*aPreviewType*/,
+    const TInt /*aActiveSkinIndex*/,
+    const TBool& /*aActivateFromPreview*/ )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL -- depricated!!");
+    User::Leave( KErrNotSupported );
+    return EFalse;
+    }
+
+// -----------------------------------------------------------------------------
+// Activates skin. 
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::ActivateSkinL(
+    const TInt aActiveSkinIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL");
+
+    TInt indexToActivate = aActiveSkinIndex;
+    if( aActiveSkinIndex == KErrNotFound )
+        {
+        indexToActivate = iActiveSkinIndex;
+        }
+    PSLN_TRACE_DEBUG1("CPslnModel::ActivateSkinL activate skin index=%d", indexToActivate );
+    // Get skin's full name.
+    HBufC* fullName = HBufC::NewLC( KMaxFileName );
+    TPtr fullNamePtr = fullName->Des();
+    fullNamePtr = GetSkinFullName( indexToActivate );
+
+    if ( !PslnDiskUtil::QueryAndSetAutomatedL( iSkinSrvSession, fullNamePtr ) )
+        {
+        CleanupStack::PopAndDestroy( fullName );
+        PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL set autom. not ok");
+        return EFalse;
+        }
+    CleanupStack::PopAndDestroy( fullName );
+
+    // Find out the skin package ID
+    CPslnSkinEntry* activeEntry = VisibleSkin( indexToActivate );
+    if ( !activeEntry )
+        {
+        PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL NULL entry");
+        User::Leave( KErrGeneral );
+        }
+
+    if ( !activeEntry->IsSupportAnimBg() )
+        {
+        //Stop animated background
+        SetAnimBackground( EPslnDisableAllEffects );
+        }
+    TAknsPkgID activeSkinPid = activeEntry->PkgID();
+    // Activate whole skin
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL set all definition sets");
+    TInt error = iSkinSrvSession.SetAllDefinitionSets( activeSkinPid );
+    
+    // For enabling first component transition effect
+    GfxTransEffect::Enable();
+    
+    if ( error != KErrNone )
+        {
+        PSLN_TRACE_DEBUG1("CPslnModel::ActivateSkinL error when setting definition sets: %d", error );
+        User::LeaveIfError( error );
+        }
+        
+    // Otherwise, save to shareddata
+    TAknsPkgIDBuf pidBuf;
+    activeSkinPid.CopyToDes( pidBuf );
+
+    iSkinsRepository->Set(
+        KPslnActiveSkinUid,
+        pidBuf );
+    iSkinsRepository->Set(
+        KPslnActiveSkinLocation,
+        activeEntry->Location() );
+        
+    iActiveSkinIndex = indexToActivate;
+    return ETrue;
+    }
+
+// -----------------------------------------------------------------------------
+// Leaving version of CurrentPropertyIndex.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::CurrentPropertyIndexL( const TInt aProperty )
+    {
+    PSLN_TRACE_DEBUG1("CPslnModel::CurrentPropertyIndex prop=%d", aProperty );
+
+    TInt itemIndex = KErrNotFound;
+
+    switch( aProperty )
+        {
+        case KPslnBgIdleSettingId:
+            {
+            itemIndex = GetWallPaperItemIndex();
+            break;
+            }
+        case KPslnScreenSettingId:
+            {
+            itemIndex = GetScreenSaverItemIndexL();
+            break;
+            }
+        default:
+            break;
+        }
+    return itemIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// Sets transition effects.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::SetTransitionEffectsL( const TInt aEffectValue )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::SetTransitionEffectsL");
+    TInt retVal = KErrNone;
+
+    // For the first time only, read default enable mask.
+    if ( iInternalState.IsClear( EPslnModelStateTransitionEnableCRKeyRead ) )
+        {
+        // Initialize to enable all.
+        iEffectsDefaultEnableMask = EPslnEnableAllEffects;
+
+        retVal = iThemesAppRepository->Get( 
+            KThemesDefaultTransitionEffects, 
+            iEffectsDefaultEnableMask );
+        if ( retVal == KErrNone )
+            {            
+            iInternalState.Set( EPslnModelStateTransitionEnableCRKeyRead );
+            }
+        }
+
+    // Only accept default mask, zero or max value.
+    if ( aEffectValue != iEffectsDefaultEnableMask && 
+         aEffectValue != EPslnEnableAllEffects &&
+         aEffectValue != EPslnDisableAllEffects )
+        {
+        retVal = KErrArgument;
+        }
+    else
+        {
+        if ( aEffectValue == EPslnEnableAllEffects ||
+             aEffectValue == iEffectsDefaultEnableMask )
+            {
+            TInt freeRAM = 0;
+            HAL::Get( HALData::EMemoryRAMFree, freeRAM );
+            if ( freeRAM < KPslnTransitionEffectRAMThreshold )
+                {
+                return KErrNoMemory;
+                }
+            }
+
+        // Use mask, if activating effects.
+        TInt effectValue = aEffectValue;
+        if ( aEffectValue != EPslnDisableAllEffects )
+            {
+            effectValue = iEffectsDefaultEnableMask;
+            }
+
+        iThemesAppRepository->Set( 
+            KThemesTransitionEffects, 
+            effectValue );
+        }
+        
+    // Need to have TFXSrv running before calling enable
+    const TInt KWaitForTFXServerStart( 100000 );
+    User::After( KWaitForTFXServerStart );
+    // For enabling first component transition effect
+    GfxTransEffect::Enable();
+    
+    PSLN_TRACE_DEBUG1("CPslnModel::SetTransitionEffectsL %d", retVal );
+    return retVal;
+    }
+
+// -----------------------------------------------------------------------------
+// Gets current value of transition effects.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::GetTransitionEffectStateL()
+    {
+    if( PslnFeatures::IsSupported( KPslnSupportFastPreviewTheme ) )
+        {
+        return iTransitionEffectValue;
+        }
+    
+
+    PSLN_TRACE_DEBUG("CPslnModel::GetTransitionEffectStateL");
+    TInt effectsValue = KErrNone;
+
+    TInt error = iThemesAppRepository->Get( KThemesTransitionEffects, effectsValue );
+    if ( error != KErrNone || effectsValue < 0 )
+        {
+        PSLN_TRACE_DEBUG2("CPslnModel::GetTransitionEffectStateL Error: %d %d", error, effectsValue );
+        effectsValue = KErrNotFound;
+        }
+
+    PSLN_TRACE_DEBUG1("CPslnModel::GetTransitionEffectStateL return %d", effectsValue );
+    return effectsValue;
+    }
+
+// -----------------------------------------------------------------------------
+// Get Animated Background state
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::AnimBackgroundState() const
+    {   
+    TInt value = KErrNone;
+    TInt error = iThemesAppRepository->Get( KThemesAnimBackgroundSupport, value );
+    if ( error != KErrNone || value < 0 )
+        {
+        value = KMaxTInt;
+        }
+
+    return value;
+    }
+
+// -----------------------------------------------------------------------------
+// Set Animated Background state
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPslnModel::SetAnimBackground( TInt aValue )
+    {
+    ASSERT( aValue == EPslnEnableAllEffects ||
+            aValue == EPslnDisableAllEffects );
+    
+    TInt retVal = KErrNone;
+    if ( aValue == EPslnEnableAllEffects )
+        {
+        TInt freeRAM = 0;
+        HAL::Get( HALData::EMemoryRAMFree, freeRAM );
+        if ( freeRAM < KPslnTransitionEffectRAMThreshold )
+            {
+            return KErrNoMemory;
+            }
+        }
+    iThemesAppRepository->Set( KThemesAnimBackgroundSupport, aValue );
+        
+    return retVal;
+    }
+	
+// -----------------------------------------------------------------------------
+// Checks if screensaver is on memory card.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsScreenSaverOnMemoryCard( const TInt aIndex ) const
+    {
+    if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )
+        {
+        return EFalse;
+        }
+
+    TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );
+    // Skip the first character: '['
+    lex.Get();
+    TUint screenSaverPluginImpUid;
+    TInt currentDrive = EDriveC;
+    // Get the UID
+    lex.Val( screenSaverPluginImpUid, EHex );
+    // Skip character: ']'
+    lex.Get();
+    // Get the drive
+    if ( !lex.Eos() )
+        {
+        // Find out which drive the plugin is on
+        if ( lex.Val( currentDrive ) != KErrNone )
+            {
+            return EFalse;
+            }
+        }
+#ifndef RD_MULTIPLE_DRIVE
+    if ( currentDrive == EDriveE )
+        {
+        return ETrue;
+        }
+    return EFalse;
+#else
+    RFs& fs = iEikEnv->FsSession();
+
+    TUint driveStatus = 0;
+    TBool retVal = EFalse;
+    TInt err = DriveInfo::GetDriveStatus( fs, currentDrive, driveStatus );
+    if ( driveStatus & DriveInfo::EDriveExternallyMountable &&
+         driveStatus & DriveInfo::EDriveRemovable )
+        {
+        retVal = ETrue;
+        }
+    return retVal;
+#endif // RD_MULTIPLE_DRIVE
+    }
+
+// -----------------------------------------------------------------------------
+// Sets currently active content (screensaver/wallpaper) index.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::SetCurrentPropertyTypeL(
+    const TInt aProperty, const TInt aCurItemIndex )
+    {
+    PSLN_TRACE_DEBUG2("CPslnModel::SetCurrentPropertyTypeL prop=%d index=%d", 
+        aProperty, aCurItemIndex );
+
+    if( aCurItemIndex < KPslnDefaultItemIndex )
+        {
+        User::Leave( KErrArgument );
+        }
+
+    TInt retVal = KErrNone;
+    switch( aProperty )
+        {
+        case KPslnBgIdleSettingId:
+            retVal = iSkinsRepository->Set( KPslnWallpaperType, aCurItemIndex );
+            break;
+        case KPslnScreenSettingId:
+            {
+            TInt screensaverType = GetScreensaverTypeByIndex(aCurItemIndex);
+            if ( screensaverType == KPslnSsText )
+                {
+                // Query text if necessary
+                TBool ret = QueryAndSetScreensaverTextL();
+                if ( !ret )
+                    {
+                    User::Leave( KErrCancel );
+                    }
+                }
+            
+            if ( screensaverType == KPslnSsObject )
+                {
+                retVal = iScreenSaverRepository->Set(
+                    KScreenSaverPluginName,
+                    iScreensaverFilenameArr->MdcaPoint( aCurItemIndex ) );
+                }
+            else
+                {
+                retVal = iScreenSaverRepository->Set(
+                    KScreenSaverPluginName,
+                    KNullDesC );
+                }
+                
+            retVal = iScreenSaverRepository->Set(
+                KScreenSaverObject,
+                screensaverType );
+            
+            break;
+            }
+        default:
+            break;
+        }
+    User::LeaveIfError( retVal );
+    }
+
+// -----------------------------------------------------------------------------
+// Checks if the theme is on memory card.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsThemeOnMemoryCard( const TInt& aIndex )
+    {
+#ifndef RD_MULTIPLE_DRIVE
+    return EFalse;
+#else
+    PSLN_TRACE_DEBUG("CPslnModel::IsThemeOnMemoryCard");
+    TBool isThemeOnMemoryCard = EFalse;
+    CPslnSkinEntry* entry = VisibleSkin( aIndex );
+    if( entry )
+        {
+        isThemeOnMemoryCard = entry->IsOnMemoryCard();
+        }
+    return isThemeOnMemoryCard;
+#endif //RD_MULTIPLE_DRIVE
+    }
+
+// -----------------------------------------------------------------------------
+// Checks if the theme is on mass memory.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsThemeOnMassDrive( const TInt& aIndex  )
+    {
+#ifndef RD_MULTIPLE_DRIVE
+    return EFalse;
+#else
+    PSLN_TRACE_DEBUG("CPslnModel::IsThemeOnMassDrive");
+    TBool isThemeOnMemoryCard = EFalse;
+    CPslnSkinEntry* entry = VisibleSkin( aIndex );
+    if( entry )
+        {
+        isThemeOnMemoryCard = entry->IsOnMassDrive();
+        }
+    return isThemeOnMemoryCard;
+#endif //RD_MULTIPLE_DRIVE
+    }
+
+// -----------------------------------------------------------------------------
+// Checks if the screensaver is on mass memory.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPslnModel::IsScreenSaverOnMassDrive( const TInt& aIndex ) const
+    {
+#ifndef RD_MULTIPLE_DRIVE
+    return EFalse;
+#else
+
+    if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )
+        {
+        return EFalse;
+        }
+
+    TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );
+    // Skip the first character: '['
+    lex.Get();
+    TUint screenSaverPluginImpUid;
+    TInt currentDrive = EDriveC;
+    // Get the UID
+    lex.Val( screenSaverPluginImpUid, EHex );
+    // Skip character: ']'
+    lex.Get();
+    // Get the drive
+    if ( !lex.Eos() )
+        {
+        // Find out which drive the plugin is on
+        if ( lex.Val( currentDrive ) != KErrNone )
+            {
+            return EFalse;
+            }
+        }
+
+    RFs& fs = iEikEnv->FsSession();
+
+    TUint driveStatus = 0;
+    TBool retVal = EFalse;
+    TInt err = DriveInfo::GetDriveStatus( fs, currentDrive, driveStatus );
+    
+    // It is mass memory, if it is externally mountable, but not removable.
+    if ( driveStatus & DriveInfo::EDriveExternallyMountable &&
+         !( driveStatus & DriveInfo::EDriveRemovable ) )
+        {
+        retVal = ETrue;
+        }
+    return retVal;
+#endif // RD_MULTIPLE_DRIVE
+    }
+
+// -----------------------------------------------------------------------------
+// Shares skin server session.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C RAknsSrvSession CPslnModel::SkinSrvSession() const
+    { 
+    return iSkinSrvSession;
+    }
+    
+// -----------------------------------------------------------------------------
+// Starts or stops transition effects.
+// -----------------------------------------------------------------------------
+//    
+EXPORT_C void CPslnModel::TransEffect(TInt aAction) const
+    {
+    __ASSERT_DEBUG( EPslnTransitionEffectDummyFirst < aAction && 
+                    aAction < EPslnTransitionEffectDummyLast,
+                    User::Panic(_L("Invalid action for CPslnModel::TransEffect"), 1) );
+                    
+    switch (aAction)
+        {
+        case EPslnTransitionEffectStartPreview:
+             GfxTransEffect::BeginFullScreen( /*AknTransEffect::EApplicationExit*/1500, TRect(), 
+                                      AknTransEffect::EParameterType,
+                                      AknTransEffect::GfxTransParam( KUidPsln ) );    
+             break;                                               
+        case EPslnTransitionEffectStartThemeActivation:
+             GfxTransEffect::BeginFullScreen( /*AknTransEffect::EApplicationExit*/1501, TRect(), 
+                                      AknTransEffect::EParameterType,
+                                      AknTransEffect::GfxTransParam( KUidPsln ) );             
+             break;                                      
+        
+        case EPslnTransitionEffectStop:
+             GfxTransEffect::EndFullScreen(); 
+             break;            
+        }
+    }
+    
+// ---------------------------------------------------------------------------
+// Set current screensaver to default screensaver.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPslnModel::SetScreenSaverToDefault()
+    {
+    // Default Screensaver is Date
+    iScreenSaverRepository->Set(
+        KScreenSaverObject,
+        KPslnSsDate );
+    iScreenSaverRepository->Set(
+        KScreenSaverPluginName,
+        KNullDesC );
+        
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::GetSeparatelyLocalizedSkinName
+// -----------------------------------------------------------------------------
+//
+TBool CPslnModel::GetSeparatelyLocalizedSkinName(
+    const TAknsPkgID aPID, TDes& aSkinName,
+    const TPslnSkinNameType aType ) const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetSeparatelyLocalizedSkinName");
+    TBool retValue = EFalse;
+    TInt i = KErrNone;
+    for( ; i < iSkinNames.Count(); i++ )
+        {
+        if( iSkinNames[i].iPid == aPID )
+            {
+            switch( aType )
+                {
+                case EPslnSkinNameTypeList:
+                    aSkinName = *iSkinNames[i].iListName;
+                    break;
+                case EPslnSkinNameTypeTitle:
+                    aSkinName = *iSkinNames[i].iTitleName;
+                    break;
+                }
+            retValue = ETrue;
+            break; // break the for loop
+            }
+        }
+    return retValue;
+    }
+
+
+// -----------------------------------------------------------------------------
+// C++ constructor can NOT contain any code, that might leave.
+// -----------------------------------------------------------------------------
+//
+CPslnModel::CPslnModel()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::constructor");
+    iEikEnv = CEikonEnv::Static();
+    iActiveSkinIndex = KErrNotFound;
+    iCurrentSkinIndex = KErrNotFound;
+    iInternalState.ClearAll();
+    }
+
+// -----------------------------------------------------------------------------
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CPslnModel::ConstructL( MAknsSkinChangeObserver* aObserver )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ConstructL");
+
+    PSLN_TRACE_DEBUG("CPslnModel::ConstructL CenRep");
+    iSkinsRepository = CRepository::NewL( KCRUidPersonalisation );
+    iScreenSaverRepository = CRepository::NewL( KCRUidScreenSaver );
+    iThemesAppRepository = CRepository::NewL( KCRUidThemes );
+
+    // Connect to skin server.
+    User::LeaveIfError( iSkinSrvSession.Connect( aObserver ) );
+    
+    if( PslnFeatures::IsSupported( KPslnSupportFastPreviewTheme ) )
+        {
+        InitTransitionEffectVauleL();
+        }
+
+    PSLN_TRACE_DEBUG("CPslnModel::ConstructL OK");
+    }
+
+// -----------------------------------------------------------------------------
+// Loads the skin name resource file
+// -----------------------------------------------------------------------------
+//
+void CPslnModel::LoadSkinNamesResourceL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::LoadSkinNamesResourceL");
+    TParse* fp = new (ELeave) TParse;
+    fp->Set( KPslnSkinNamesFile, &KDC_APP_RESOURCE_DIR, NULL );
+    TFileName filename = fp->FullName();
+    delete fp;
+
+    BaflUtils::NearestLanguageFile( iEikEnv->FsSession(), filename );
+    TResourceReader reader;
+    TInt resourceFileOffset = iEikEnv->AddResourceFileL( filename );
+    iEikEnv->CreateResourceReaderLC( reader, R_PSLN_SKINNAME_LIST );
+
+    TInt items = reader.ReadInt16();
+    for( TInt i = 0; i < items; i++ )
+        {
+        TInt pid1 = reader.ReadInt32();
+        TInt pid2 = reader.ReadInt32();
+        HBufC16* listname = reader.ReadHBufC16L();
+        CleanupStack::PushL( listname );
+        HBufC16* titlename = reader.ReadHBufC16L();
+        CleanupStack::PushL( titlename );
+
+        TPslnSkinNameEntry entry;
+        entry.iPid.Set( pid2, pid1 );
+        entry.iListName = listname;
+        entry.iTitleName = titlename;
+        User::LeaveIfError( iSkinNames.Append( entry ) );
+
+        // Title and list name are deleted in the model's destructor.
+        CleanupStack::Pop( 2, listname ); // titlename, listname
+        }
+    CleanupStack::PopAndDestroy(); // reader
+
+    if( resourceFileOffset )
+        {
+        iEikEnv->DeleteResourceFile( resourceFileOffset );
+        }
+
+    iInternalState.Set( EPslnModelStateSkinNamesLoaded );
+    PSLN_TRACE_DEBUG("CPslnModel::LoadSkinNamesResourceL DONE");
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::FindAndAppendScreensaversL
+// ---------------------------------------------------------------------------
+//
+TBool CPslnModel::FindAndAppendScreensaversL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL");
+
+    TBool found = EFalse;
+
+    RImplInfoPtrArray screenSaverList;
+    CleanupResetAndDestroyPushL( screenSaverList );
+
+    CScreensaverPluginInterfaceDefinition::ListImplementationsL( screenSaverList );
+
+    const TInt ssCount = screenSaverList.Count();
+
+    for( TInt i = 0; i < ssCount; i++ )
+        {
+        PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Plugin found");
+
+        CImplementationInformation* implInfo = screenSaverList[i];
+
+        // The the screensaver ecom plugin implementation UID will be used in place of
+        // screensaver file name
+        // The string format of the UID: [12345678]
+        // The number inside the brackets in hexadecimal format
+        TUid impUid = implInfo->ImplementationUid();
+
+        // Stash plugin drive number after the UID.
+        HBufC* ssName = HBufC::NewLC( KMaxUidName + KPslnDriveNumberLength );
+        TPtr ssNamePtr = ssName->Des();
+        ssNamePtr = impUid.Name();
+        ssNamePtr.AppendNum( implInfo->Drive() );
+
+        // Query plugin name.
+        MScreensaverPlugin* plugin = NULL;
+
+        TRAPD( err, plugin = static_cast<MScreensaverPlugin*>(
+            CScreensaverPluginInterfaceDefinition::NewL(
+                TUid::Uid( impUid.iUid  ) ) ) );
+
+        PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Getting caps");
+
+        if ( err == KErrNone )
+            {
+            CleanupStack::PushL( plugin );
+
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Getting caps");
+
+            // Convert the string stored in OpaqueData to an integer
+            // It is the string represantation of TScPluginCaps values
+            // opaque_data has the type TDescC8 so we have to use TLex8
+            TLex8 lex(implInfo->OpaqueData());
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL After Getting caps");
+            TInt capabilities = EScpCapsNone;
+            TInt err2 = KErrNone;
+            if ( !lex.Eos() )
+                {
+                err2 = lex.Val( capabilities );
+                }
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL After Eos check");
+            if ( err2 != KErrNone )
+                {
+                PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Failed");
+                // skip the failing plugin
+                CleanupStack::Pop( plugin ); // using PopAndDestroy fails here.
+                delete plugin;
+                plugin = NULL;
+                break;
+                }
+
+            // Append screensaver name.
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Do Check");
+            if ( plugin && iScreensaverNameArr )
+                {
+                if ( plugin->Name() != KNullDesC )
+                    {
+                    PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Trying to add Name");
+                    iScreensaverNameArr->AppendL( plugin->Name() );
+                    }
+                else
+                    {
+                    PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Trying to add DisplayName");
+                    iScreensaverNameArr->AppendL( implInfo->DisplayName() );
+                    }
+                }
+            CleanupStack::Pop( plugin ); // using PopAndDestroy fails here.
+            delete plugin;
+            plugin = NULL;
+
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL CapsArr Append");
+            User::LeaveIfError(
+                iScreensaverCapsArr.Append( capabilities ) );
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL CapsArrAppend OK");
+
+            found = ETrue;
+
+            PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL Append");
+            if ( iScreensaverFilenameArr )
+                {
+                iScreensaverFilenameArr->AppendL( ssNamePtr );
+                }
+            }
+        CleanupStack::PopAndDestroy( ssName );
+        }
+    PSLN_TRACE_DEBUG("CPslnModel::FindAndAppendScreensaversL COMPLETED");
+    CleanupStack::PopAndDestroy( &screenSaverList );
+    return found;
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::UpdateFromServerL
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::UpdateFromServerL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::UpdateFromServerL");
+    if ( !iSkinStore )
+        {        
+        iSkinStore = CPslnSkinStore::NewL( this );
+        }
+    iSkinStore->UpdateAllSkinsL( iEikEnv->FsSession() );
+    UpdateVisibleSkinListL();
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::UpdateVisibleSkinListL
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::UpdateVisibleSkinListL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::UpdateVisibleSkinListL");
+    if( iVisibleSkinArr )
+        {
+        iVisibleSkinArr->ResetAndDestroy();
+        delete iVisibleSkinArr;
+        iVisibleSkinArr = NULL;
+        }
+
+    if ( iSkinStore )
+        {
+        iVisibleSkinArr = iSkinStore->CreateNameArrayL();
+        }    
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::SetActiveSkinL
+// -----------------------------------------------------------------------------
+//
+void CPslnModel::SetActiveSkinL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::SetActiveSkinL");
+
+    TInt activeSkinLocation = KErrNotFound;
+
+    iSkinsRepository->Get(
+        KPslnActiveSkinLocation,
+        activeSkinLocation );
+
+    // If skin is from memory card, check memory card status.
+    if( activeSkinLocation == EAknsSrvMMC )
+        {
+        if( PslnDiskUtil::MmcStatus() < 0 )
+            {
+            // If skin is on memory card, and there is access error, 
+            // activate default skin.
+            ActivateDefaultSkinL();
+            return;
+            }
+        }
+
+    TAknsPkgIDBuf pidBuf;
+    iSkinsRepository->Get(
+        KPslnActiveSkinUid,
+        pidBuf );
+
+    TAknsPkgID activeSkinPid;
+    activeSkinPid.SetFromDesL( pidBuf );
+
+    if ( !iVisibleSkinArr )
+        {
+        User::Leave( KErrGeneral );
+        }
+    TInt activeSkinIndex = KErrNotFound;
+    for( TInt i = 0; i < iVisibleSkinArr->Count(); i++ )
+        {
+        CPslnSkinNameEntry* nameEntry = (*iVisibleSkinArr)[i];
+        if ( !nameEntry )
+            {
+            User::Leave( KErrGeneral );
+            }
+        if( ( activeSkinPid == nameEntry->PkgID() ) &&
+            ( activeSkinLocation == nameEntry->Location() ) )
+            {
+            activeSkinIndex = i;
+            break;
+            }
+        }
+
+    if( activeSkinIndex == KErrNotFound )
+        {
+        // If the currently active skin no longer exists, activate the default.
+        ActivateDefaultSkinL();
+        return;
+        }
+
+    iActiveSkinIndex = activeSkinIndex;
+    }
+
+// -----------------------------------------------------------------------------
+// Screen saver text query
+// -----------------------------------------------------------------------------
+//
+TBool CPslnModel::QueryAndSetScreensaverTextL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::QueryAndSetScreensaverTextL");
+
+    HBufC* displayText = HBufC::NewLC( KPslnMaxNumberOfScreenSaverText );
+    TPtr txtPtr = displayText->Des();
+
+    TInt error = iScreenSaverRepository->Get( KScreenSaverText, txtPtr );
+
+    // Just load the default text if nothing was set in the skin settings.
+    if ( ( txtPtr.Length() == 0 ) || ( error != KErrNone ) )
+        {
+        GetDefaultTextToScreensaverL( txtPtr );
+        }
+
+    // Set text to query.
+    CAknTextQueryDialog* dlg = CAknTextQueryDialog::NewL(
+        txtPtr,
+        CAknQueryDialog::ENoTone );
+    dlg->SetPredictiveTextInputPermitted( ETrue );
+
+    // If in APAC region, set dialog length dynamically.
+    if ( PslnFeatures::IsAPACSupported() )
+        {        
+        dlg->SetMaxLength( KPslnSsTextDialogAPACMaxLength );
+        }
+
+    TBool retValue = EFalse;
+    // Show query for Screen saver txt.
+    if( dlg->ExecuteLD( R_PSLN_SCREEN_SAVER_TEXT_QUERY_DIALOG ) )
+        {
+        error = iScreenSaverRepository->Set( KScreenSaverText, txtPtr );
+        if ( error == KErrNone )
+            {
+            retValue = ETrue;
+            }
+        }
+    CleanupStack::PopAndDestroy( displayText );
+    return retValue;
+    }
+
+
+// ---------------------------------------------------------------------------
+// CPslnModel::GetSkinFullName
+// ---------------------------------------------------------------------------
+//
+const TDesC& CPslnModel::GetSkinFullName( const TInt aItemIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetSkinFullName");
+    CPslnSkinEntry* skinEntry = VisibleSkin( aItemIndex );
+    if ( skinEntry )
+        {
+        return skinEntry->FullName();
+        }
+    return KNullDesC;
+    }
+
+// -----------------------------------------------------------------------------
+// CPslnModel::GetSkinNameByPID
+// -----------------------------------------------------------------------------
+//
+void CPslnModel::GetSkinNameByPID( const TAknsPkgID aPID, TDes& aSkinName,
+    const TPslnSkinNameType aType ) const
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetSkinNameByPID");
+
+    aSkinName = KNullDesC;
+
+    if( GetSeparatelyLocalizedSkinName( aPID, aSkinName, aType ) )
+        {
+        return;
+        }
+
+    if ( iSkinStore )
+        {
+        CPslnSkinEntry* entry = iSkinStore->Find( aPID, EAknsSrvAll );
+        if ( entry )
+            {
+            entry->GetName( aSkinName );
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CPslnModel::ActivateDefaultSkinL
+// ---------------------------------------------------------------------------
+//    
+void CPslnModel::ActivateDefaultSkinL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateDefaultSkinL");
+    GuardActivationLC();
+    ActivateSkinL( KPslnSeries60SkinIndex );
+    CleanupStack::PopAndDestroy(); // activation guard
+    }
+
+// ---------------------------------------------------------------------------
+// Sets default text to parameter.
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::GetDefaultTextToScreensaverL( TDes& aDisplayText )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetDefaultTextToScreensaverL");
+    HBufC* strBuffer = NULL;
+    strBuffer = StringLoader::LoadLC( R_PSLN_SCREEN_SAVER_DEFAULT_TEXT );
+    if ( strBuffer )
+        {
+        aDisplayText = strBuffer->Des();
+        }
+    CleanupStack::PopAndDestroy( strBuffer );
+    }
+
+// ---------------------------------------------------------------------------
+// Gets wallpaper item index. Same as above, but can leave.
+// ---------------------------------------------------------------------------
+//    
+TInt CPslnModel::GetWallPaperItemIndex()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetWallPaperItemIndexL");
+    TInt itemIndex = KErrNotFound;
+
+    TInt error = iSkinsRepository->Get( KPslnWallpaperType, itemIndex );
+    if ( error != KErrNone )
+        {
+        itemIndex = KPslnDefaultItemIndex;
+        }
+    if ( itemIndex == KPslnDefaultItemIndex )
+        {
+        // Verify that key values are coherent.
+        TFileName wallpaperPath;
+        error = iSkinsRepository->Get( KPslnIdleBackgroundImagePath, wallpaperPath );
+        if ( wallpaperPath.Length() > 0 )
+            {
+            // Wallpaper image is defined, but type is claimed as None.
+            // Assume that image is desired.
+            itemIndex = 1;
+            }
+        }
+
+    return itemIndex;
+    }
+
+// ---------------------------------------------------------------------------
+// Gets screensaver item index. Same as above, but can leave.
+// ---------------------------------------------------------------------------
+//     
+TInt CPslnModel::GetScreenSaverItemIndexL()
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetScreenSaverItemIndexL");
+    TInt screenObjectType = KErrNotFound;
+    TInt error = KErrNone;
+    
+    error = iScreenSaverRepository->Get( 
+        KScreenSaverObject, screenObjectType );
+        
+    if ( error != KErrNone )
+        {
+        return KErrNotFound;
+        }
+
+    if ( screenObjectType == KPslnSsNone && !IsSupportScreenSaverNoneOption() )
+        {
+        //if "none" option is not supported and the settings of cenrep is none
+        //then change it to the default screen saver - "date".
+        screenObjectType = KPslnSsDate;
+        }
+        
+    switch ( screenObjectType )
+        {
+        case KPslnSsNone:
+            return GetScreenSaverIndexByFileName(KPslnScreenSaverTypeNone);
+        case KPslnSsDate:
+            return GetScreenSaverIndexByFileName(KPslnScreenSaverTypeDateTime);
+        case KPslnSsText:
+            return GetScreenSaverIndexByFileName(KPslnScreenSaverTypeText);
+        case KPslnSsObject:
+            break;
+        default:
+            return KErrNotFound;
+        }
+
+    TInt itemIndex = KErrNotFound;
+    HBufC* screenSaverFileName = HBufC::NewLC( KMaxFileName );
+    TPtr ssFilePtr = screenSaverFileName->Des();
+    error = iScreenSaverRepository->Get(
+        KScreenSaverPluginName,
+        ssFilePtr );
+
+    // Try to look for ']'.
+    TInt eqPos = ssFilePtr.Find( KPslnScreenSaverUidEndMark );
+
+    // If not found, use the whole string.
+    if( eqPos == KErrNotFound )
+        {
+        eqPos = ssFilePtr.Length();
+        }
+    // strip all characters right of it.
+    ssFilePtr = ssFilePtr.Left( eqPos + 1 );
+
+    if ( error == KErrNone && iScreensaverFilenameArr )
+        {
+        // Loop through all the screensavers.
+        for( TInt i = 0; i < iScreensaverFilenameArr->MdcaCount(); i++ )
+            {
+            TPtrC ssNamePtr = GetRealScreenSaverUid( i );
+            if( ssNamePtr.CompareF( ssFilePtr ) == 0 )
+                {
+                itemIndex = i;
+                break;
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy( screenSaverFileName );
+    return itemIndex;
+    }
+
+// ---------------------------------------------------------------------------
+// Dynamically loads AknsWallpaperUtils to memory.
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::LoadWallpaperUtilsL()
+    {
+    // Wallpaper utils dll loading.
+    if( iInternalState.IsClear( EPslnModelStateWallpaperDllLoaded ) )
+        {
+        PSLN_TRACE_DEBUG("CPslnModel::LoadWallpaperUtilsL about load");
+        if( iWallpaperDll.Load( KPslnWallpaperUtilsLoaderName ) == KErrNone )
+            {
+            PSLN_TRACE_DEBUG("CPslnModel::LoadWallpaperUtilsL loaded");
+            iInternalState.Set( EPslnModelStateWallpaperDllLoaded );
+            // Request the entry function
+            NewWallpaperUtilsL wallpaperUtils =
+                (NewWallpaperUtilsL) iWallpaperDll.Lookup( KPslnDllEntryPoint );
+            if( wallpaperUtils )
+                {
+                PSLN_TRACE_DEBUG("CPslnModel::LoadWallpaperUtilsL create");
+                // Create the class
+                iWallpaperSetter =
+                    (CPslnWallpaperUtilsLoader*) (*wallpaperUtils)();
+                }
+            }
+        }
+    if ( !iWallpaperSetter )
+        {
+        User::Leave( KErrNotFound );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// This function removes file information from ScreenSaver UID.
+// -----------------------------------------------------------------------------
+//
+TPtrC CPslnModel::GetRealScreenSaverUid( const TInt aIndex )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::GetRealScreenSaverUid");
+    // Look for ']' - this indicates the end of screensaver UID. 
+    TInt eqPos = 
+        iScreensaverFilenameArr->MdcaPoint( aIndex ).Find( 
+            KPslnScreenSaverUidEndMark );
+    // If not found, use the whole string.
+    if( eqPos == KErrNotFound )
+        {
+        eqPos = iScreensaverFilenameArr->MdcaPoint( aIndex ).Length();
+        }
+    // strip all characters right of it.
+    return iScreensaverFilenameArr->MdcaPoint( aIndex ).Left( eqPos + 1 );
+    }
+
+// -----------------------------------------------------------------------------
+// This is leaving version of ActivateScreenSaver.
+// -----------------------------------------------------------------------------
+//
+void CPslnModel::ActivateScreenSaverL( const TInt aItemIndex, 
+    TPslnScreenSaverActivation aActivationType )
+    {
+    PSLN_TRACE_DEBUG("CPslnModel::ActivateScreenSaver");
+    
+    TInt error = KErrNone;
+    if ( aActivationType == EPslnScreenSaverPreviewActivation )
+        {
+        // get screen saver type to be previewed
+        TInt previewSsType = GetScreensaverTypeByIndex( aItemIndex );
+        if ( previewSsType == KErrNotFound )
+            {
+            User::Leave( KErrNotFound );
+            }
+
+        // create CScreenSaverInfo object to backup the current screensaver settings
+        if ( !iScreenSaverInfo )
+            {
+            iScreenSaverInfo = CPslnScreenSaverInfo::NewL();
+            }
+        
+        //backup current screensaver settings
+        error = iScreenSaverRepository->Get(
+            KScreenSaverObject,
+            iScreenSaverInfo->iScreenSaverType );
+
+        if ( previewSsType == KPslnSsText )
+            {
+            TPtr ptr = iScreenSaverInfo->iScreenSaverTxt->Des();
+            error = iScreenSaverRepository->Get(
+                KScreenSaverText,
+                ptr );
+            }
+        else if ( previewSsType == KPslnSsObject )
+            {
+            TPtr ptr = iScreenSaverInfo->iFileName->Des();
+            error = iScreenSaverRepository->Get(
+                KScreenSaverPluginName,
+                ptr );
+            }
+            
+        //set values to screen saver needed to preview
+        if ( previewSsType == KPslnSsText )
+            {
+            // Load the default text.
+            if ( iScreenSaverInfo->iScreenSaverTxt->Length() == 0 )
+                {
+                HBufC* screensaverText = HBufC::NewLC( KPslnMaxNumberOfScreenSaverText );
+                TPtr ptr = screensaverText->Des();
+
+                GetDefaultTextToScreensaverL( ptr );
+                
+                error = iScreenSaverRepository->Set(
+                    KScreenSaverText,
+                    ptr );
+
+                CleanupStack::PopAndDestroy(screensaverText);
+                }
+            }
+        else if ( previewSsType == KPslnSsObject )
+            {
+            // Get Screen saver filename based on index.
+            if( ( aItemIndex >= 0 ) && ( aItemIndex < iScreensaverFilenameArr->Count() ) )
+                {
+                TPtrC ptr = iScreensaverFilenameArr->MdcaPoint( aItemIndex );
+                error = iScreenSaverRepository->Set(
+                    KScreenSaverPluginName,
+                    ptr );
+                }
+            }
+            
+        error = iScreenSaverRepository->Set(
+            KScreenSaverObject,
+            previewSsType );
+            
+        // Set preview mode active, the screensaver is listening the value.
+        error = RProperty::Set(
+            KPSUidScreenSaver,
+            KScreenSaverPreviewMode,
+            KPslnActivatePreviewMode );     
+        }
+    else if ( aActivationType == EPslnScreenSaverPreviewDeactivation )
+        {
+        TInt previewSsType = KErrNotFound;
+        error = iScreenSaverRepository->Get(
+            KScreenSaverObject,
+            previewSsType );
+
+        //restore the screen saver settings.
+        if ( previewSsType == KPslnSsObject )
+            {
+            error = iScreenSaverRepository->Set(
+                KScreenSaverPluginName,
+                iScreenSaverInfo->iFileName->Des() );
+            }
+        else if ( previewSsType == KPslnSsText )
+            {
+            error = iScreenSaverRepository->Set(
+                KScreenSaverText,
+                iScreenSaverInfo->iScreenSaverTxt->Des() );
+            }
+            
+        if ( error == KErrNone )
+            {        
+            error = iScreenSaverRepository->Set(
+                KScreenSaverObject,
+                iScreenSaverInfo->iScreenSaverType );
+            }
+        }
+    else
+        {
+        User::Leave( KErrNotSupported );      
+        }   
+    }
+
+// ---------------------------------------------------------------------------
+// Dynamically loads browser launcher dll to memory.
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::LoadBrowserLaunchL()
+    {
+    // Browser launch dll loading.
+    if( iInternalState.IsClear( EPslnModelStateBrowserLaunchDllLoaded ) )
+        {
+        PSLN_TRACE_DEBUG("CPslnModel::LoadBrowserLaunchL about load");
+        if( iBrowserLaunchDll.Load( KPslnBrowserLaunchLoaderName ) == KErrNone )
+            {
+            PSLN_TRACE_DEBUG("CPslnModel::LoadBrowserLaunchL loaded");
+            iInternalState.Set( EPslnModelStateBrowserLaunchDllLoaded );
+            // Request the entry function
+            NewBrowserLauncherL browserLaucnher =
+                (NewBrowserLauncherL) iBrowserLaunchDll.Lookup( KPslnDllEntryPoint );
+            if( browserLaucnher )
+                {
+                PSLN_TRACE_DEBUG("CPslnModel::LoadBrowserLaunchL create");
+                // Create the class
+                iBrowserLauncher =
+                    (CPslnBrowserLaunchLoader*) (*browserLaucnher)();
+                }
+            }
+        }
+    if ( !iBrowserLauncher )
+        {
+        User::Leave( KErrNotFound );
+        }
+    }
+    
+// -----------------------------------------------------------------------------
+// CPslnModel::SkinFileExist
+// -----------------------------------------------------------------------------
+//
+TBool CPslnModel::SkinFileExist( const TInt& aIndex  )
+    {
+    if( !IsThemeOnMemoryCard(aIndex) )
+        {
+        return ETrue;
+        }
+    
+    TFileName fullname;
+    fullname = GetSkinFullName( aIndex );
+    
+    TInt filehandle = 0;
+    TInt fileserverhandle = iSkinSrvSession.OpenBitmapFile( fullname, filehandle );
+
+    RFile file;
+    TInt errorcode = file.AdoptFromServer( fileserverhandle, filehandle );
+    file.Close();
+    
+    if ( errorcode == KErrNone )
+        {
+        return ETrue;
+        }
+    
+    return EFalse;
+    }
+        
+// ---------------------------------------------------------------------------
+// Used to notify the client about changes for integer value keys.
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::HandleNotifyInt(TUint32 aId, TInt aNewValue)
+    {
+    if( aId == KThemesTransitionEffects )
+        {
+        iTransitionEffectValue = aNewValue;
+        }
+    }
+    
+// ---------------------------------------------------------------------------
+// Gets transition effect value and initialize CenRep notify handler.
+// ---------------------------------------------------------------------------
+//
+void CPslnModel::InitTransitionEffectVauleL()
+    {
+    iTransitionEffectValue = KErrNone;
+
+    TInt error = iThemesAppRepository->Get( KThemesTransitionEffects, iTransitionEffectValue );
+    if ( error != KErrNone || iTransitionEffectValue < 0 )
+        {
+        iTransitionEffectValue = KErrNotFound;
+        }
+    
+    iThemesAppCenRepNotifyHandler = 
+         CCenRepNotifyHandler::NewL(*this, *iThemesAppRepository,
+            CCenRepNotifyHandler::EIntKey, KThemesTransitionEffects);
+    iThemesAppCenRepNotifyHandler->StartListeningL();
+
+    }
+
+// -----------------------------------------------------------------------------
+// Get screen saver object type from index.
+// -----------------------------------------------------------------------------
+//
+TInt CPslnModel::GetScreensaverTypeByIndex(TInt aIndex)
+    {
+    if(aIndex < 0 || aIndex >= iScreensaverFilenameArr->MdcaCount())
+        {
+        return KErrNotFound;
+        }
+        
+    TPtrC ptr = iScreensaverFilenameArr->MdcaPoint(aIndex);
+    if(ptr.Compare(KPslnScreenSaverTypeNone) == 0)
+        {
+        return KPslnSsNone;
+        }
+    if(ptr.Compare(KPslnScreenSaverTypeDateTime) == 0)
+        {
+        return KPslnSsDate;
+        }
+    if(ptr.Compare(KPslnScreenSaverTypeText) == 0)
+        {
+        return KPslnSsText;
+        }
+    
+    return KPslnSsObject;
+    }
+
+// ---------------------------------------------------------------------------
+// Get screensaver item index from filename
+// ---------------------------------------------------------------------------
+//  
+TInt CPslnModel::GetScreenSaverIndexByFileName(const TDesC &aFileName) const
+    {
+    for( TInt i = 0; i < iScreensaverFilenameArr->MdcaCount(); i++ )
+        {
+        if( aFileName.Compare((*iScreensaverFilenameArr)[i]) == 0 )
+            {
+            return i;
+            }
+        }
+    return KErrNotFound;
+    }
+
+// ---------------------------------------------------------------------------
+// Get if the "None" screen saver is supported.
+// ---------------------------------------------------------------------------
+//      
+TBool CPslnModel::IsSupportScreenSaverNoneOption() const
+    {
+    return PslnFeatures::IsSupported( KPslnSupportScreenSaverSupportNoneOption );
+    }
+    
+    
+
+//  End of File
+