/*

* Copyright (c) 2007-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:  Widget factory implementation file

*

*/

//STL includes

#include <string.h>

//ALF Client includes

#include <alf/alfenv.h>

#include <alf/alfdisplay.h>

//OSN core includes

#include <osn/ustring.h>

#include <osn/alfptrvector.h>

//Widget Utils includes

#include <alf/alfexceptions.h>

//Widget factory includes

#include <alf/ialffactoryplugin.h>

//Widget Model includes

#include <alf/ialfwidget.h>

#include <alf/ialfmodel.h>

#include <alf/ialfwidgetcontrol.h>

#include <alf/ialfelement.h>

#include "alf/ialfvisualtemplate.h"

#include <alf/ialfwidgeteventhandler.h>

#include <alf/ialflayoutmanager.h>

//View Widget includes

#include <alf/ialfviewwidget.h>

//Local Includes

#include "alfwidgetfactory.h"

using namespace osncore;

namespace Alf

    {

static const char* const KViewWidgetProductId = "viewwidget";

static IAlfViewWidget* createDefaultViewWidget(

    const char* aInstanceId,

    int aControlGroupID,

    DuiNode* aNode,

    CAlfDisplay& aDisplay,

    CAlfEnv& aEnv,

    IAlfFactoryPlugin& aFactoryPlugin,

    const char* aFilePath,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfViewWidget* ret = 0;

    // Create construction parameter structure.

    AlfViewWidgetInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfViewWidgetInitData));

    // Set the construction parameters.

    init.mEnv = &aEnv;

    init.mDisplay = &aDisplay;    

    init.mWidgetId = aInstanceId;

    init.mControlGroupId = aControlGroupID;

    init.mNode = aNode;

    init.mFilePath = aFilePath;

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(

        KViewWidgetProductId, &init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.        	

        ret = IAlfInterfaceBase::makeInterface<IAlfViewWidget>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;

    }

static IAlfWidget* createDefaultWidget(

    const char*     aLoadId,

    const char*     aInstanceId,

    IAlfContainerWidget& aContainerWidget,

    DuiNode*       aNode,

    CAlfEnv&        aEnv,

    IAlfFactoryPlugin&      aFactoryPlugin,

    const char* aFilePath,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfWidget* ret = 0;

    // Create construction parameter structure.

    AlfWidgetInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfWidgetInitData));

    // Set the construction parameters.    

    init.mEnv = &aEnv;

    init.mContainerWidget = &aContainerWidget;

    init.mWidgetId = const_cast<char*>(aInstanceId);

    init.mNode = aNode;  

    init.mFilePath = aFilePath;  

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.        	

        ret = IAlfInterfaceBase::makeInterface<IAlfWidget>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }

static IAlfModel* createDefaultModel(

    const char* aLoadId,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfModel* ret = 0;

    // Create construction parameter structure.

    AlfModelInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfModelInitData));

    // Set the construction parameters.        

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfModel>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;           

    }

static IAlfWidgetControl* createDefaultControl(

    const char* aLoadId,

    CAlfDisplay& aDisplay,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfWidgetControl* ret(0);

    // Create construction parameter structure.

    AlfWidgetControlInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfWidgetControlInitData));

    // Set the construction parameters.        

    init.mDisplay = &aDisplay;    

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfWidgetControl>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }

static IAlfElement* createDefaultElement(

    const char* aLoadId, 

    const char* aInstanceId, 

    DuiNode* aNode,

    IAlfWidgetControl& aControl,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfElement* ret(0);

    // Create construction parameter structure.

    AlfElementInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfElementInitData));

    // Set the construction parameters.        

    init.mControl= &aControl;

    init.mElementId = const_cast<char*>(aInstanceId);

    init.mNode= aNode;

    init.mCustomData = aCustomData; 

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfElement>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }   

static IAlfVisualTemplate* createDefaultVisualTemplate(

    const char* aLoadId, 

    const char* aInstanceId,

    DuiNode* aNode,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfVisualTemplate* ret(0);

    // Create construction parameter structure.

    AlfVisualTemplateInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfVisualTemplateInitData));

    // Set the construction parameters.        

    init.mVisualTemplateId = const_cast<char*>(aInstanceId);

    init.mNode= aNode;

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfVisualTemplate>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }

static IAlfWidgetEventHandler* createDefaultEventHandler(

    const char* aLoadId,

    const char* aInstanceId,

    DuiNode* aNode,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfWidgetEventHandler* ret(0);

    // Create construction parameter structure.

    AlfWidgetEventHandlerInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfWidgetEventHandlerInitData));

    // Set the construction parameters.        

    init.mWidgetEventHandlerId = const_cast<char*>(aInstanceId);

    init.mNode= aNode;

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId,&init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfWidgetEventHandler>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }

