1 /*

     2 * Copyright (c) 2007-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Widget factory implementation file

    15 *

    16 */

    17 

    18 

    19 //STL includes

    20 #include <string.h>

    21 

    22 //ALF Client includes

    23 #include <alf/alfenv.h>

    24 #include <alf/alfdisplay.h>

    25 

    26 //OSN core includes

    27 #include <osn/ustring.h>

    28 #include <osn/alfptrvector.h>

    29 

    30 //Widget Utils includes

    31 #include <alf/alfexceptions.h>

    32 

    33 //Widget factory includes

    34 #include <alf/ialffactoryplugin.h>

    35 

    36 //Widget Model includes

    37 #include <alf/ialfwidget.h>

    38 #include <alf/ialfmodel.h>

    39 #include <alf/ialfwidgetcontrol.h>

    40 #include <alf/ialfelement.h>

    41 #include "alf/ialfvisualtemplate.h"

    42 #include <alf/ialfwidgeteventhandler.h>

    43 #include <alf/ialflayoutmanager.h>

    44 

    45 //View Widget includes

    46 #include <alf/ialfviewwidget.h>

    47 

    48 //Local Includes

    49 #include "alfwidgetfactory.h"

    50 

    51 using namespace osncore;

    52 

    53 namespace Alf

    54     {

    55 

    56 static const char* const KViewWidgetProductId = "viewwidget";

    57         

    58     

    59 static IAlfViewWidget* createDefaultViewWidget(

    60     const char* aInstanceId,

    61     int aControlGroupID,

    62     DuiNode* aNode,

    63     CAlfDisplay& aDisplay,

    64     CAlfEnv& aEnv,

    65     IAlfFactoryPlugin& aFactoryPlugin,

    66     const char* aFilePath,

    67     AlfCustomInitDataBase* aCustomData)

    68     {

    69     IAlfViewWidget* ret = 0;

    70     

    71     // Create construction parameter structure.

    72     AlfViewWidgetInitData init;

    73     

    74     // Zero out the data in the construction structure.

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

    76     

    77     // Set the construction parameters.

    78     init.mEnv = &aEnv;

    79     init.mDisplay = &aDisplay;    

    80     init.mWidgetId = aInstanceId;

    81     init.mControlGroupId = aControlGroupID;

    82     init.mNode = aNode;

    83     init.mFilePath = aFilePath;

    84     init.mCustomData = aCustomData;

    85     

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

    87     // interface.

    88     IAlfInterfaceBase* tmp = aFactoryPlugin.createProduct(

    89         KViewWidgetProductId, &init);

    90     if(tmp)

    91         {

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

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

    94         if(!ret)

    95             {

    96             // Interface not found. Delete the temporary product.	

    97             delete tmp;            	

    98             }	

    99         }

   100 

   101     return ret;

   102     }

   103 

   104 static IAlfWidget* createDefaultWidget(

   105     const char*     aLoadId,

   106     const char*     aInstanceId,

   107     IAlfContainerWidget& aContainerWidget,

   108     DuiNode*       aNode,

   109     CAlfEnv&        aEnv,

   110     IAlfFactoryPlugin&      aFactoryPlugin,

   111     const char* aFilePath,

   112     AlfCustomInitDataBase* aCustomData)

   113     {

   114     IAlfWidget* ret = 0;

   115     

   116     // Create construction parameter structure.

   117     AlfWidgetInitData init;

   118 

   119     // Zero out the data in the construction structure.

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

   121     

   122     // Set the construction parameters.    

   123     init.mEnv = &aEnv;

   124     init.mContainerWidget = &aContainerWidget;

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

   126     init.mNode = aNode;  

   127     init.mFilePath = aFilePath;  

   128     init.mCustomData = aCustomData;

   129 

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

   131     // interface.

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

   133     if(tmp)

   134         {

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

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

   137         if(!ret)

   138             {

   139             // Interface not found. Delete the temporary product.	

   140             delete tmp;            	

   141             }	

   142         }

   143 

   144     return ret;       

   145     }

   146 

   147 static IAlfModel* createDefaultModel(

   148     const char* aLoadId,

   149     IAlfFactoryPlugin& aFactoryPlugin,

   150     AlfCustomInitDataBase* aCustomData)

   151     {

   152     IAlfModel* ret = 0;

   153 

   154     // Create construction parameter structure.

   155     AlfModelInitData init;

   156 

   157     // Zero out the data in the construction structure.

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

   159 

   160     // Set the construction parameters.        

   161     init.mCustomData = aCustomData;

   162 

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

   164     // interface.

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

   166     if(tmp)

   167         {

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

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

   170         if(!ret)

   171             {

   172             // Interface not found. Delete the temporary product.	

   173             delete tmp;            	

   174             }	

   175         }

   176    

   177     return ret;           

   178     }

   179 

   180 static IAlfWidgetControl* createDefaultControl(

   181     const char* aLoadId,

   182     CAlfDisplay& aDisplay,

   183     IAlfFactoryPlugin& aFactoryPlugin,

   184     AlfCustomInitDataBase* aCustomData)

   185     {

   186     IAlfWidgetControl* ret(0);

   187 

   188     // Create construction parameter structure.

   189     AlfWidgetControlInitData init;

   190 

   191     // Zero out the data in the construction structure.

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

   193 

   194     // Set the construction parameters.        

   195     init.mDisplay = &aDisplay;    

   196     init.mCustomData = aCustomData;

   197  

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

   199     // interface.

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

   201     if(tmp)

   202         {

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

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

   205         if(!ret)

   206             {

   207             // Interface not found. Delete the temporary product.	

   208             delete tmp;            	

   209             }	

   210         }

   211    

   212     return ret;       

   213     }

   214 

   215 static IAlfElement* createDefaultElement(

   216     const char* aLoadId, 

   217     const char* aInstanceId, 

   218     DuiNode* aNode,

   219     IAlfWidgetControl& aControl,

   220     IAlfFactoryPlugin& aFactoryPlugin,

   221     AlfCustomInitDataBase* aCustomData)

   222     {

   223     IAlfElement* ret(0);

   224     

   225     // Create construction parameter structure.

   226     AlfElementInitData init;

   227 

   228     // Zero out the data in the construction structure.

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

   230 

   231     // Set the construction parameters.        

   232     init.mControl= &aControl;

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

   234     init.mNode= aNode;

   235     init.mCustomData = aCustomData; 

   236  

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

   238     // interface.

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

   240     if(tmp)

   241         {

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

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

   244         if(!ret)

   245             {

   246             // Interface not found. Delete the temporary product.	

   247             delete tmp;            	

   248             }	

   249         }

   250 

   251     return ret;       

   252     }   

   253 

   254 static IAlfVisualTemplate* createDefaultVisualTemplate(

   255     const char* aLoadId, 

   256     const char* aInstanceId,

   257     DuiNode* aNode,

   258     IAlfFactoryPlugin& aFactoryPlugin,

   259     AlfCustomInitDataBase* aCustomData)

   260     {

   261     IAlfVisualTemplate* ret(0);

   262         

   263     // Create construction parameter structure.

   264     AlfVisualTemplateInitData init;

   265 

   266     // Zero out the data in the construction structure.

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

   268 

   269     // Set the construction parameters.        

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

   271     init.mNode= aNode;

   272     init.mCustomData = aCustomData;

   273 

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

   275     // interface.

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

   277     if(tmp)

   278         {

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

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

   281         if(!ret)

   282             {

   283             // Interface not found. Delete the temporary product.	

   284             delete tmp;            	

   285             }	

   286         }

   287         

   288     return ret;       

   289     }

   290        

   291 static IAlfWidgetEventHandler* createDefaultEventHandler(

   292     const char* aLoadId,

   293     const char* aInstanceId,

   294     DuiNode* aNode,

   295     IAlfFactoryPlugin& aFactoryPlugin,

   296     AlfCustomInitDataBase* aCustomData)

   297     {

   298     IAlfWidgetEventHandler* ret(0);

   299         

   300     // Create construction parameter structure.

   301     AlfWidgetEventHandlerInitData init;

   302 

   303     // Zero out the data in the construction structure.

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

   305 

   306     // Set the construction parameters.        

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

   308     init.mNode= aNode;

   309     init.mCustomData = aCustomData;

   310     

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

   312     // interface.

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

   314     if(tmp)

   315         {

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

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

   318         if(!ret)

   319             {

   320             // Interface not found. Delete the temporary product.	

   321             delete tmp;            	

   322             }	

   323         }

   324 

   325     return ret;       

   326     }

   327     

   328 static IAlfLayoutManager* createDefaultLayoutManager(

   329     const char* aLoadId,

   330     const char* aInstanceId,

   331     DuiNode* aNode,

   332     IAlfFactoryPlugin& aFactoryPlugin,

   333     AlfCustomInitDataBase* aCustomData)

   334     {

   335     IAlfLayoutManager* ret(0);

   336 

   337     // Create construction parameter structure.

   338     AlfLayoutManagerInitData init;

   339 

   340     // Zero out the data in the construction structure.

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

   342 

   343     // Set the construction parameters.        

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

   345     init.mNode= aNode;

   346     init.mCustomData = aCustomData;

   347 

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

   349     // interface.

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

   351     if(tmp)

   352         {

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

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

   355         if(!ret)

   356             {

   357             // Interface not found. Delete the temporary product.	

   358             delete tmp;            	

   359             }	

   360         }

   361 

   362     return ret;       

   363     }

   364 

   365 static IAlfViewWidget* createRegisteredViewWidget(

   366     const char* aInstanceId,

   367     int aControlGroupID,

   368     DuiNode* aNode,

   369     CAlfEnv& aEnv,

   370     CAlfDisplay& aDisplay,

   371     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   372     const char* aFilePath,    

   373     AlfCustomInitDataBase* aCustomData)

   374     {

   375     IAlfViewWidget* ret(0);

   376     IAlfInterfaceBase* tmp(0);

   377 

   378     // Create construction parameter structure.    

   379     AlfViewWidgetInitData init;

   380 

   381     // Zero out the data in the construction structure.

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

   383 

   384     // Set the construction parameters.        

   385     init.mEnv = &aEnv;

   386     init.mDisplay = &aDisplay;    

   387     init.mWidgetId = aInstanceId;

   388     init.mControlGroupId = aControlGroupID;

   389     init.mNode = aNode;

   390     init.mFilePath = aFilePath;    

   391     init.mCustomData = aCustomData;

   392     

   393     // Run through registered factories.     

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

   395         {

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

   397         // interface.

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

   399         if(tmp)

   400             {

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

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

   403             if(!ret)

   404                 {

   405                 // Interface not found. Delete the temporary product.	

   406                 delete tmp;    

   407                 tmp=0;        	

   408                 }	

   409             }

   410         }

   411         

   412     return ret;     

   413     }

   414         

   415 static IAlfWidget* createRegisteredWidget(

   416     const char* aLoadId,

   417     const char* aInstanceId,

   418     IAlfContainerWidget& aContainerWidget,

   419     DuiNode*   aNode,

   420     CAlfEnv&    aEnv,

   421     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   422     const char* aFilePath,

   423     AlfCustomInitDataBase* aCustomData)

   424     {

   425     IAlfWidget* ret(0);

   426     IAlfInterfaceBase* tmp(0);

   427 

   428     // Create construction parameter structure.        

   429     AlfWidgetInitData init;

   430 

   431     // Zero out the data in the construction structure.

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

   433 

   434     // Set the construction parameters.        

   435     init.mEnv = &aEnv;

   436     init.mContainerWidget = &aContainerWidget;

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

   438     init.mNode = aNode;    

   439     init.mFilePath= aFilePath;

   440     init.mCustomData = aCustomData;

   441         

   442     // Run through registered factories.     

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

   444         {

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

   446         // interface.

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

   448         if(tmp)

   449             {

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

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

   452             if(!ret)

   453                 {

   454                 // Interface not found. Delete the temporary product.	

   455                 delete tmp;    

   456                 tmp=0;        	

   457                 }	

   458             }

   459         }

   460 

   461     return ret;       

   462     }

   463 

   464 static IAlfModel* createRegisteredModel(

   465     const char* aLoadId,

   466     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   467     AlfCustomInitDataBase* aCustomData)

   468     {

   469     IAlfModel* ret(0);

   470     IAlfInterfaceBase* tmp(0);

   471 

   472     // Create construction parameter structure.

   473     AlfModelInitData init;

   474 

   475     // Zero out the data in the construction structure.

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

   477 

   478     // Set the construction parameters.        

   479     init.mCustomData = aCustomData;

   480         

   481     // Run through registered factories.     

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

   483         {

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

   485         // interface.

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

   487         if(tmp)

   488             {

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

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

   491             if(!ret)

   492                 {

   493                 // Interface not found. Delete the temporary product.	

   494                 delete tmp;    

   495                 tmp=0;        	

   496                 }	

   497             }

   498         }

   499 

   500     return ret;     

   501     }

   502    

   503 static IAlfWidgetControl* createRegisteredControl(

   504     const char* aLoadId,

   505     CAlfDisplay& aDisplay,

   506     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   507     AlfCustomInitDataBase* aCustomData)

   508     {

   509     IAlfWidgetControl* ret(0);

   510     IAlfInterfaceBase* tmp(0);

   511 

   512 

   513     // Create construction parameter structure.

   514     AlfWidgetControlInitData init;

   515 

   516     // Zero out the data in the construction structure.

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

   518 

   519     // Set the construction parameters.        

   520     init.mDisplay = &aDisplay;    

   521     init.mCustomData = aCustomData;

   522  

   523     // Run through registered factories.     

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

   525         {

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

   527         // interface.

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

   529         if(tmp)

   530             {

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

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

   533             if(!ret)

   534                 {

   535                 // Interface not found. Delete the temporary product.	

   536                 delete tmp;    

   537                 tmp=0;        	

   538                 }	

   539             }

   540         }

   541     

   542     return ret;       

   543     }

   544     

   545 static IAlfElement* createRegisteredElement(

   546     const char* aLoadId, 

   547     const char* aInstanceId,

   548     DuiNode*   aNode, 

   549     IAlfWidgetControl& aControl,

   550     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   551     AlfCustomInitDataBase* aCustomData)

   552     {

   553     IAlfElement* ret(0);

   554     IAlfInterfaceBase* tmp(0);

   555     

   556     // Create construction parameter structure.

   557     AlfElementInitData init;

   558 

   559     // Zero out the data in the construction structure.

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

   561 

   562     // Set the construction parameters.        

   563     init.mControl= &aControl;

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

   565     init.mNode= aNode;

   566     init.mCustomData = aCustomData; 

   567  

   568     // Run through registered factories.     

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

   570         {

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

   572         // interface.

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

   574         if(tmp)

   575             {

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

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

   578             if(!ret)

   579                 {

   580                 // Interface not found. Delete the temporary product.	

   581                 delete tmp;    

   582                 tmp=0;        	

   583                 }	

   584             }

   585         }

   586 

   587     return ret;       

   588     }

   589     

   590 static IAlfVisualTemplate* createRegisteredVisualTemplate(

   591     const char* aLoadId, 

   592     const char* aInstanceId,

   593     DuiNode* aNode,

   594     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   595     AlfCustomInitDataBase* aCustomData)

   596     {

   597     IAlfVisualTemplate* ret(0);

   598     IAlfInterfaceBase* tmp(0);

   599 

   600     // Create construction parameter structure.

   601     AlfVisualTemplateInitData init;

   602 

   603     // Zero out the data in the construction structure.

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

   605 

   606     // Set the construction parameters.        

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

   608     init.mNode= aNode;

   609     init.mCustomData = aCustomData;

   610  

   611     // Run through registered factories.     

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

   613         {

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

   615         // interface.

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

   617         if(tmp)

   618             {

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

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

   621             if(!ret)

   622                 {

   623                 // Interface not found. Delete the temporary product.	

   624                 delete tmp;    

   625                 tmp=0;        	

   626                 }	

   627             }

   628         }

   629 

   630     return ret;  

   631     }

   632 

   633 static IAlfWidgetEventHandler* createRegisteredEventHandler(

   634     const char* aLoadId,

   635     const char* aInstanceId,

   636     DuiNode*   aNode,

   637     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   638     AlfCustomInitDataBase* aCustomData)

   639     {

   640     IAlfWidgetEventHandler* ret(0);

   641     IAlfInterfaceBase* tmp(0);

   642 

   643     // Create construction parameter structure.

   644     AlfWidgetEventHandlerInitData init;

   645 

   646     // Zero out the data in the construction structure.

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

   648 

   649     // Set the construction parameters.        

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

   651     init.mNode= aNode;

   652     init.mCustomData = aCustomData;

   653 

   654     // Run through registered factories.     

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

   656         {

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

   658         // interface.

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

   660         if(tmp)

   661             {

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

   663             ret = IAlfInterfaceBase::makeInterface<IAlfWidgetEventHandler>(

   664                                                                       tmp);

   665             if(!ret)

   666                 {

   667                 // Interface not found. Delete the temporary product.	

   668                 delete tmp;    

   669                 tmp=0;        	

   670                 }	

   671             }

   672         }

   673 

   674     return ret;       

   675     }

   676     

   677 static IAlfLayoutManager* createRegisteredLayoutManager(

   678     const char* aLoadId,

   679     const char* aInstanceId,    

   680     DuiNode* aNode,

   681     AlfPtrVector<IAlfFactoryPlugin>& aFactoryList,

   682     AlfCustomInitDataBase* aCustomData)

   683     {

   684     IAlfLayoutManager* ret(0);

   685     IAlfInterfaceBase* tmp(0);

   686 

   687     // Create construction parameter structure.

   688     AlfLayoutManagerInitData init;

   689 

   690     // Zero out the data in the construction structure.

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

   692 

   693     // Set the construction parameters.        

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

   695     init.mNode= aNode;

   696     init.mCustomData = aCustomData;

   697 

   698     // Run through registered factories.     

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

   700         {

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

   702         // interface.

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

   704         if(tmp)

   705             {

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

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

   708             if(!ret)

   709                 {

   710                 // Interface not found. Delete the temporary product.	

   711                 delete tmp;    

   712                 tmp=0;        	

   713                 }	

   714             }

   715         }

   716 

   717     return ret;

   718     }    

   719                 

   720 

   721 AlfWidgetFactory::AlfWidgetFactory(CAlfEnv& aAlfEnv):

   722     mAlfEnv(aAlfEnv)

   723     {

   724     mWidgetList.setAutoDelete(true);

   725     }

   726 

   727 AlfWidgetFactory::~AlfWidgetFactory()

   728     {

   729     mWidgetList.clear();

   730     mRegisteredFactoryList.clear();

   731     }

   732 

   733 IAlfViewWidget* AlfWidgetFactory::createViewWidget(

   734     const char* aInstanceId, 

   735     int aControlGroupID, 

   736     DuiNode* aNode, 

   737     CAlfDisplay* aDisplay, 

   738     const char* aFilePath, 

   739     AlfCustomInitDataBase* aCustomData)

   740     {

   741     IAlfViewWidget* ret(0);

   742     auto_ptr<IAlfViewWidget> autoptr = auto_ptr<IAlfViewWidget>(0);

   743 

   744     IAlfFactoryPlugin* factoryPlugin = mFactoryPluginLoader.loadFactoryPlugin(

   745                                                         KViewWidgetProductId);    

   746     

   747     CAlfDisplay* display = aDisplay;

   748 

   749     //Check there is already a widget with the same instance ID.

   750     if(findWidget(aInstanceId))

   751         {

   752     	  ALF_THROW(AlfWidgetException,EInvalidWidgetInstanceId,

   753     	      "Instance ID same as an existing widget.")

   754         }

   755             

   756     //Both node and presentation declaration file handle cannot have 

   757     //non-null value at the same time.

   758     if(aNode && aFilePath)

   759         {

   760     	  ALF_THROW(AlfWidgetException,EInvalidArgument,

   761     	      "Both node & presentation declaration file handle cannot have non-null values at the same time")

   762         }

   763         

   764     if(!display)

   765         {

   766         if(mAlfEnv.DisplayCount() == 0)

   767             {

   768             // No display objects defined in the environment. 

   769             // Throw an exception.

   770             ALF_THROW(AlfException, EDisplayNotFound, 

   771             "No display found from environment.Unable to associate a display with the view widget.");

   772             }

   773         display = &mAlfEnv.PrimaryDisplay();    

   774         }    

   775     

   776     // Try default factory first    

   777     if(factoryPlugin)

   778         {

   779         autoptr.reset(createDefaultViewWidget(

   780                           aInstanceId,aControlGroupID,aNode,*display, 

   781                           mAlfEnv,*factoryPlugin,aFilePath,aCustomData));

   782         }

   783 

   784     // Then try registered factories

   785     if(!autoptr.get())

   786         {        

   787         autoptr.reset(createRegisteredViewWidget(

   788                           aInstanceId,aControlGroupID,aNode, 

   789                           mAlfEnv,*display,mRegisteredFactoryList, 

   790                           aFilePath,aCustomData));

   791         }

   792         

   793     if(autoptr.get() != 0)

   794         {

   795         // If trap occurs throw exception. Created widget will be automatically

   796         // destroyed since it is in auto pointer.

   797         TRAPD(err, appendWidget(

   798               IAlfInterfaceBase::makeInterface<IAlfWidget>(autoptr.get())));

   799         if(err != KErrNone)

   800             {

   801             ALF_THROW(AlfException, err, 

   802                 "Appending created widget to environment failed.");

   803             }

   804             

   805         // After succesfull call to AppendWidgetL we can release the autoptr.

   806         ret = autoptr.release();

   807         }

   808         

   809     return ret;

   810     }

   811 

   812 IAlfWidget* AlfWidgetFactory::createWidget(

   813     const char* aLoadId,

   814     const char* aInstanceId,

   815     IAlfContainerWidget& aContainerWidget,

   816     DuiNode* aNode,

   817     const char* aFilePath,

   818     AlfCustomInitDataBase* aCustomData)

   819     {

   820     IAlfWidget* ret(0);

   821     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

   822                                                                      aLoadId); 

   823 

   824     //Check there is already a widget with the same instance ID.

   825     if(findWidget(aInstanceId))

   826         {

   827     	  ALF_THROW(AlfWidgetException,EInvalidWidgetInstanceId,

   828     	      "Instance ID same as an existing widget.")

   829         }

   830         

   831     //Both node and presentation declaration file handle cannot have 

   832     //non-null value at the same time.

   833     if(aNode && aFilePath)

   834         {

   835     	  ALF_THROW(AlfWidgetException,EInvalidArgument,

   836     	      "Both node & presentation declaration file handle cannot have non-null values at the same time")

   837         }

   838     

   839     // Try first default factory    

   840     if(pluginFactory)

   841         {

   842         ret = createDefaultWidget(

   843                   aLoadId,aInstanceId,aContainerWidget,aNode,

   844                   mAlfEnv,*pluginFactory,aFilePath,aCustomData);    

   845         }

   846 

   847     // Then try registered factories

   848     if(!ret)

   849         {

   850         ret = createRegisteredWidget(

   851                   aLoadId,aInstanceId,aContainerWidget,aNode,mAlfEnv,

   852                   mRegisteredFactoryList,aFilePath,aCustomData);        

   853         }

   854         

   855     if(ret)

   856         {

   857         TRAPD(err, appendWidget(ret));

   858         if(err != KErrNone)

   859             {

   860             delete ret;	

   861             ALF_THROW(AlfException, err, 

   862                 "Appending created widget to environment failed.");

   863             }

   864         }

   865 

   866     return ret;

   867     }

   868 

   869 int AlfWidgetFactory::destroyWidget(IAlfWidget* aWidget)

   870     {

   871     int ret = -1;

   872     int widgetCount = mWidgetList.count();

   873     for ( int i = 0; i < widgetCount; ++i ) 

   874         {        

   875         if ( mWidgetList[i] == aWidget )

   876             {            

   877             // remove and destroy the widget

   878             mWidgetList.remove( i );

   879             ret = 0;

   880             break; ;

   881             }

   882         }    

   883     return ret;

   884     }

   885     

   886 int AlfWidgetFactory::appendWidget(IAlfWidget* aWidget)

   887     {

   888     int ret = 0;

   889     int widgetCount = mWidgetList.count();

   890     for ( int i = 0; i < widgetCount; ++i ) 

   891         {        

   892         if ( mWidgetList[i] == aWidget )

   893             {

   894             ret = -1;

   895             break; ;

   896             }

   897         }

   898     if(ret != -1 ) 

   899 	    {

   900 	    mWidgetList.resize( mWidgetList.count()+1);

   901     	mWidgetList.insert( mWidgetList.count(), aWidget );	

   902 	    }

   903 	return ret;

   904     }

   905     

   906 IAlfWidget* AlfWidgetFactory::findWidget(const char* aWidgetName) const

   907     {

   908     IAlfWidget* ret(NULL);

   909     int widgetCount = mWidgetList.count();

   910     for(int i=0; i<widgetCount && !ret; i++)

   911         {

   912         const char* widgetName = mWidgetList[i]->widgetName();

   913         if(!strcmp(widgetName,aWidgetName))

   914             {

   915             ret = mWidgetList[i];    

   916             }

   917         }

   918     return ret;

   919     }

   920 

   921 IAlfModel* AlfWidgetFactory::createModel(

   922     const char* aLoadId,

   923     AlfCustomInitDataBase* aCustomData)

   924     {

   925     IAlfModel* ret(0);

   926     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

   927                                                                      aLoadId);

   928 

   929     // Try first default factory

   930     if(pluginFactory)

   931         {

   932         ret = createDefaultModel(aLoadId,*pluginFactory, aCustomData);    

   933         }

   934 

   935     // Then try registered factories        

   936     if(!ret)

   937         {

   938         ret = createRegisteredModel(

   939                   aLoadId,mRegisteredFactoryList,aCustomData);        

   940         }

   941     

   942     return ret;

   943     }

   944     

   945 IAlfWidgetControl* AlfWidgetFactory::createControl(

   946     const char* aLoadId,

   947     const char* aInstanceId,

   948     CAlfDisplay* aDisplay,

   949     AlfCustomInitDataBase* aCustomData)

   950     {

   951     IAlfWidgetControl* ret(0);    	

   952     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

   953                                                                      aLoadId);

   954     //Compiler warning removal. Left here for future use cases.

   955     (void)aInstanceId; 

   956     

   957     CAlfDisplay* display = aDisplay;

   958     

   959     if(!display)

   960         {

   961         display = &mAlfEnv.PrimaryDisplay();    

   962         }

   963   

   964     // Try first default factory

   965     if(pluginFactory)

   966     	{

   967     	 ret = createDefaultControl(aLoadId,*display,*pluginFactory,aCustomData);

   968     	}

   969 

   970     // Then try registered factories         

   971     if(!ret)

   972         {

   973         ret = createRegisteredControl(

   974                   aLoadId,*display,mRegisteredFactoryList,aCustomData);        

   975         }

   976 

   977     return ret;     

   978     }

   979 

   980 IAlfElement* AlfWidgetFactory::createElement(

   981     const char* aLoadId,

   982     const char* aInstanceId, 

   983     IAlfWidgetControl& aControl,

   984     DuiNode* aNode,

   985     AlfCustomInitDataBase* aCustomData)

   986     {

   987     IAlfElement* ret(0);

   988     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

   989                                                                      aLoadId);

   990 

   991     // Try first default factory

   992     if (pluginFactory)

   993         {

   994         ret = createDefaultElement(

   995                   aLoadId,aInstanceId,aNode,aControl,

   996                   *pluginFactory,aCustomData);

   997         }

   998 

   999     // Then try registered factories                 

  1000     if(!ret)

  1001         {

  1002         ret = createRegisteredElement(

  1003                   aLoadId,aInstanceId,aNode,aControl,

  1004                   mRegisteredFactoryList,aCustomData);        

  1005         }

  1006 

  1007     return ret;    

  1008     }

  1009    

  1010 IAlfVisualTemplate* AlfWidgetFactory::createVisualTemplate(

  1011     const char* aLoadId,

  1012     const char* aInstanceId,

  1013     DuiNode* aNode,

  1014     AlfCustomInitDataBase* aCustomData )

  1015     {

  1016      

  1017     IAlfVisualTemplate* ret(0);

  1018     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

  1019                                                                      aLoadId);

  1020 

  1021     // Try first default factory                                                                 

  1022     if (pluginFactory)

  1023         {

  1024         ret = createDefaultVisualTemplate(

  1025                   aLoadId,aInstanceId,aNode,*pluginFactory,aCustomData);

  1026         }

  1027         

  1028     // Then try registered factories          

  1029     if(!ret)

  1030         {

  1031         ret = createRegisteredVisualTemplate(

  1032                   aLoadId,aInstanceId,aNode,

  1033                   mRegisteredFactoryList,aCustomData);        

  1034         }

  1035         

  1036     return ret;         

  1037     }

  1038     

  1039 IAlfWidgetEventHandler* AlfWidgetFactory::createEventHandler(

  1040     const char* aLoadId,

  1041     const char* aInstanceId,

  1042     DuiNode* aNode,

  1043     AlfCustomInitDataBase* aCustomData )

  1044     {

  1045     IAlfWidgetEventHandler* ret(0);

  1046     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

  1047                                                                      aLoadId);

  1048 

  1049     // Try first default factory

  1050     if (pluginFactory)

  1051         {

  1052         ret = createDefaultEventHandler(

  1053                   aLoadId,aInstanceId,aNode,*pluginFactory,aCustomData);

  1054         }

  1055 

  1056     // Then try registered factories        

  1057     if(!ret)

  1058         {

  1059         ret = createRegisteredEventHandler(

  1060                   aLoadId,aInstanceId,aNode,

  1061                   mRegisteredFactoryList,aCustomData);        

  1062         }

  1063         

  1064     return ret;    

  1065     }

  1066     

  1067 IAlfLayoutManager* AlfWidgetFactory::createLayoutManager(

  1068     const char* aLoadId, 

  1069     const char* aInstanceId, 

  1070     DuiNode* aNode, 

  1071     AlfCustomInitDataBase* aCustomData)

  1072     {

  1073     IAlfLayoutManager* ret(0);

  1074     IAlfFactoryPlugin* pluginFactory = mFactoryPluginLoader.loadFactoryPlugin(

  1075                                                                      aLoadId);

  1076 

  1077     // Try first default factory

  1078     if (pluginFactory)

  1079         {

  1080         ret = createDefaultLayoutManager(

  1081                   aLoadId,aInstanceId,aNode,*pluginFactory,aCustomData);

  1082         }

  1083     

  1084     // Then try registered factories         

  1085     if(!ret)

  1086         {

  1087         ret = createRegisteredLayoutManager(

  1088                   aLoadId,aInstanceId,aNode,

  1089                   mRegisteredFactoryList,aCustomData);

  1090         }

  1091         

  1092     return ret;

  1093     }

  1094 

  1095 void AlfWidgetFactory::registerCustomWidgetFactory(

  1096     IAlfFactoryPlugin* aFactory)

  1097     {

  1098     mRegisteredFactoryList.resize(mRegisteredFactoryList.count()+1);

  1099     mRegisteredFactoryList.insert(mRegisteredFactoryList.count(),aFactory);

  1100     }

  1101     

  1102 IAlfInterfaceBase* AlfWidgetFactory::makeInterface(const IfId& aType)

  1103     {

  1104     if ( !strcmp(aType.mImplementationId, 

  1105                  IAlfWidgetFactory::type().mImplementationId) )

  1106         {

  1107         return static_cast<IAlfWidgetFactory*>(this);

  1108         }

  1109     

  1110     return 0;

  1111     }

  1112     } // namespace Alf    

  1113 

  1114 // End of File