1 /*

     2 * Copyright (c) 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:  The base class for all widget controls.

    15 *

    16 */

    17 

    18 

    19 #include <alf/alfevent.h>

    20 

    21 #include "alf/alfwidget.h"

    22 #include <alf/alfwidgetcontrol.h>

    23 #include <alf/alfmodel.h>

    24 #include <alf/alfwidgeteventhandler.h>

    25 #include "alf/alfelement.h"

    26 #include <alf/alfvarianttype.h>

    27 #include "alf/alfmodeloperation.h"

    28 #include <osn/ustring.h>

    29 #include <osn/alfptrvector.h>

    30 #include <alf/alfexceptions.h>

    31 #include <alf/alfenv.h>

    32 #include <alf/alfcontrolgroup.h>

    33 #include <alf/ialflayoutmanager.h>

    34 #include <alf/alfwidgetevents.h>

    35 #include "alf/ialfattributeowner.h"

    36 #include <osn/osnnew.h>

    37 #include <assert.h>

    38 

    39 #include "alfhostapiimpl.h"

    40 #include "alfwidgetcontroleventfilter.h"

    41 

    42 using namespace osncore;

    43 

    44 namespace Alf

    45     {

    46 // ======== INTERNAL DATA TYPES ========

    47 

    48 // Forward declared inside the Alf namespace

    49 

    50 

    51 //Internal Class to Store the Element Data

    52 class ElementData

    53     {

    54 public:

    55     //Default constructor

    56     ElementData():mElement(0)

    57         {

    58         }

    59     //Destructor

    60     ~ElementData()

    61         {

    62         delete mElement;

    63         }

    64     /**

    65      * The element. Own.

    66      */

    67     IAlfElement* mElement;

    68 

    69     /**

    70      * The data id range for the element.

    71      */

    72     uint mDataIdRange;

    73     };

    74 

    75 class AlfWidgetControlImpl

    76     {

    77 

    78 public:

    79     AlfWidgetControlImpl():mWidget(0),mEventFilter(0),mAlfHostAPIImpl(0)

    80         {

    81 

    82         }

    83     ~AlfWidgetControlImpl()

    84         {

    85 

    86         }

    87 public:

    88     /**

    89      * The element data. Elements are owned by the control.

    90      */

    91     AlfPtrVector<ElementData> mElementArray;

    92 

    93     /**

    94      * The event handlers. Event handlers are owned by the control.

    95      */

    96     AlfPtrVector<IAlfWidgetEventHandler> mEventHandlerArray;

    97 

    98     /**

    99      * The owner widget.

   100      */

   101     AlfWidget* mWidget;

   102     

   103     /**

   104      * PointerUp Event Filter.

   105      */

   106     AlfWidgetControlEventFilter *mEventFilter;

   107     

   108     /**

   109      * The state of the control.

   110      * The state is a combination of binary state flags.

   111      */

   112     uint mState;

   113     /**

   114      * AlfAPIImpl auto pointer.

   115      * This will be used to provide container control's functionality by 

   116      * widget control.Owned.

   117      */

   118     auto_ptr<AlfHostAPIImpl> mAlfHostAPIImpl;

   119     };

   120 

   121 // ======== MEMBER FUNCTIONS ========

   122 

   123 OSN_EXPORT CAlfWidgetControl::CAlfWidgetControl(CAlfEnv& aEnv)

   124     {

   125     construct(aEnv);

   126     }

   127 

   128 OSN_EXPORT CAlfWidgetControl::CAlfWidgetControl()

   129     {

   130     }

   131 

   132 OSN_EXPORT void* CAlfWidgetControl::operator new(

   133                  size_t aSize, newarg /*aEnumVal*/)  throw (std::bad_alloc)

   134     { 

   135     void* ret = 0;

   136     TRAPD(err, ret = CBase::operator new((TUint)aSize, ELeave));

   137     if(err != KErrNone)

   138         {

   139         throw std::bad_alloc();

   140         }

   141     return ret;         

   142     } 

   143 

   144 OSN_EXPORT void CAlfWidgetControl::construct(

   145     CAlfEnv& aEnv)

   146     {

   147     mWdgtControlData.reset( new (EMM) AlfWidgetControlImpl() );

   148     mWdgtControlData->mWidget = 0;

   149     //by default control is focusable and enabled

   150     mWdgtControlData->mState = IAlfWidgetControl::Focusable |

   151         IAlfWidgetControl::Enabled;

   152 

   153     // Call CAlfControl second phase constructor

   154     TRAPD(err, CAlfControl::ConstructL( aEnv ));

   155     if(err != KErrNone)

   156         {

   157         ALF_THROW(AlfException, err, "CAlfWidgetControl::construction failed.");

   158         }

   159     mWdgtControlData->mElementArray.setAutoDelete(true);

   160     mWdgtControlData->mEventHandlerArray.setAutoDelete(true);

   161     mWdgtControlData->mAlfHostAPIImpl.reset(0);

   162 

   163     // Instatiate Event filter

   164     mWdgtControlData->mEventFilter = 

   165         new (EMM) AlfWidgetControlEventFilter();

   166     addEventHandler(mWdgtControlData->mEventFilter);

   167     }

   168 

   169 OSN_EXPORT CAlfWidgetControl::~CAlfWidgetControl()

   170     {

   171     //release all connections

   172     while (this->ConnectionCount())

   173         {

   174         this->RemoveConnection(&(this->Connection(0)));

   175         }

   176     mWdgtControlData->mElementArray.setAutoDelete(true);

   177     

   178     for(int i = 0; i < mWdgtControlData->mElementArray.count(); ++i)

   179         {

   180         // Fetch the element

   181         IAlfElement *element = mWdgtControlData->mElementArray[i]->mElement;

   182 

   183         // If the element is also an event handler

   184         IAlfWidgetEventHandler* eventHandler =

   185         IAlfInterfaceBase::makeInterface<IAlfWidgetEventHandler>( element );

   186         int eventHandlerIndex = 

   187             mWdgtControlData->mEventHandlerArray.findRef( eventHandler );

   188         if ( eventHandler && eventHandlerIndex != KErrNotFound )

   189             {

   190              //cache auto delete state.

   191             bool autoDeleteState = 

   192                 mWdgtControlData->mEventHandlerArray.autoDelete();

   193             mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   194             mWdgtControlData->mEventHandlerArray.remove( eventHandlerIndex );

   195              //restore auto delete state.

   196             mWdgtControlData->mEventHandlerArray.setAutoDelete(

   197                                                      autoDeleteState);

   198             }

   199         }

   200     

   201     mWdgtControlData->mElementArray.clear();

   202         

   203     mWdgtControlData->mEventHandlerArray.setAutoDelete(true);

   204     mWdgtControlData->mEventHandlerArray.clear(); 

   205     	 

   206     if(mWdgtControlData->mWidget)

   207         {

   208         // false: don't delete twice

   209         mWdgtControlData->mWidget->setControl(0, false);

   210         mWdgtControlData->mWidget = 0;

   211         }

   212     }

   213 

   214 OSN_EXPORT uint CAlfWidgetControl::state() const

   215     {

   216     // Verify that the internal state stored in the member variable

   217     // is in sync with the CAlfWidget state. This might not be the case

   218     // if someone has called CAlfWidget APIs, e.g. AcquireFocus(), directly.

   219     

   220     if ( Focus() )

   221         {

   222         mWdgtControlData->mState |= IAlfWidgetControl::Focused;

   223         }

   224     else

   225         {

   226         mWdgtControlData->mState &= ~IAlfWidgetControl::Focused;

   227         }

   228 

   229     return mWdgtControlData->mState;

   230     }

   231 

   232 OSN_EXPORT void CAlfWidgetControl::setState( uint aState )

   233     {

   234      // Checks the state invariants. Throws exceptions if not OK

   235     checkStateInvariants(aState);

   236     

   237     // Visible

   238     if ( aState & IAlfWidgetControl::Visible )

   239         {

   240         enableStateVisible();

   241         }

   242     else

   243         {

   244         disableStateVisible();

   245         }

   246 

   247     // Enabled

   248     if ( aState & IAlfWidgetControl::Enabled )

   249         {

   250         enableStateEnabled();

   251         }

   252     else

   253         {

   254         disableStateEnabled();

   255         }

   256 

   257     // Focused

   258     if ( aState & IAlfWidgetControl::Focused )

   259         {

   260         enableStateFocused();

   261         }

   262     else

   263         {

   264         disableStateFocused();

   265         }        

   266 

   267     // Focusable

   268     if ( aState & IAlfWidgetControl::Focusable )

   269         {

   270         enableStateFocusable();

   271         }

   272     else

   273         {

   274         disableStateFocusable();

   275         }        

   276     }

   277 

   278 OSN_EXPORT void CAlfWidgetControl::enableState( uint aState )

   279     {

   280     // Predicts the state and checks the state invariants.

   281     // Throws exceptions if not OK

   282     predictAndCheckStateInvariants(aState, true);

   283 

   284     // Visible

   285     if ( aState & IAlfWidgetControl::Visible )

   286         {

   287         enableStateVisible();

   288         }

   289 

   290     // Enabled

   291     if ( aState & IAlfWidgetControl::Enabled )

   292         {

   293         enableStateEnabled();

   294         }

   295 

   296     // Set Focusable. This is done first, before putting on fucus

   297     if ( aState & IAlfWidgetControl::Focusable )

   298         {

   299         enableStateFocusable();

   300         }

   301         

   302     // Focused

   303     if ( aState & IAlfWidgetControl::Focused )

   304         {

   305         enableStateFocused();

   306         }

   307 

   308     }

   309 

   310 OSN_EXPORT void CAlfWidgetControl::disableState( uint aState )

   311     {

   312     // Predicts the state and checks the state invariants.

   313     // Throws exceptions if not OK

   314     predictAndCheckStateInvariants(aState, false);

   315 

   316     // Visible

   317     if ( aState & IAlfWidgetControl::Visible )

   318         {

   319         disableStateVisible();

   320         }

   321 

   322     // Enabled

   323     if ( aState & IAlfWidgetControl::Enabled )

   324         {

   325         disableStateEnabled();

   326         }

   327 

   328     // Focused

   329     if ( aState & IAlfWidgetControl::Focused )

   330         {

   331         disableStateFocused();

   332         }

   333 

   334     // Focusable

   335     if ( aState & IAlfWidgetControl::Focusable )

   336         {

   337         disableStateFocusable();

   338         }

   339     }

   340 

   341 OSN_EXPORT bool CAlfWidgetControl::checkState( uint aState ) const

   342     {

   343     return ( state() & aState );

   344     }

   345 

   346 OSN_EXPORT int CAlfWidgetControl::numEventHandlers() const

   347     {

   348     return mWdgtControlData->mEventHandlerArray.count();

   349     }

   350 

   351 OSN_EXPORT IAlfWidgetEventHandler& CAlfWidgetControl::eventHandler(

   352     int aIndex )

   353     {

   354     return *mWdgtControlData->mEventHandlerArray[aIndex];

   355     }

   356 

   357 OSN_EXPORT int CAlfWidgetControl::eventHandlerIndex(

   358     IAlfWidgetEventHandler& aEventHandler ) const

   359     {

   360     for ( int i = 0; i < mWdgtControlData->mEventHandlerArray.count(); ++i )

   361         {

   362         if ( mWdgtControlData->mEventHandlerArray[i] == &aEventHandler )

   363             {

   364             return i;

   365             }

   366         }

   367     return -1;

   368     }

   369 

   370 OSN_EXPORT IAlfWidgetEventHandler* CAlfWidgetControl::findEventHandler(

   371     const TAlfEvent& aEvent )

   372     {

   373     for ( int i = 0; i < mWdgtControlData->mEventHandlerArray.count(); ++i )

   374         {

   375         if ( mWdgtControlData->mEventHandlerArray[i]->accept( *this, aEvent ) )

   376             {

   377             return mWdgtControlData->mEventHandlerArray[i];

   378             }

   379         }

   380     return 0;

   381     }

   382 

   383 OSN_EXPORT void CAlfWidgetControl::addEventHandler(

   384     IAlfWidgetEventHandler* aEventHandler, int aIndex )

   385     {

   386     try

   387         {

   388         if ( mWdgtControlData->mEventHandlerArray.findRef( aEventHandler ) == 

   389              KErrNotFound )

   390             {

   391             if ( aIndex == -1 )

   392                 {

   393                 mWdgtControlData->mEventHandlerArray.resize(

   394                     mWdgtControlData->mEventHandlerArray.count()+1);

   395                 mWdgtControlData->mEventHandlerArray.insert(

   396                     mWdgtControlData->mEventHandlerArray.count(),

   397                     aEventHandler );

   398                 }

   399             else

   400                 {

   401                 mWdgtControlData->mEventHandlerArray.resize(

   402                     mWdgtControlData->mEventHandlerArray.count()+1);

   403                 mWdgtControlData->mEventHandlerArray.insert( aIndex,

   404                                                          aEventHandler);

   405                 }

   406             }

   407         }

   408     catch (...)

   409         {

   410         ALF_THROW(AlfWidgetException,ECommonError,"CAlfWidgetControl: Adding event handler failed.")

   411         }

   412     }

   413 

   414 OSN_EXPORT void CAlfWidgetControl::removeAndDestroyEventHandler(

   415     IAlfWidgetEventHandler& aEventHandler )

   416     {

   417 

   418     for (int i =0; i<mWdgtControlData->mEventHandlerArray.count();i++)

   419         {

   420         if (mWdgtControlData->mEventHandlerArray[i] == &aEventHandler)

   421             {

   422             IAlfWidgetEventHandler *handler = 

   423                 mWdgtControlData->mEventHandlerArray[i];

   424             //check if it is an eventhandler associated with presentation 

   425             if(handler->eventHandlerType() == 

   426                IAlfWidgetEventHandler::EPresentationEventHandler)

   427                 {

   428                 ElementData* elementData = 0;

   429                 // if the event handller is also an element, remove the 

   430                 // corresponding element data from mEventHandlerArray

   431                 elementData = removePesentationElementData(*handler);

   432                 // if the element data does not exist, remove the event handler

   433                 // from mEventHandlerArray and destroy it 

   434                 if(!elementData)

   435                     {

   436                     mWdgtControlData->mEventHandlerArray.remove( i );

   437                     }

   438                 // remove the event hanlder from the array but dont destroy it,

   439                 // and then delete element data which in turn will destroy the

   440                 // element and thus the event handler

   441                 else

   442                     {

   443                     // cache auto delete state.

   444                     bool autoDeleteState = 

   445                         mWdgtControlData->mEventHandlerArray.autoDelete(); 

   446                     mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   447                     mWdgtControlData->mEventHandlerArray.remove( i );

   448                     // restore auto delete state.

   449                     mWdgtControlData->mEventHandlerArray.setAutoDelete(

   450                                                              autoDeleteState);

   451                     delete elementData;

   452                     }

   453                 }

   454             else

   455                 {

   456                 mWdgtControlData->mEventHandlerArray.remove( i );

   457                 }

   458             return;

   459             }

   460 

   461         }

   462 

   463     }

   464 

   465 OSN_EXPORT void CAlfWidgetControl::removeEventHandler(

   466     IAlfWidgetEventHandler& aEventHandler )

   467     {

   468     for (int i =0; i<mWdgtControlData->mEventHandlerArray.count();i++)

   469         {

   470         if (mWdgtControlData->mEventHandlerArray[i] == &aEventHandler)

   471             {

   472             // cache auto delete state.

   473             bool autoDeleteState = 

   474                 mWdgtControlData->mEventHandlerArray.autoDelete();

   475             mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   476             mWdgtControlData->mEventHandlerArray.remove( i );

   477             // restore auto delete state.

   478             mWdgtControlData->mEventHandlerArray.setAutoDelete(

   479                                                      autoDeleteState);

   480             return;

   481             }

   482         }

   483     }

   484 

   485 OSN_EXPORT void CAlfWidgetControl::removeAndDestroyEventHandler(

   486     const UString& aHandlerId )

   487     {

   488     for (int i =0; i<mWdgtControlData->mEventHandlerArray.count();i++)

   489         {

   490         IAlfWidgetEventHandler* handler = 

   491             mWdgtControlData->mEventHandlerArray[i];

   492         AlfWidgetEventHandlerInitData* eventData = handler->eventHandlerData();

   493         if(eventData != 0)

   494             {

   495             //check for the event id/name

   496             if (!aHandlerId.compare(eventData->mWidgetEventHandlerId))

   497                 {

   498                 //check if it is an eventhandler associated with presentation 

   499                 if(handler->eventHandlerType() == 

   500                    IAlfWidgetEventHandler::EPresentationEventHandler)

   501                     {

   502                     ElementData* elementData = 0;

   503                     // if the event handller is also an element, remove the 

   504                     // corresponding element data from mEventHandlerArray

   505                     elementData = removePesentationElementData(*handler);

   506                     // if the element data does not exist, remove the event 

   507                     // handler from mEventHandlerArray and destroy it 

   508                     if(!elementData)

   509                         {

   510                         // removes and destoys the event handler

   511                         mWdgtControlData->mEventHandlerArray.remove( i );

   512                         }

   513                     // remove the event hanlder from the array but dont destroy

   514                     // it, and then delete element data which in turn will 

   515                     // destroy the element and thus the event handler      

   516                     else

   517                         {

   518                         // cache auto delete state.

   519                         bool autoDeleteState = 

   520                             mWdgtControlData->mEventHandlerArray.autoDelete();

   521                         mWdgtControlData->mEventHandlerArray.setAutoDelete(

   522                                                                  false);

   523                         mWdgtControlData->mEventHandlerArray.remove( i );

   524                         // restore auto delete state.

   525                         mWdgtControlData->mEventHandlerArray.setAutoDelete(

   526                                                              autoDeleteState);

   527                         //delete element data

   528                         delete elementData;

   529                         }

   530                     }

   531                 else

   532                     {

   533                     mWdgtControlData->mEventHandlerArray.remove( i );

   534                     }

   535                 return;

   536                 }

   537             }

   538         

   539         }

   540     }

   541     

   542 OSN_EXPORT void CAlfWidgetControl::removeAndDestroyPresentationEventHandlers()

   543     {

   544     int i=0;

   545     while(i<mWdgtControlData->mEventHandlerArray.count())

   546         {

   547         IAlfWidgetEventHandler* handler = 

   548                                     mWdgtControlData->mEventHandlerArray[i];

   549         

   550         //check if it is an eventhandler associated with presentation 

   551         if(handler->eventHandlerType() == 

   552                IAlfWidgetEventHandler::EPresentationEventHandler)

   553             {

   554             ElementData* elementData = 0;

   555             // if the event handller is also an element, remove the 

   556             // corresponding element data from mEventHandlerArray

   557             elementData = removePesentationElementData(*handler);

   558             // if the element data does not exist, remove the event handler

   559             // from mEventHandlerArray and destroy it 

   560             if(!elementData)

   561                 {

   562                 mWdgtControlData->mEventHandlerArray.remove( i );

   563                 }

   564             // remove the event hanlder from the array but dont destroy it,

   565             // and then delete element data which in turn will destroy the

   566             // element and thus the event handler    

   567             else

   568                 {

   569                 // cache auto delete state.

   570                 bool autoDeleteState = 

   571                     mWdgtControlData->mEventHandlerArray.autoDelete();

   572                 mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   573                 mWdgtControlData->mEventHandlerArray.remove( i );

   574                 // restore auto delete state.

   575                 mWdgtControlData->mEventHandlerArray.setAutoDelete(

   576                                                          autoDeleteState);

   577                 //delete element data

   578                 delete elementData;

   579                 }

   580             }

   581         else

   582             {

   583             i++;

   584             }

   585         }

   586     

   587     }

   588     

   589 OSN_EXPORT void CAlfWidgetControl::removePresentationEventHandlers()

   590     {

   591     int i=0;

   592     // cache auto delete state.

   593     bool autoDeleteState = mWdgtControlData->mEventHandlerArray.autoDelete();

   594     mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   595     while(i<mWdgtControlData->mEventHandlerArray.count())

   596         {

   597         IAlfWidgetEventHandler* handler = 

   598                                     mWdgtControlData->mEventHandlerArray[i];

   599         //check if it is an eventhandler associated with presentation 

   600         if(handler->eventHandlerType() == 

   601            IAlfWidgetEventHandler::EPresentationEventHandler)

   602             {

   603             mWdgtControlData->mEventHandlerArray.remove( i );

   604             }

   605         else

   606             {

   607             i++;

   608             }

   609         }

   610     // restore auto delete state.    

   611     mWdgtControlData->mEventHandlerArray.setAutoDelete(autoDeleteState);

   612     }

   613 

   614 ElementData* CAlfWidgetControl::removePesentationElementData( 

   615     IAlfWidgetEventHandler& aEventHandler )

   616     {

   617     IAlfElement* element =

   618         IAlfInterfaceBase::makeInterface<IAlfElement>( &aEventHandler );

   619         

   620     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   621         {

   622         if ( mWdgtControlData->mElementArray[i]->mElement == element )

   623             {

   624             // cache auto delete state.

   625             bool autoDeleteState = 

   626                 mWdgtControlData->mElementArray.autoDelete();

   627             mWdgtControlData->mElementArray.setAutoDelete(false);

   628             // Store the Element Data which is to be removed.

   629             // This pointer will be returned to the caller

   630             ElementData* elementData = mWdgtControlData->mElementArray[i];

   631             mWdgtControlData->mElementArray.remove( i );

   632             // restore auto delete state.

   633             mWdgtControlData->mElementArray.setAutoDelete(autoDeleteState);

   634             return elementData;;

   635             }

   636         }

   637     return 0;

   638     }

   639 

   640 OSN_EXPORT int CAlfWidgetControl::numElements() const

   641     {

   642     return mWdgtControlData->mElementArray.count();

   643     }

   644 

   645 OSN_EXPORT IAlfElement& CAlfWidgetControl::element( int aIndex )

   646     {

   647     return *(mWdgtControlData->mElementArray[aIndex]->mElement);

   648     }

   649 

   650 OSN_EXPORT IAlfElement* CAlfWidgetControl::findElement( const char* aName )

   651     {

   652     UString name(aName);

   653     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   654         {

   655         IAlfElement* element = mWdgtControlData->mElementArray[i]->mElement;

   656         if (name == UString(element->name()))

   657             {

   658             return element;

   659             }

   660         }

   661     return 0;

   662     }

   663 

   664 OSN_EXPORT void CAlfWidgetControl::addElement( IAlfElement* aElement )

   665     {

   666     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   667         {

   668         if ( mWdgtControlData->mElementArray[i]->mElement == aElement )

   669             {

   670             return; // Already exists

   671             }

   672         }

   673     auto_ptr<ElementData> elemData( new (EMM) ElementData() );

   674     elemData->mElement = aElement;

   675     elemData->mDataIdRange = 0xFFFFFFFF;

   676     try

   677         {

   678         mWdgtControlData->mElementArray.resize(

   679                               mWdgtControlData->mElementArray.count()+1);

   680         mWdgtControlData->mElementArray.insert(

   681                               mWdgtControlData->mElementArray.count(),

   682                               elemData.get() );

   683         elemData.release(); // ownership transferred

   684         }

   685     catch (...)

   686         {

   687         // change the element of element data to 0.

   688         // this will ensure that the element does not get deleted when the 

   689         // elemData gets out of scope, since elemData was not successfully 

   690         // added to the array

   691         elemData->mElement = 0;

   692         ALF_THROW(AlfException,ECommonError,"AlfWidgetControl: Adding the element failed.")

   693         }    

   694     }

   695 

   696 OSN_EXPORT void CAlfWidgetControl::removeAndDestroyElement(

   697     const IAlfElement& aElement )

   698     {

   699     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i ) 

   700         {

   701         if (mWdgtControlData->mElementArray[i])

   702             {

   703             if ( mWdgtControlData->mElementArray[i]->mElement == &aElement )

   704                 {

   705                 // Remove the element

   706                 IAlfElement *element = 

   707                                 mWdgtControlData->mElementArray[i]->mElement;

   708 

   709                 // If the element is also an event handler

   710                 IAlfWidgetEventHandler* eventHandler =

   711                     IAlfInterfaceBase::makeInterface<IAlfWidgetEventHandler>(

   712                                            element );

   713                 int eventHandlerIndex = 

   714                     mWdgtControlData->mEventHandlerArray.findRef(

   715                                           eventHandler );

   716                 if ( eventHandler && eventHandlerIndex != KErrNotFound )

   717                     {

   718                     // cache auto delete state.

   719                     bool autoDeleteState = 

   720                         mWdgtControlData->mEventHandlerArray.autoDelete();

   721                     mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

   722                     mWdgtControlData->mEventHandlerArray.remove(

   723                                                          eventHandlerIndex );

   724                     // restore auto delete state.

   725                     mWdgtControlData->mEventHandlerArray.setAutoDelete(

   726                                                              autoDeleteState);

   727                     }

   728                 // remove and destroy the element

   729                 mWdgtControlData->mElementArray.remove( i );

   730                 return;

   731                 }

   732 

   733             }

   734         }

   735     }

   736     

   737 OSN_EXPORT void CAlfWidgetControl::removeElement(const IAlfElement& aElement )

   738     {

   739     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i ) 

   740         {

   741         if (mWdgtControlData->mElementArray[i])

   742             {

   743             if ( mWdgtControlData->mElementArray[i]->mElement == &aElement )

   744                 {

   745                 // make the element pointer of elementData null, and then 

   746                 // destroy elementData. This will ensure that the memory

   747                 // allocated for the elementData is freed but the element

   748                 // is not destroyed

   749                 mWdgtControlData->mElementArray[i]->mElement = 0;

   750                 mWdgtControlData->mElementArray.remove(i);

   751                 return;

   752                 }

   753             }

   754         }

   755     }    

   756 

   757 OSN_EXPORT uint CAlfWidgetControl::elementDataId(

   758     const IAlfElement& aElement,

   759     uint aIndex,

   760     uint aParentDataId )

   761     {

   762     uint range = dataIdRange( aElement );

   763 

   764     if ( aIndex >= range )

   765         {

   766         }

   767     // In hierarchical element structures this may overflow

   768     return aParentDataId * range + aIndex;

   769     }

   770 

   771 OSN_EXPORT uint CAlfWidgetControl::parentElementDataId(

   772     const IAlfElement& aElement,

   773     uint aDataId )

   774     {

   775     uint dataIdRng = dataIdRange( aElement );

   776     if (0 == dataIdRng) return(0xFFFFFFFF);

   777     else

   778         return (uint)( aDataId / dataIdRange( aElement ) );

   779     }

   780 

   781 OSN_EXPORT uint CAlfWidgetControl::dataIdToIndex( 

   782     const IAlfElement& aElement,

   783     uint aDataId )

   784     {

   785     uint dataIdRng = dataIdRange( aElement );

   786     if (0 == dataIdRng) return(0xFFFFFFFF);

   787     else

   788         return aDataId % dataIdRange( aElement );

   789     }

   790 

   791 OSN_EXPORT IAlfVariantType* CAlfWidgetControl::elementData(

   792     const IAlfElement& aElement, uint aDataId )

   793     {

   794     if (!mWdgtControlData->mWidget)

   795         {

   796         return 0;	

   797         }

   798     IAlfModel* widgetModel = mWdgtControlData->mWidget->model();

   799     if ( !widgetModel )

   800         {

   801     	return 0;

   802         }

   803     IAlfVariantType* modelData = widgetModel->data();

   804     if ( !modelData || modelData->type() != IAlfVariantType::EMap )

   805         {

   806     	return 0;

   807         }

   808         

   809     IAlfMap* map = modelData->map();

   810 

   811     // Use "current" to traverse elements from the root to the leaf

   812     const IAlfElement* last = 0;

   813     while ( last != &aElement )

   814         {

   815         int currentDataId = aDataId;

   816         const IAlfElement* current;

   817         for ( current = &aElement ;

   818                 current->parentElement() != last ;

   819                 current = current->parentElement() )

   820             {

   821             currentDataId = parentElementDataId( *current, currentDataId );

   822             }

   823         int index = dataIdToIndex( *current, currentDataId );

   824         last = current;

   825 

   826         IAlfVariantType* data = map->item( UString(current->name()) );

   827         if ( data->type() == IAlfVariantType::EContainer )

   828             {

   829             data = data->container()->item( index );

   830             }

   831         if ( current == &aElement )

   832             {

   833             return data;

   834             }

   835         if ( data->type() == IAlfVariantType::EBranch )

   836             {

   837             // Continue with the child data

   838             map = data->branch()->childData();

   839             continue;

   840             }

   841         if ( data->type() == IAlfVariantType::EMap )

   842             {

   843             map = data->map();

   844             }

   845         else

   846             {

   847             return 0;

   848             }

   849         }

   850 

   851     return 0;

   852     }

   853 

   854 OSN_EXPORT void CAlfWidgetControl::setDataIdRange(

   855     const IAlfElement& aElement, uint aRange )

   856     {

   857     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   858         {

   859         if ( mWdgtControlData->mElementArray[i]->mElement == &aElement )

   860             {

   861             mWdgtControlData->mElementArray[i]->mDataIdRange = aRange;

   862             return;

   863             }

   864         }

   865     }

   866 

   867 OSN_EXPORT uint CAlfWidgetControl::dataIdRange( const IAlfElement& aElement )

   868     {

   869     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   870         {

   871         if ( mWdgtControlData->mElementArray[i]->mElement == &aElement )

   872             {

   873             return mWdgtControlData->mElementArray[i]->mDataIdRange;

   874             }

   875         }

   876     return 0;

   877     }

   878 

   879 OSN_EXPORT void CAlfWidgetControl::updatePresentation()

   880     {

   881     if ( !mWdgtControlData->mWidget || !mWdgtControlData->mWidget->model() ||

   882             !mWdgtControlData->mWidget->model()->data() ||

   883             mWdgtControlData->mWidget->model()->data()->type() != 

   884             IAlfVariantType::EMap )

   885         {

   886         return;

   887         }

   888     IAlfMap* map = mWdgtControlData->mWidget->model()->data()->map();

   889     for ( int i = 0; i < map->count(); ++i )

   890         {

   891         IAlfElement* element = findElement( map->name( i ).getUtf8() );

   892         if ( element )

   893             {

   894 

   895             int childInd = childIndex( *map, i, 0, true );

   896             IAlfVariantType* data = map->item( i );

   897             try

   898                 {

   899                 if ( data->type() == IAlfVariantType::EMap ||

   900                         data->type() == IAlfVariantType::EBranch)

   901                     {

   902                     // Data for a single presentation instance (visual tree)

   903                     element->createVisualTree( *data,

   904                         elementDataId( *element, childInd, 0 ),

   905                         element->defaultParentLayout( 0 ), childInd );

   906                     }

   907                 else if ( data->type() == IAlfVariantType::EContainer )

   908                     {

   909 

   910                     // Data for multiple presentation instances (visual trees)

   911                     IAlfContainer* container = data->container();

   912                     for ( int j = 0; j < container->count(); ++j )

   913                         {

   914                         element->createVisualTree( *container->item( j ),

   915                             elementDataId( *element, childInd + j, 0 ),

   916                             element->defaultParentLayout( 0 ), childInd + j );

   917                         }

   918                     }

   919                 }

   920             catch (...)

   921                 {

   922                 ALF_THROW(AlfVisualException,ECanNotCreateVisual,"CAlfWidgetControl::updatePresentation failed")

   923                 }

   924 

   925             }

   926 

   927         }

   928     }

   929 

   930 OSN_EXPORT void CAlfWidgetControl::destroyPresentation( int aTimeMilliseconds )

   931     {

   932     (void)aTimeMilliseconds;

   933 

   934     for ( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   935         {

   936         mWdgtControlData->mElementArray[i]->mElement->removeAndDestroyVisuals(

   937                                                           aTimeMilliseconds );

   938         }

   939     processEvent(TAlfEvent(EEventWidgetPresentationDestroyed));

   940     }

   941     

   942 OSN_EXPORT void CAlfWidgetControl::destroyVisualsAndElements(

   943     int aTimeMilliseconds )

   944     {

   945     (void)aTimeMilliseconds;

   946 

   947     // destroy visual trees from elements

   948     for( int i = 0; i < mWdgtControlData->mElementArray.count(); ++i )

   949         {

   950         mWdgtControlData->mElementArray[i]->mElement->removeAndDestroyVisuals(

   951                                                           aTimeMilliseconds );

   952         }

   953     // destroy elements

   954     while( numElements() )

   955         {

   956         removeAndDestroyElement( element(numElements()-1) );

   957         }	

   958 	

   959     // destroy presentation related event handlers

   960     removeAndDestroyPresentationEventHandlers();

   961 	

   962     // send notification

   963     processEvent(TAlfEvent(EEventWidgetPresentationDestroyed));		

   964     }

   965     

   966 OSN_EXPORT void CAlfWidgetControl::updateParentLayout()

   967     {

   968     //get the parent control

   969     CAlfWidgetControl* parent = dynamic_cast<CAlfWidgetControl*>(Host());

   970     if (parent)

   971         {

   972         IAlfLayoutManager* layoutManager = 

   973             CAlfWidgetControl::makeInterface<IAlfLayoutManager>(parent);

   974         if (layoutManager)

   975             {

   976             layoutManager->updateChildLayout(this);

   977             }

   978         }

   979     }

   980     

   981 OSN_EXPORT bool CAlfWidgetControl::isContainer() const

   982     {

   983     IAlfHostAPI* api = mWdgtControlData->mAlfHostAPIImpl.get();

   984     return (api && api->getConnectionCount() > 0);

   985     }

   986     

   987 OSN_EXPORT bool CAlfWidgetControl::isFocusable() const

   988     {

   989     return checkState(IAlfWidgetControl::Enabled) && 

   990            checkState(IAlfWidgetControl::Focusable);

   991     }

   992 

   993 void CAlfWidgetControl::setOwnerWidget( AlfWidget* aWidget )

   994     {

   995     mWdgtControlData->mWidget = aWidget;

   996     }

   997 

   998 OSN_EXPORT AlfWidget* CAlfWidgetControl::widget()

   999     {

  1000     return mWdgtControlData->mWidget;

  1001     }

  1002 

  1003 OSN_EXPORT AlfEventStatus CAlfWidgetControl::handleEvent(

  1004     const TAlfEvent& aEvent )

  1005     {

  1006     AlfEventStatus ret = EEventNotHandled;

  1007     if(isContainer())

  1008         {

  1009         CAlfWidgetControl* focused = 

  1010                     dynamic_cast<CAlfWidgetControl*>(FocusedConnection());

  1011         if(focused && aEvent.IsKeyEvent())

  1012             {

  1013             ret = focused->processEvent(aEvent);

  1014             }

  1015         else if ( aEvent.IsCustomEvent() )

  1016             {

  1017             int eventId = aEvent.CustomParameter();

  1018             switch(eventId)

  1019                 {

  1020                 case EEventFocusNextWidget:

  1021                     {

  1022                       if( handleFocusNext() )

  1023                           {

  1024                           ret = EEventConsumed;

  1025                           }

  1026                     }

  1027                     break;

  1028                 case EEventFocusPreviousWidget:

  1029                     {

  1030                       if( handleFocusPrevious() )

  1031                           {

  1032                           ret = EEventConsumed;

  1033                           }

  1034                     }

  1035                     break;

  1036                 }

  1037             }

  1038         }

  1039     return ret;

  1040 

  1041     }

  1042 

  1043 

  1044 OSN_EXPORT TBool CAlfWidgetControl::OfferEventL( const TAlfEvent& aEvent )

  1045     {

  1046     TBool ret(EFalse);

  1047     try

  1048         {

  1049         ret = processEvent(aEvent);  

  1050         }

  1051     catch(AlfException& ae)

  1052         {

  1053         int reason = ae.errorCode();

  1054         User::Leave( reason );

  1055         }

  1056     

  1057     return ret;

  1058     }

  1059     

  1060     

  1061     

  1062     

  1063  OSN_EXPORT AlfEventStatus CAlfWidgetControl::processEvent(

  1064     const TAlfEvent& aEvent )

  1065     {

  1066     AlfEventStatus ret(EEventNotHandled);

  1067     

  1068     /* If the event is not a custom event, stop execution if the widget is

  1069        not in enabled state. For custom event continue execution anyway. */

  1070     if(!(mWdgtControlData->mState & IAlfWidgetControl::Enabled) &&

  1071           !(aEvent.IsCustomEvent()))

  1072         {

  1073         return EEventNotHandled;    

  1074         }

  1075     

  1076     // Go through tunneling phase event handlers.

  1077     AlfEventStatus ret2 = ProcessEventHandlingPhase( tunneling, aEvent );

  1078     

  1079     if( ret2 == EEventConsumed )  

  1080         {

  1081         return EEventConsumed;  

  1082         }

  1083     else if ( ret2 == EEventHandled )     

  1084         {

  1085         ret = EEventHandled;

  1086         }

  1087 

  1088     // Execute business logic.

  1089     if(aEvent.IsPointerEvent())

  1090         {

  1091         if (aEvent.PointerDown() && isFocusable() && !Focus())

  1092              {

  1093              AcquireFocus();  

  1094              }

  1095         }

  1096     

  1097     ret2 = handleEvent( aEvent );

  1098     

  1099     if( ret2 == EEventConsumed )  

  1100         {

  1101         return EEventConsumed;  

  1102         }

  1103     else if ( ret2 == EEventHandled )     

  1104         {

  1105         ret = EEventHandled;

  1106         }

  1107     

  1108     // Go through bubbling phase event handlers.

  1109     ret2 = ProcessEventHandlingPhase( bubbling, aEvent );

  1110     

  1111     if( ret2 == EEventConsumed )  

  1112         {

  1113         return EEventConsumed;  

  1114         }

  1115     else if ( ret2 == EEventHandled )     

  1116         {

  1117         ret = EEventHandled;

  1118         }

  1119         

  1120     return ret;

  1121     }

  1122 

  1123 AlfEventStatus CAlfWidgetControl::ProcessEventHandlingPhase(

  1124     int aPhase, const TAlfEvent& aEvent )

  1125     {

  1126     // *** Implementation note ***

  1127     //

  1128     // offerEvent implementations may remove event handlers from the array that is

  1129     // being gone through. So that needs to be taken in consideration in the

  1130     // loop implementation.

  1131 

  1132     AlfEventStatus ret = EEventNotHandled;

  1133 

  1134     AlfPtrVector<IAlfWidgetEventHandler>& eventHandlerArray =