static IAlfLayoutManager* createDefaultLayoutManager(

    const char* aLoadId,

    const char* aInstanceId,

    DuiNode* aNode,

    IAlfFactoryPlugin& aFactoryPlugin,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfLayoutManager* ret(0);

    // Create construction parameter structure.

    AlfLayoutManagerInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfLayoutManagerInitData));

    // Set the construction parameters.        

    init.mLayoutManagerId = const_cast<char*>(aInstanceId);

    init.mNode= aNode;

    init.mCustomData = aCustomData;

    // Create a temporary factory product and typecast it to the correct 

    // interface.

    IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(aLoadId, &init);

    if(tmp)

        {

        // Object created. Attempt to typecast to correct interface.

        ret = IAlfInterfaceBase::makeInterface<IAlfLayoutManager>(tmp);

        if(!ret)

            {

            // Interface not found. Delete the temporary product.	

            delete tmp;            	

            }	

        }

    return ret;       

    }

static IAlfViewWidget* createRegisteredViewWidget(

    const char* aInstanceId,

    int aControlGroupID,

    DuiNode* aNode,

    CAlfEnv& aEnv,

    CAlfDisplay& aDisplay,

    AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

    const char* aFilePath,    

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfViewWidget* ret(0);

    IAlfInterfaceBase* tmp(0);

    // Create construction parameter structure.    

    AlfViewWidgetInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfViewWidgetInitData));

    // Set the construction parameters.        

    init.mEnv = &aEnv;

    init.mDisplay = &aDisplay;    

    init.mWidgetId = aInstanceId;

    init.mControlGroupId = aControlGroupID;

    init.mNode = aNode;

    init.mFilePath = aFilePath;    

    init.mCustomData = aCustomData;

    // Run through registered factories.     

    for(int i=0;i<aFactoryList.count()&&!ret;i++)

        {

        // Create a temporary factory product and typecast it to the correct 

        // interface.

        tmp = aFactoryList.at(i)->createProduct(KViewWidgetProductId,&init);   

        if(tmp)

            {

            // Object created. Attempt to typecast to correct interface.

            ret = IAlfInterfaceBase::makeInterface<IAlfViewWidget>(tmp);

            if(!ret)

                {

                // Interface not found. Delete the temporary product.	

                delete tmp;    

                tmp=0;        	

                }	

            }

        }

    return ret;     

    }

static IAlfWidget* createRegisteredWidget(

    const char* aLoadId,

    const char* aInstanceId,

    IAlfContainerWidget& aContainerWidget,

    DuiNode*   aNode,

    CAlfEnv&    aEnv,

    AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

    const char* aFilePath,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfWidget* ret(0);

    IAlfInterfaceBase* tmp(0);

    // Create construction parameter structure.        

    AlfWidgetInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfWidgetInitData));

    // Set the construction parameters.        

    init.mEnv = &aEnv;

    init.mContainerWidget = &aContainerWidget;

    init.mWidgetId = const_cast<char*>(aInstanceId);

    init.mNode = aNode;    

    init.mFilePath= aFilePath;

    init.mCustomData = aCustomData;

    // Run through registered factories.     

    for(int i=0;i<aFactoryList.count()&&!ret;i++)

        {

        // Create a temporary factory product and typecast it to the correct 

        // interface.

        tmp = aFactoryList.at(i)->createProduct(aLoadId,&init);   

        if(tmp)

            {

            // Object created. Attempt to typecast to correct interface.

            ret = IAlfInterfaceBase::makeInterface<IAlfWidget>(tmp);

            if(!ret)

                {

                // Interface not found. Delete the temporary product.	

                delete tmp;    

                tmp=0;        	

                }	

            }

        }

    return ret;       

    }

static IAlfModel* createRegisteredModel(

    const char* aLoadId,

    AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfModel* ret(0);

    IAlfInterfaceBase* tmp(0);

    // Create construction parameter structure.

    AlfModelInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfModelInitData));

    // Set the construction parameters.        

    init.mCustomData = aCustomData;

    // Run through registered factories.     

    for(int i=0;i<aFactoryList.count()&&!ret;i++)

        {

        // Create a temporary factory product and typecast it to the correct 

        // interface.

        tmp = aFactoryList.at(i)->createProduct(aLoadId,&init);   

        if(tmp)

            {

            // Object created. Attempt to typecast to correct interface.

            ret = IAlfInterfaceBase::makeInterface<IAlfModel>(tmp);

            if(!ret)

                {

                // Interface not found. Delete the temporary product.	

                delete tmp;    

                tmp=0;        	

                }	

            }

        }

    return ret;     

    }

static IAlfWidgetControl* createRegisteredControl(

    const char* aLoadId,

    CAlfDisplay& aDisplay,

    AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

    AlfCustomInitDataBase* aCustomData)

    {

    IAlfWidgetControl* ret(0);

    IAlfInterfaceBase* tmp(0);

    // Create construction parameter structure.

    AlfWidgetControlInitData init;

    // Zero out the data in the construction structure.

    memset(&init, 0, sizeof(AlfWidgetControlInitData));

    // Set the construction parameters.        

    init.mDisplay = &aDisplay;    

    init.mCustomData = aCustomData;

    // Run through registered factories.     

    for(int i=0;i<aFactoryList.count()&&!ret;i++)

        {

        // Create a temporary factory product and typecast it to the correct 

        // interface.

        tmp = aFactoryList.at(i)->createProduct(aLoadId,&init);