/*

* 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 implementation	for	presentation elements.

*

*/

#include "alfviewwidget.h"

#include "alfviewcontrol.h"

#include <e32std.h>

#include <assert.h>

#include <memory>

#include <alf/alfcontrolgroup.h>

#include <alf/alfenv.h>

#include <alf/alfdisplay.h>

#include <alf/alfroster.h>

#include <alf/alfmetric.h>

#include "alf/alfwidget.h"

#include <alf/alfwidgetcontrol.h>

#include <alf/alfanchorlayoutmanager.h>

#include <alf/alfgridlayout.h>

#include <alf/ialfgridlayoutpolicy.h>

#include <alf/alfwidgetenvextension.h>

#include <alf/ialfwidgetfactory.h>

#include <alf/alfutil.h>

#include "alfviewwidgetexception.h"

#include <eikbtgpc.h>

#include <eikspane.h>

#include <eikmenub.h>

namespace Alf

    {

/**

 * Observer class to observe changes in the relative order of control groups in associated

 * roster object and to notify view object about possible view activation (view coming

 * top-most) and deactivation.

 *

 * This class is a Symbian - specific implementation class.

 */

class AlfViewWidgetZOrderChangedObserver : public MAlfControlGroupOrderChangedObserver

    {

    public:

        /**

         * Default constructor

         */

        AlfViewWidgetZOrderChangedObserver(CAlfDisplay& aDisplay, AlfViewWidget& aView)

            : iDisplay(aDisplay), iView(aView)

            {

            aDisplay.Roster().AddControlGroupOrderChangedObserverL(*this);

            }

        /**

         * Default destructor

         */

        ~AlfViewWidgetZOrderChangedObserver()

            {

            int index = CAlfEnv::Static()->FindDisplayIndex(iDisplay);

            if(index != -1)

	            {

	            iDisplay.Roster().RemoveControlGroupOrderChangedObserver(*this);	

	            }            

            }

        /**

         * Callback method called by roster when control group order changes.

         */

        void NotifyControlGroupOrderChanged()

            {

            // If the associated view is on top, notify it about view activation

            // and the view below it about view deactivation.

            if(iView.getViewStackPosition() == 0)

                {               

                AlfViewWidget* viewBelow = getViewFromStack(1);                

                if(viewBelow)

                    {

                    viewBelow->notifyViewActivated(false);

                    }

                iView.notifyViewActivated(true);

                }

            }

    private:

        /**

         * Utility method to return view from specified z-position on the view stack.

         * Returns 0 if the index is out of bounds.

         */

        AlfViewWidget* getViewFromStack(int index)

            {

            int zPos = 0;

            // Iterate through the control groups in the roster

            for(int i = (iDisplay.Roster().Count() - 1); i >= 0; --i)

            	{

            	CAlfControlGroup& group = iDisplay.Roster().ControlGroup(i);            	    	

            	// Investigate whether this is a control group of a view widget

            	if(group.Count() > 0)

            		{

            		CAlfControl& control = group.Control(0);

            		CAlfViewControl* viewControl = dynamic_cast<CAlfViewControl*>(&control);

            		if(viewControl != 0)

            			{

            			// View widget found from the roster

            			if(zPos == index)

            			    {

            			    return &viewControl->viewWidget();

            			    }

            			zPos++;

            			}

            		}

            	}

            return 0;

            }

        /** Roster to which this callback object is added to. */

        CAlfDisplay& iDisplay;

        /** View widget that this observer notifies. */

        AlfViewWidget& iView;

    };

AlfViewWidget::AlfViewWidget(const char* aWidgetName, int aControlGroupId, CAlfEnv& aEnv, 

                             CAlfDisplay& aDisplay, DuiNode* aNode, const char *aFilePath) : 

    mEnv(&aEnv), mDisplay(&aDisplay), mControlGroup(0),

    mZOrderChangedObserver(0),

    mControlGroupResourceId(aControlGroupId),

    mShown(false), mControlPaneEnabled(true), mStatusPaneEnabled(true),

    mSkinEnabled(false), mSkinId(KAknsIIDQsnBgScreen), mHasFocus(false)

	{

	mChildWidgetName.setAutoDelete(true);

	mWidget.reset(new (EMM) AlfWidget(aWidgetName));

	TRAPD(err,aEnv.AddActionObserverL(this));

	if(err!=KErrNone)

	    {

	    ALF_THROW(AlfViewWidgetException, err, 

	        "CAlfEnv::AddActionObserverL() - failed.");

	    }

	// By default, we use ClientRect() as the area of the view widget    

	TRect rect = ((CAknAppUi*)CEikonEnv::Static()->AppUi())->ClientRect();

	mDisplayRect =  TRect(rect);

	mZOrderChangedObserver.reset(new (EMM) AlfViewWidgetZOrderChangedObserver(aDisplay, *this));

        constructDefault(aEnv);

	}

AlfViewWidget::~AlfViewWidget()

	{	

	//If the view widget is deleted before the AlfEnv is deleted,

	//the control group needs to be destroyed.

	if(mEnv->FindControlGroup(mControlGroupResourceId))

    	{

    	mEnv->DeleteControlGroup(mControlGroup->ResourceId());		

    	}

    mEnv->RemoveActionObserver(this);

    IAlfWidget* childWidget = NULL;

    IAlfWidgetFactory& factory = AlfWidgetEnvExtension::widgetFactory(*(CAlfEnv::Static()));

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

	    {

	    childWidget = factory.findWidget(mChildWidgetName.at(i)->getUtf8());

	    if(childWidget)

		    {

			factory.destroyWidget(childWidget);

			childWidget = NULL;

		    }

	    }

    mChildWidgetName.clear();

	}

CAlfWidgetControl* AlfViewWidget::control() const

	{

	return mWidget->control();

	}

IAlfContainerWidget* AlfViewWidget::parent() const

    {

    return mWidget->parent();

    }	

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

	{

	CAlfWidgetControl* prevControl = mWidget->control();

	// Set new control to the widget implementation.

	// Never delete the previous control in this phase, so that we can

	// still remove it from the control group if this call is succesfull.

	mWidget->setControl(aControl, false);		

	// Remove the previous control from control group.

	if(prevControl != 0)

	    {

	    assert(prevControl->ControlGroup() == mControlGroup);

	    if(aDeletePreviousControl)

	        {

	        mControlGroup->Remove(prevControl);

	        delete prevControl;

	        }

	    }	

	// Append the new control into the control group.

    if(aControl)

    	{

	    TRAPD(err, mControlGroup->AppendL(aControl));

	    if(err != KErrNone)

	    	{

	    	mWidget->setControl(0, false);

	    	ALF_THROW(AlfViewWidgetException, err, "CAlfControlGroup::AppendL() - failed.");

	    	}

    	}	

	}

void AlfViewWidget::setChildNameToDelete( UString aChildName )

	{

	UString* childName = new(EMM)UString(aChildName.getUtf8());

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

	mChildWidgetName.insert(mChildWidgetName.count(),childName);

	}

IAlfModel* AlfViewWidget::model()

    {

    return 0;

    }

void AlfViewWidget::setModel(IAlfModel* /*aModel*/, bool /*aTakeOwnership*/)

    {

    //Do nothing.

    }

const char* AlfViewWidget::widgetName() const

    {

    return mWidget->widgetName();

    }

void AlfViewWidget::setChildFocus(bool /*aFocus*/)

    {

    }

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

// Creates the presentation for the widget from XML. Destroys any existing

// presentation.

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

//    

void AlfViewWidget::setPresentation (const char* aFilePath)

    {

    if(mWidget.get())

    	{

        mWidget->setPresentation(aFilePath);    	

    	}

    }

int AlfViewWidget::widgetCount() const

    {

    return mWidget->widgetCount();

    }

void AlfViewWidget::addWidget(IAlfWidget& aWidget)

    {

    mWidget->addWidget(aWidget);

    }

IAlfWidget* AlfViewWidget::getWidget(int aIndex) const

    {

    return mWidget->getWidget(aIndex);

    }

int AlfViewWidget::getWidgetIndex(IAlfWidget& aWidget) const

    {

    return mWidget->getWidgetIndex(aWidget);

    }

void AlfViewWidget::removeWidget(int aIndex)

    {

    mWidget->removeWidget(aIndex);

    }

void AlfViewWidget::applyLayout(IAlfLayoutManager& aLayout)

    {

    mWidget->applyLayout(aLayout);

    }

IAlfInterfaceBase* AlfViewWidget::makeInterface(const IfId& aType)

	{

    // Type cast to IAlfWidget

    if(!strcmp(aType.mImplementationId, IAlfWidget::type().mImplementationId))

        {

        return static_cast<IAlfWidget*>(this);

        }

    // Type cast to IAlfContainerWidget

    if (!strcmp(aType.mImplementationId, IAlfContainerWidget::type().mImplementationId))

        {

        return static_cast<IAlfContainerWidget*>(this);

        }

    // Type cast to IAlfViewWidget        

    if(!strcmp(aType.mImplementationId, IAlfViewWidget::type().mImplementationId))

        {

        return static_cast<IAlfViewWidget*>(this);

        }    

    return mWidget->makeInterface(aType);

    }

void AlfViewWidget::notifyViewActivated(bool aIsActivated)

	{

	if(aIsActivated)

		{

        // Update control pane, status pane and background according to state of the view.

        updateStatusPane();

        updateControlPane();

        // When a view is activated, it sets the size of the display to full screen

        // This is done so that the view widget gets pointer events in the entire screen

        TRect screenRect(TPoint(0,0), TSize(AlfUtil::ScreenSize()));

        control()->Env().PrimaryDisplay().SetVisibleArea(screenRect);

        setRect(mDisplayRect);

        // Restore the focus here

        IAlfWidget* focusedWidget = 0;

        focusedWidget = AlfWidgetEnvExtension::widgetFactory(*mEnv).findWidget(mFocusedChildWidgetID.c_str());

        if(focusedWidget == 0 && widgetCount() > 0)

            {

            focusedWidget = getWidget(0);

            }

        if(!mHasFocus)

	        {

	        mHasFocus = true;

	        if(focusedWidget != 0)

	            {

	            focusedWidget->control()->AcquireFocus();

	            }

	        else

	            {

	            control()->AcquireFocus();

	            }	

	        }

        }

    else

        {

        // Cache and release the focus here

        // FocusedControl function is not exported from the toolkit

        CAlfControl* focusedCtrl = focusedControl();

        if(focusedCtrl)

            {

            CAlfWidgetControl* focusedWidgetControl = dynamic_cast<CAlfWidgetControl*>(focusedCtrl);

            if(focusedWidgetControl != 0)

                {

                mFocusedChildWidgetID = focusedWidgetControl->widget()->widgetName();

                }                        

            focusedCtrl->RelinquishFocus();

            }

        mHasFocus = false;    

        }

    }

CAlfControl* AlfViewWidget::focusedControl()

    {

    CAlfControl* focusedconnection = control();

    // Iterate through the focused connections and return the control

    // that has the focus.

    while(focusedconnection != 0)

        {

        if(focusedconnection->Focus())

            {

            // There should be no connections leading outside from the control

            // group of the view.

            assert(focusedconnection->ControlGroup() == mControlGroup);

            return focusedconnection;

            }

        focusedconnection = focusedconnection->FocusedConnection();        

        }

    return 0;

    }

void AlfViewWidget::show(bool aShow)

    {

    mShown = aShow;

    if (aShow)

        {   

        TRAPD(err, mDisplay->Roster().ShowL(*mControlGroup));

        if (err != KErrNone)

            {

            ALF_THROW(AlfViewWidgetException, err, "AlfViewWidget::show(): View Widget Show failed");   

            }

        }

    else

        {

        // Notify this view that it is being deactivated.

        notifyViewActivated(false);

        // Hide the control group

        mDisplay->Roster().Hide(*mControlGroup);

        }

    }

void AlfViewWidget::acceptEvents(bool aAccept)

    {

    assert(mControlGroup);

    mControlGroup->SetAcceptInput(aAccept);

    }

void AlfViewWidget::enableStatusPane(bool aEnable)

    {

	if(aEnable != mStatusPaneEnabled)

		{

	    mStatusPaneEnabled = aEnable;

	    // Update status pane and background image state if this view is active.

	    if(getViewStackPosition() == 0)

	        {

	        updateStatusPane();

	        }

		}

    }

void AlfViewWidget::enableControlPane(bool aEnable)

    {

    if (aEnable != mControlPaneEnabled)

        {

        mControlPaneEnabled=aEnable;

	    // Update control pane and background image state if this view is active.

	    if(getViewStackPosition() == 0)

	        {        

            updateControlPane();

	        }

        }

    }

void AlfViewWidget::useSkinBackground(bool aSkinBackground)

    {

    if(mSkinEnabled != aSkinBackground)

    	{

    	 mSkinEnabled = aSkinBackground;

    	 updateBackGroundImage();	

    	}

    }

void AlfViewWidget::setSkinBackground(TAknsItemID aSkinID)

    {

    mSkinEnabled = true;

    mSkinId = aSkinID;

    updateBackGroundImage();

    }

bool AlfViewWidget::shown()

    {

	return mShown;

	}

int AlfViewWidget::getViewStackPosition() const

	{

	int ret = 0;

    const CAlfRoster& roster = mDisplay->Roster();

    // Iterate through the control groups in the roster

    for(int i = (roster.Count() - 1); i >= 0; --i)

    	{

    	CAlfControlGroup& group = roster.ControlGroup(i);

    	// Compare the control group with this view's control group

    	if(mControlGroup == &group)

    		{

    		return ret;

    		}

    	// Investigate whether this is a control group of a view widget

    	if(group.Count() > 0)

    		{

    		CAlfControl& control = group.Control(0);    		

    		if(dynamic_cast<CAlfViewControl*>(&control) != 0)

    			{

    			ret++;

    			}

    		}

    	}

    return -1;   

	}

bool AlfViewWidget::eventsAccepted()

    {

    assert(mControlGroup);

    return mControlGroup->AcceptInput();

    }

bool AlfViewWidget::statusPaneEnabled()

    {

    return mStatusPaneEnabled;

    }

bool AlfViewWidget::controlPaneEnabled()

    {

    return mControlPaneEnabled;

    }

bool AlfViewWidget::usingSkinBackground()

	{