/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  The base class for all widget controls.

*

*/

#include <alf/alfevent.h>

#include "alf/alfwidget.h"

#include <alf/alfwidgetcontrol.h>

#include <alf/alfmodel.h>

#include <alf/alfwidgeteventhandler.h>

#include "alf/alfelement.h"

#include <alf/alfvarianttype.h>

#include "alf/alfmodeloperation.h"

#include <osn/ustring.h>

#include <osn/alfptrvector.h>

#include <alf/alfexceptions.h>

#include <alf/alfenv.h>

#include <alf/alfcontrolgroup.h>

#include <alf/ialflayoutmanager.h>

#include <alf/alfwidgetevents.h>

#include "alf/ialfattributeowner.h"

#include <osn/osnnew.h>

#include <assert.h>

#include "alfhostapiimpl.h"

#include "alfwidgetcontroleventfilter.h"

using namespace osncore;

namespace Alf

    {

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

// Forward declared inside the Alf namespace

//Internal Class to Store the Element Data

class ElementData

    {

public:

    //Default constructor

    ElementData():mElement(0)

        {

        }

    //Destructor

    ~ElementData()

        {

        delete mElement;

        }

    /**

     * The element. Own.

     */

    IAlfElement* mElement;

    /**

     * The data id range for the element.

     */

    uint mDataIdRange;

    };

class AlfWidgetControlImpl

    {

public:

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

        {

        }

    ~AlfWidgetControlImpl()

        {

        }

public:

    /**

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

     */

    AlfPtrVector<ElementData> mElementArray;

    /**

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

     */

    AlfPtrVector<IAlfWidgetEventHandler> mEventHandlerArray;

    /**

     * The owner widget.

     */

    AlfWidget* mWidget;

    /**

     * PointerUp Event Filter.

     */

    AlfWidgetControlEventFilter *mEventFilter;

    /**

     * The state of the control.

     * The state is a combination of binary state flags.

     */

    uint mState;

    /**

     * AlfAPIImpl auto pointer.

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

     * widget control.Owned.

     */

    auto_ptr<AlfHostAPIImpl> mAlfHostAPIImpl;

    };

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

OSN_EXPORT CAlfWidgetControl::CAlfWidgetControl(CAlfEnv& aEnv)

    {

    construct(aEnv);

    }

OSN_EXPORT CAlfWidgetControl::CAlfWidgetControl()

    {

    }

OSN_EXPORT void* CAlfWidgetControl::operator new(

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

    { 

    void* ret = 0;

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

    if(err != KErrNone)

        {

        throw std::bad_alloc();

        }

    return ret;         

    } 

OSN_EXPORT void CAlfWidgetControl::construct(

    CAlfEnv& aEnv)

    {

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

    mWdgtControlData->mWidget = 0;

    //by default control is focusable and enabled

    mWdgtControlData->mState = IAlfWidgetControl::Focusable |

        IAlfWidgetControl::Enabled;

    // Call CAlfControl second phase constructor

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

    if(err != KErrNone)

        {

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

        }

    mWdgtControlData->mElementArray.setAutoDelete(true);

    mWdgtControlData->mEventHandlerArray.setAutoDelete(true);

    mWdgtControlData->mAlfHostAPIImpl.reset(0);

    // Instatiate Event filter

    mWdgtControlData->mEventFilter = 

        new (EMM) AlfWidgetControlEventFilter();

    addEventHandler(mWdgtControlData->mEventFilter);

    }

OSN_EXPORT CAlfWidgetControl::~CAlfWidgetControl()

    {

    //release all connections

    while (this->ConnectionCount())

        {

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

        }

    mWdgtControlData->mElementArray.setAutoDelete(true);

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

        {

        // Fetch the element

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

        // If the element is also an event handler

        IAlfWidgetEventHandler* eventHandler =

        IAlfInterfaceBase::makeInterface<IAlfWidgetEventHandler>( element );

        int eventHandlerIndex = 

            mWdgtControlData->mEventHandlerArray.findRef( eventHandler );

        if ( eventHandler && eventHandlerIndex != KErrNotFound )

            {

             //cache auto delete state.

            bool autoDeleteState = 

                mWdgtControlData->mEventHandlerArray.autoDelete();

            mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

            mWdgtControlData->mEventHandlerArray.remove( eventHandlerIndex );

             //restore auto delete state.

            mWdgtControlData->mEventHandlerArray.setAutoDelete(

                                                     autoDeleteState);

            }

        }

    mWdgtControlData->mElementArray.clear();

    mWdgtControlData->mEventHandlerArray.setAutoDelete(true);

    mWdgtControlData->mEventHandlerArray.clear(); 

    if(mWdgtControlData->mWidget)

        {

        // false: don't delete twice

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

        mWdgtControlData->mWidget = 0;

        }

    }

OSN_EXPORT uint CAlfWidgetControl::state() const

    {

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

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

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

    if ( Focus() )

        {

        mWdgtControlData->mState |= IAlfWidgetControl::Focused;

        }

    else

        {

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

        }

    return mWdgtControlData->mState;

    }

OSN_EXPORT void CAlfWidgetControl::setState( uint aState )

    {

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

    checkStateInvariants(aState);

    // Visible

    if ( aState & IAlfWidgetControl::Visible )

        {

        enableStateVisible();

        }

    else

        {

        disableStateVisible();

        }

    // Enabled

    if ( aState & IAlfWidgetControl::Enabled )

        {

        enableStateEnabled();

        }

    else

        {

        disableStateEnabled();

        }

    // Focused

    if ( aState & IAlfWidgetControl::Focused )

        {

        enableStateFocused();

        }

    else

        {

        disableStateFocused();

        }        

    // Focusable

    if ( aState & IAlfWidgetControl::Focusable )

        {

        enableStateFocusable();

        }

    else

        {

        disableStateFocusable();

        }        

    }

OSN_EXPORT void CAlfWidgetControl::enableState( uint aState )

    {

    // Predicts the state and checks the state invariants.

    // Throws exceptions if not OK

    predictAndCheckStateInvariants(aState, true);

    // Visible

    if ( aState & IAlfWidgetControl::Visible )

        {

        enableStateVisible();

        }

    // Enabled

    if ( aState & IAlfWidgetControl::Enabled )

        {

        enableStateEnabled();

        }

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

    if ( aState & IAlfWidgetControl::Focusable )

        {

        enableStateFocusable();

        }

    // Focused

    if ( aState & IAlfWidgetControl::Focused )

        {

        enableStateFocused();

        }

    }

OSN_EXPORT void CAlfWidgetControl::disableState( uint aState )

    {

    // Predicts the state and checks the state invariants.

    // Throws exceptions if not OK

    predictAndCheckStateInvariants(aState, false);

    // Visible

    if ( aState & IAlfWidgetControl::Visible )

        {

        disableStateVisible();

        }

    // Enabled

    if ( aState & IAlfWidgetControl::Enabled )

        {

        disableStateEnabled();

        }

    // Focused

    if ( aState & IAlfWidgetControl::Focused )

        {

        disableStateFocused();

        }

    // Focusable

    if ( aState & IAlfWidgetControl::Focusable )

        {

        disableStateFocusable();

        }

    }

OSN_EXPORT bool CAlfWidgetControl::checkState( uint aState ) const

    {

    return ( state() & aState );

    }

OSN_EXPORT int CAlfWidgetControl::numEventHandlers() const

    {

    return mWdgtControlData->mEventHandlerArray.count();

    }

OSN_EXPORT IAlfWidgetEventHandler& CAlfWidgetControl::eventHandler(

    int aIndex )

    {

    return *mWdgtControlData->mEventHandlerArray[aIndex];

    }

OSN_EXPORT int CAlfWidgetControl::eventHandlerIndex(

    IAlfWidgetEventHandler& aEventHandler ) const

    {

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

        {

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

            {

            return i;

            }

        }

    return -1;

    }

OSN_EXPORT IAlfWidgetEventHandler* CAlfWidgetControl::findEventHandler(

    const TAlfEvent& aEvent )

    {

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

        {

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

            {

            return mWdgtControlData->mEventHandlerArray[i];

            }

        }

    return 0;

    }

OSN_EXPORT void CAlfWidgetControl::addEventHandler(

    IAlfWidgetEventHandler* aEventHandler, int aIndex )

    {

    try

        {

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

             KErrNotFound )

            {

            if ( aIndex == -1 )

                {

                mWdgtControlData->mEventHandlerArray.resize(

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

                mWdgtControlData->mEventHandlerArray.insert(

                    mWdgtControlData->mEventHandlerArray.count(),

                    aEventHandler );

                }

            else

                {

                mWdgtControlData->mEventHandlerArray.resize(

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

                mWdgtControlData->mEventHandlerArray.insert( aIndex,

                                                         aEventHandler);

                }

            }

        }

    catch (...)

        {

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

        }

    }

OSN_EXPORT void CAlfWidgetControl::removeAndDestroyEventHandler(

    IAlfWidgetEventHandler& aEventHandler )

    {

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

        {

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

            {

            IAlfWidgetEventHandler *handler = 

                mWdgtControlData->mEventHandlerArray[i];

            //check if it is an eventhandler associated with presentation 

            if(handler->eventHandlerType() == 

               IAlfWidgetEventHandler::EPresentationEventHandler)

                {

                ElementData* elementData = 0;

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

                // corresponding element data from mEventHandlerArray

                elementData = removePesentationElementData(*handler);

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

                // from mEventHandlerArray and destroy it 

                if(!elementData)

                    {

                    mWdgtControlData->mEventHandlerArray.remove( i );

                    }

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

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

                // element and thus the event handler

                else

                    {

                    // cache auto delete state.

                    bool autoDeleteState = 

                        mWdgtControlData->mEventHandlerArray.autoDelete(); 

                    mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

                    mWdgtControlData->mEventHandlerArray.remove( i );

                    // restore auto delete state.

                    mWdgtControlData->mEventHandlerArray.setAutoDelete(

                                                             autoDeleteState);

                    delete elementData;

                    }

                }

            else

                {

                mWdgtControlData->mEventHandlerArray.remove( i );

                }

            return;

            }

        }

    }

OSN_EXPORT void CAlfWidgetControl::removeEventHandler(

    IAlfWidgetEventHandler& aEventHandler )

    {

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

        {

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

            {

            // cache auto delete state.

            bool autoDeleteState = 

                mWdgtControlData->mEventHandlerArray.autoDelete();

            mWdgtControlData->mEventHandlerArray.setAutoDelete(false);

            mWdgtControlData->mEventHandlerArray.remove( i );

            // restore auto delete state.

            mWdgtControlData->mEventHandlerArray.setAutoDelete(

                                                     autoDeleteState);

            return;

            }

        }

    }

OSN_EXPORT void CAlfWidgetControl::removeAndDestroyEventHandler(

    const UString& aHandlerId )

    {

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

        {

        IAlfWidgetEventHandler* handler = 

            mWdgtControlData->mEventHandlerArray[i];

        AlfWidgetEventHandlerInitData* eventData = handler->eventHandlerData();

        if(eventData != 0)

            {

            //check for the event id/name

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

                {

                //check if it is an eventhandler associated with presentation 

                if(handler->eventHandlerType() == 

                   IAlfWidgetEventHandler::EPresentationEventHandler)

                    {

                    ElementData* elementData = 0;

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

                    // corresponding element data from mEventHandlerArray

                    elementData = removePesentationElementData(*handler);

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

                    // handler from mEventHandlerArray and destroy it 

                    if(!elementData)

                        {

                        // removes and destoys the event handler

                        mWdgtControlData->mEventHandlerArray.remove( i );

                        }

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

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

                    // destroy the element and thus the event handler      

                    else

                        {

                        // cache auto delete state.

                        bool autoDeleteState = 

                            mWdgtControlData->mEventHandlerArray.autoDelete();

                        mWdgtControlData->mEventHandlerArray.setAutoDelete(

                                                                 false);

                        mWdgtControlData->mEventHandlerArray.remove( i );

                        // restore auto delete state.

                        mWdgtControlData->mEventHandlerArray.setAutoDelete(

                                                             autoDeleteState);

                        //delete element data

                        delete elementData;