/*

* 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 private implementation of CAlfWidget.

*

*/

#include "alfwidgetimpl.h"

#include <alf/alfwidgetcontrol.h>

#include <alf/alfmodel.h>

#include <alf/alfcontrolgroup.h>

#include "alf/alfwidget.h"

#include "alf/alfattribute.h"

#include "alf/alfattributevaluetype.h"

#include <alf/alfexceptions.h>

#include <libc/string.h>

#include <alf/ialfelement.h>

#include "alfwidgetattributeownerimpl.h"

namespace Alf

    {

AlfWidgetImpl::AlfWidgetImpl()

    {

    mControl = NULL;

    mModel = NULL;

    mAttributeList.setAutoDelete(true);

    mWidgets.setAutoDelete(false);

    mTakesModelOwnership=false;

    }

AlfWidgetImpl::~AlfWidgetImpl()

    {

    setControl( NULL, true );

    if (mTakesModelOwnership)

        {

        delete mModel;

        mModel = NULL;

        }        

    mAttributeList.clear();

    mWidgets.clear();

    }

void AlfWidgetImpl::setWidgetName( const UString& aWidgetName )

    {

    mWidgetName = aWidgetName;

    }

const UString& AlfWidgetImpl::widgetName() const

    {

    return mWidgetName;

    }

CAlfWidgetControl* AlfWidgetImpl::control()

    {

    return mControl;

    }	

void AlfWidgetImpl::setControl( CAlfWidgetControl* aControl,bool aDeletePreviousControl)

    {    

    if ( mControl != aControl )

        {

        if( mControl )

            {

            if( mModel )

                {

                // Remove model change observer from control

                mModel->removeModelChangeObserver( *mControl );

                }

            if( aDeletePreviousControl )

                {

                // Delete control from possible control group to avoid double deletion

                if(mControl->ControlGroup())

                    {

                    mControl->ControlGroup()->Remove(mControl);

                    }

                // Delete the control

                delete mControl;

                mControl = NULL;

                }

            }

        // Set the new control.

        mControl = aControl;

        // Add the new control as an observer for model changes.

        if( mControl )

            {

            if( mModel )

                {

                mModel->addModelChangeObserver( *mControl );

                }

            mAttributeOwnerImpl.reset(new (EMM) AlfWidgetAttributeOwnerImpl(mControl));

            }

        }

    }

IAlfModel* AlfWidgetImpl::model()

    {

    return mModel;

    }

void AlfWidgetImpl::setModel( IAlfModel* aModel,bool aTakeOwnerShip )

    {

    if ( mModel != aModel )

        {

        // Release the old model.

        if (mTakesModelOwnership)

            {

            delete mModel;

            }

        else if (mModel&&mControl)

            {

            mModel->removeModelChangeObserver(*mControl);

            }

        // Set the new model.

        mModel = aModel;

        mTakesModelOwnership=aTakeOwnerShip;

        // Add the control as an observer for model changes.

        if ( mModel && mControl )

            {

            mModel->addModelChangeObserver( *mControl );

            }

        }

    else // just copy the ownership flag 

        { 

        if (mModel != NULL)

            {

            mTakesModelOwnership=aTakeOwnerShip;

            }

        }

    }

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

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

//

void AlfWidgetImpl::addWidget(AlfWidget *aWidget)

    {

    for (int i=0 ; i< mWidgets.count(); i++ )

        {

        if (mWidgets.findRef(aWidget) >=0)

            {

            //widget already there.

            return;

            }

        }

    mWidgets.resize(mWidgets.count()+1);

    mWidgets.insert(mWidgets.count(),aWidget);

    }

int  AlfWidgetImpl::widgetCount()

    {

    return mWidgets.count();

    }

AlfWidget* AlfWidgetImpl::getWidget(int aIndex)

    {

    if (aIndex>=0 && aIndex < mWidgets.count())

        return mWidgets[aIndex];

    return 0;

    }

int AlfWidgetImpl::findWidget(AlfWidget* aWidget)

    {

    return mWidgets.findRef(aWidget);

    }

void AlfWidgetImpl::removeWidget(int aIndex)

    {

    if (aIndex >=0 and aIndex < mWidgets.count())

        mWidgets.remove(aIndex);

    }

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

//  Returns attribute owner interface.

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

//

AlfWidgetAttributeOwnerImpl* AlfWidgetImpl::getAttributeOwner()

    {

    return mAttributeOwnerImpl.get();

    }

    } //namespace alf