/*

* Copyright (c) 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:  Extensions can be added to AlfEnv through this class.

               Currently resourcepool,widgetfactory can be added as extensions to AlfEnv.

*

*/

#include <alf/alfenv.h>

#include <alf/alfenvobject.h>

#include <alf/alfresourcepool.h>

#include <osn/osnnew.h>

#include <alf/alfwidgetexception.h>

#include <alf/alfwidgetenvextension.h>

#include <alf/alfwidgetfactoryloader.h>

#include <alf/ialfwidgetfactory.h>

namespace Alf

    {

    const int KAlfExtensionResourcePoolUid( 89 ); // Bogus id for resource 

                                                  // pool extension

    const int KAlfExtensionWidgetFactoryUid( 106 ); // Bogus id for widget

                                                    // factory extension

    // Env extension for the resource pool

    class AlfExtensionResourcePoolContainer : public MAlfEnvObject

        {

    public:        

        AlfExtensionResourcePoolContainer( ResourcePool* aResourcePool) :

        mResourcePool(aResourcePool )

            {

            }

        virtual void Release()

            {

            delete this;

            }

        ~AlfExtensionResourcePoolContainer()

            {

            delete mResourcePool;

            }

        // Owned

        ResourcePool* mResourcePool;

        };

    // Env extension for the widget factory

    class AlfExtensionWidgetFactory : public MAlfEnvObject

        {

    public:        

        AlfExtensionWidgetFactory( 

            AlfWidgetFactoryLoader* amWidgetFactoryLoader,

            IAlfWidgetFactory* aWidgetFactory) :

        mWidgetFactoryLoader( amWidgetFactoryLoader ),

        mWidgetFactory( aWidgetFactory )

            {

            }

        virtual void Release()

            {

            delete this;

            }

        ~AlfExtensionWidgetFactory()

            {

            delete mWidgetFactoryLoader;

            }

        // Owned

        AlfWidgetFactoryLoader* mWidgetFactoryLoader;

        // Not owned

        IAlfWidgetFactory* mWidgetFactory;

        };    

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

// Initializes environment with resource pool and factory extensions

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

//    

OSN_EXPORT void AlfWidgetEnvExtension::initializeEnvironment(CAlfEnv& aEnv)

    {

	AlfExtensionResourcePoolContainer* poolContainer = 

        static_cast<AlfExtensionResourcePoolContainer*>(

            aEnv.Extension( KAlfExtensionResourcePoolUid));

    if ( poolContainer == NULL)

        {

        // Initialize the env with resource pool extension

        initializeEnvironmentForResourcePool(aEnv);

        }

	AlfExtensionWidgetFactory* widgetFactoryExtension = 

        static_cast<AlfExtensionWidgetFactory*>(

            aEnv.Extension( KAlfExtensionWidgetFactoryUid));

    if ( widgetFactoryExtension == NULL)

        {

        // Initialize the env with widget factory extension

        initializeEnvironmentForFactory(aEnv);

        }

    }

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

// Initializes environment with Theme Manager extension

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

//   

void AlfWidgetEnvExtension::initializeEnvironmentForTheme(CAlfEnv& /*aEnv*/ )

    {

    }

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

// Initializes environment with resource pool extension

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

//        

void AlfWidgetEnvExtension::initializeEnvironmentForResourcePool(CAlfEnv& aEnv)

    {

    auto_ptr<ResourcePool> pool(new(EMM) ResourcePool(

                                             aEnv.TextureManager(), NULL));

    auto_ptr<AlfExtensionResourcePoolContainer> poolContainer(

        new(EMM) AlfExtensionResourcePoolContainer( pool.release()));

    int err = aEnv.AddExtension( KAlfExtensionResourcePoolUid,

                       (MAlfEnvObject*)(poolContainer.get()));

    if ( err != KErrNone)

        {

        ALF_THROW(AlfWidgetException, ECommonError, "Failed to add AlfEnv extension");

        }

    else

        {

        poolContainer.release();

        }   

    }

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

// Returns the reference for Resource Pool extension object. 

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

//

OSN_EXPORT ResourcePool& AlfWidgetEnvExtension::resourcePool( CAlfEnv& aEnv)

    {

    Alf::AlfExtensionResourcePoolContainer* poolContainer = 

        static_cast<Alf::AlfExtensionResourcePoolContainer*>(aEnv.Extension( KAlfExtensionResourcePoolUid));

    if ( poolContainer == NULL)

        {

        initializeEnvironment(aEnv);

        }

    //re-fetch the pool

    poolContainer = 

        static_cast<Alf::AlfExtensionResourcePoolContainer*>(aEnv.Extension( KAlfExtensionResourcePoolUid));

    return *(poolContainer->mResourcePool);

}

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

// Initializes environment with factory extension

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

//    

void AlfWidgetEnvExtension::initializeEnvironmentForFactory(CAlfEnv& aEnv)

    {

    auto_ptr<AlfWidgetFactoryLoader> widgetFactoryLoader( 

                                         new (EMM) AlfWidgetFactoryLoader() );

    IAlfWidgetFactory* widgetFactory = NULL;

    widgetFactory = widgetFactoryLoader->loadWidgetFactory(aEnv);

    if(!widgetFactory)

        {

        ALF_THROW(AlfWidgetException, ECommonError, "Failed to create widget factory");

        }

    auto_ptr<AlfExtensionWidgetFactory> widgetFactoryExtension(

        new(EMM) AlfExtensionWidgetFactory( widgetFactoryLoader.release(),

                     widgetFactory));

    int err = aEnv.AddExtension( KAlfExtensionWidgetFactoryUid,

                       (MAlfEnvObject*)(widgetFactoryExtension.get()));

    if ( err != 0)

        {

        ALF_THROW(AlfWidgetException, ECommonError, "Failed to add AlfEnv extension");

        }

    else

        {

    	widgetFactoryExtension.release();

        }        

    }

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

// Returns the reference for Theme Manager extension object. 

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

//    

OSN_EXPORT AlfThemeManagerUtil& AlfWidgetEnvExtension::themeManagerUtil( CAlfEnv& /*aEnv*/)

    {

    // Depricated

    ALF_THROW(AlfWidgetException, EInvalidArgument, "Depricated Module");

    }

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

//Access to the widget factory

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

//        

OSN_EXPORT IAlfWidgetFactory& AlfWidgetEnvExtension::widgetFactory( 

    CAlfEnv& aEnv)

    {

    AlfExtensionWidgetFactory* widgetFactoryExtension = 

        static_cast<AlfExtensionWidgetFactory*>(

            aEnv.Extension( KAlfExtensionWidgetFactoryUid));

    if ( widgetFactoryExtension == NULL)

        {

        initializeEnvironmentForFactory(aEnv);

        }

    //re-fetch the widget factory extension

    widgetFactoryExtension = 

        static_cast<AlfExtensionWidgetFactory*>(

            aEnv.Extension( KAlfExtensionWidgetFactoryUid));

    return *(widgetFactoryExtension->mWidgetFactory);

    }    

    } // Alf