/*

* Copyright (c) 2006-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:   Implementation of CHuiRosterImpl. CHuiRosterImpl implements 

*                the interface defined by CHuiRoster.

*

*/

#include "HuiRosterImpl.h"  // Class definition

#include "HuiRosterEntry.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiSkin.h"

#include "uiacceltk/HuiControlGroup.h"

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiDisplay.h"

#include "uiacceltk/HuiEvent.h"

#include "uiacceltk/HuiTransformation.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiProbe.h"

#include "uiacceltk/HuiCanvasVisual.h"

#include "huilongtapdetector.h"

#include "HuiFxEffect.h"

#include "huieffectable.h"

#include "huicanvasrenderbuffer.h"

#include "huicanvasgc.h"

#include "HuiRenderPlugin.h"

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

const TReal32 KHuiVisualOutlineWidth = 1.f;

struct THuiPointerEventDetails 

	{

	MHuiEventHandler* iEventHandler;

	THuiXYMetric iXYMetric;

	TBool iDisableLongTapWhenDragging;

	TBool iDragging;

	};

CHuiRosterImpl::CHuiRosterImpl(CHuiDisplay* aDisplay)

        : iDisplay(aDisplay), iInitialDownEvent(NULL), iEffectOpacity(1.f)

    {

    }

CHuiRosterImpl::~CHuiRosterImpl()

    {

    if (iDisplay)

        {

        iDisplay->Env().RemoveMemoryLevelObserver(this);

        }

    FreezeVisibleContentL(EFalse);

    delete iLongTapDetector;

    iEntries.ResetAndDestroy();

    iPointerDragObservers.Close();

    iDisplay = NULL;

    iInputFocus = NULL;

    iUnhandledPointerObservers.Close();

    iLongTapObservers.Close();

    while(iPointerEventDetails.Count()>0)

    	{

    	delete iPointerEventDetails[0];

		iPointerEventDetails.Remove(0);    	

    	}

    iPointerEventDetails.ResetAndDestroy();

    }

void CHuiRosterImpl::SetDisplay(CHuiDisplay* aDisplay)

    {

    iDisplay = aDisplay;    

    }

void CHuiRosterImpl::SetRect(const TRect& aRect)

    {

    iRect = TRect(0, 0, aRect.Width(), aRect.Height());

    UpdateLayout();

    SetChanged();

    }

TRect CHuiRosterImpl::Rect() const

	{

	return(iRect);

	}

void CHuiRosterImpl::ShowL(CHuiControlGroup& aGroup, TInt aWhere)

    {

    // The group will automatically accept input events once shown.

       aGroup.SetAcceptInput(ETrue);

    // If the group is already shown on the display, just adjust its position

    // according to the parameters.

    if(Find(&aGroup) != KErrNotFound)

        {

        // It is already shown. Only adjust position.

        TInt newPos = aWhere;

        if(newPos == KHuiRosterShowAtTop)

            {

            newPos = Count() - 1;

            }

        else if(newPos == KHuiRosterShowAtBottom)

            {

            newPos = 0;

            }

        else

            {

            // for PC lint

            }

        Move(&aGroup, newPos);            

        return;

        }

    if(aWhere == KHuiRosterShowAtTop)

        {

        // Put the group on top of the roster.

        AppendL(&aGroup);

        }

    else if(aWhere == KHuiRosterShowAtBottom)

        {

        InsertL(&aGroup, 0);

        }

    else

        {

        InsertL(&aGroup, aWhere);

        }

    // Show all the controls of the group.

    for(TInt i = 0; i < aGroup.Count(); ++i)

        {

        aGroup.Control(i).ShowL(*iDisplay);

        }

    }

void CHuiRosterImpl::Hide(CHuiControlGroup& aGroup)

    {

    // Hide all the controls of the group.

    for(TInt i = 0; i < aGroup.Count(); ++i)

        {

        aGroup.Control(i).Hide(*iDisplay);

        }

    Remove(&aGroup);

    }

void CHuiRosterImpl::AppendL(CHuiControlGroup* aGroup)

    {

    ASSERT( aGroup );

    CHuiRosterEntry* entry = new (ELeave) CHuiRosterEntry(*aGroup);

    CleanupStack::PushL(entry);

    User::LeaveIfError(iEntries.Append(entry));

    CleanupStack::Pop(entry);

    if(iDisplay)

        {

        iDisplay->Env().ContinueRefresh();

        }

    SetChanged();

    }

void CHuiRosterImpl::InsertL(CHuiControlGroup* aGroup, TInt aPos)

    {

    ASSERT( aGroup );

    if(Find(aGroup) != KErrNotFound)

        {

        User::Leave(KErrAlreadyExists);

        }

    CHuiRosterEntry* entry = new (ELeave) CHuiRosterEntry(*aGroup);

    CleanupStack::PushL(entry);

    User::LeaveIfError(iEntries.Insert(entry, aPos));

    CleanupStack::Pop(entry);

    if(iDisplay)

        {

        iDisplay->Env().ContinueRefresh();

        }

    SetChanged();

    }

void CHuiRosterImpl::Move(CHuiVisual* aVisual, TInt aPos)

    {

    CHuiRosterEntry* entry = EntryForVisual(aVisual);

    if (entry)

        {

        Move(&entry->ControlGroup(), aPos);        

        }    

    }

void CHuiRosterImpl::Move(CHuiControlGroup* aGroup, TInt aPos)

    {

    TInt index = Find(aGroup);

    TInt k = 0;

    if(index != KErrNotFound && index != aPos)

        {

        CHuiRosterEntry* moving = iEntries[index];

        if(aPos > index)

            {

            for(k = index; k < aPos; ++k)

                {

                iEntries[k] = iEntries[k + 1];

                }

            }

        else 

            {

            for(k = index; k > aPos; --k)

                {

                iEntries[k] = iEntries[k - 1];

                }

            }

        iEntries[aPos] = moving;                

        }

    if(iDisplay)

        {

        iDisplay->Env().ContinueRefresh();        

        }

    SetChanged();

    }

TInt CHuiRosterImpl::Find(CHuiControlGroup* aGroup) const

    {

    for(TInt i = 0; i < iEntries.Count(); ++i)

        {

        if(&iEntries[i]->ControlGroup() == aGroup)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

void CHuiRosterImpl::Remove(CHuiControlGroup* aGroup)

    {

    TInt index = Find(aGroup);

    if(index != KErrNotFound)

        {

        delete iEntries[index];

        iEntries.Remove(index);

        if(iDisplay)

            {

            iDisplay->Env().ContinueRefresh();

            }

        SetChanged();

        }

    }

TInt CHuiRosterImpl::Count() const

    {

    return iEntries.Count();

    }

CHuiControlGroup& CHuiRosterImpl::ControlGroup(TInt aIndex) const

    {

    return iEntries[aIndex]->ControlGroup();

    }

CHuiControl* CHuiRosterImpl::FindControl(TInt aControlId) const

    {

    CHuiControl* control = 0;

    for(TInt i = 0; i < iEntries.Count(); ++i)

        {

        control = iEntries[i]->ControlGroup().FindControl(aControlId);

        if(control)

            {

            break;

            }

        }

    return control;

    }

CHuiRosterEntry* CHuiRosterImpl::EntryForVisual(const CHuiVisual* aVisual)

    {

    ASSERT( aVisual != NULL );

    CHuiControlGroup* group = aVisual->Owner().ControlGroup();

    TInt index = Find(group);

    if(index == KErrNotFound)

        {

        // The group is not in this roster.

        return NULL;

        }

    return iEntries[index];

    }

void CHuiRosterImpl::ShowVisualL(CHuiVisual* aVisual)

    {

    CHuiRosterEntry* entry = EntryForVisual(aVisual);

    if(!entry)

        {

        User::Leave(KErrNotFound);

        }

    if(entry->iRootVisuals.Find(aVisual) != KErrNotFound)

        {

        User::Leave(KErrAlreadyExists);

        }

    User::LeaveIfError( entry->iRootVisuals.Append(aVisual) );

    SetVisualToFullArea(aVisual);    

    }

void CHuiRosterImpl::HideVisual(CHuiVisual* aVisual)

    {

    ASSERT( aVisual );

    aVisual->SetDisplay(NULL);

    CHuiRosterEntry* entry = EntryForVisual(aVisual);

    if(entry)

        {

        TInt index = entry->iRootVisuals.Find(aVisual);

        if(index != KErrNotFound) // do nothing if visual was not found

            {

            entry->iRootVisuals.Remove(index);

            if(iDisplay)

                {

                iDisplay->Env().ContinueRefresh();

                }

            }

        }

    }

void CHuiRosterImpl::SetFocus(CHuiControl& aControl)

    {

    ChangeInputFocus(&aControl);

    }

void CHuiRosterImpl::ClearFocus()

    {

    ChangeInputFocus(NULL);

    }

void CHuiRosterImpl::ChangeInputFocus(CHuiControl* aControl)

    {

    if(aControl)

        {

        // The control must be in one of groups of the roster.

        CHuiControl* control = FindControl(aControl->Id());

        if(control != aControl)

            {

            // Illegal focus.

            return;

            }

        }

    iInputFocus = aControl;

    }

TBool CHuiRosterImpl::PrepareDraw() const

    {

    HUI_PROBE_PROGRAMFLOW_ENTER(MHuiProbe::EProgramFlowPointRefreshPrepareDraw)

    TInt i = 0;

    TInt j = 0;

    TInt visualCount = 0;

    TInt entryCount = iEntries.Count();

    // Prepare the visuals tree in the display.

    for(j = 0; j < entryCount; ++j)

        {

        CHuiRosterEntry& entry = *iEntries[j]; 

        visualCount = entry.iRootVisuals.Count();

        for(i = 0; i < visualCount; ++i)

            {

            CHuiVisual* visual = entry.iRootVisuals[i];

            //Ignore inactive visuals

            if ( visual->Flags()& EHuiVisualFlagInactive )

            	{

            	continue; 

            	}

            TBool successfullyPrepared = ETrue;

            TRAPD(err, successfullyPrepared = visual->PrepareDrawL());

            if (err != KErrNone)

	            {

	            // Handle the error by calling the visual owner

	            // errorhandling callback

                visual->Owner().VisualPrepareDrawFailed(*visual, err);

                HUI_PROBE_PROGRAMFLOW_EXIT(MHuiProbe::EProgramFlowPointRefreshPrepareDraw)

                return EFalse;

	            }

	        if (!successfullyPrepared) 

		        {

		        // we can stop preparing the rest of the root visuals

		        // if one prepare failed (we won't be drawing 

		        // anything anyway)

		        // also if the prepare failed but it didn't leave,

		        // we assume it was already handled 

                HUI_PROBE_PROGRAMFLOW_EXIT(MHuiProbe::EProgramFlowPointRefreshPrepareDraw)

		        return EFalse;

		        }

            }

        }

    HUI_PROBE_PROGRAMFLOW_EXIT(MHuiProbe::EProgramFlowPointRefreshPrepareDraw)

    return ETrue;

    }

void CHuiRosterImpl::Draw(CHuiGc& aGc) const

    {

    Draw(aGc, NULL);

    }

void CHuiRosterImpl::Draw(CHuiGc& aGc, CHuiDisplay* aDisplay) const

    {

    CHuiDisplay* display = aDisplay ? aDisplay : iDisplay;

    THuiRealRect displayRect = display->VisibleArea();

    TBool refreshCache = ETrue; // TODO: Could this be optimized ?

    TBool opaque = EFalse;  

    // Init projection matrix

    aGc.LoadIdentity(EHuiGcMatrixProjection);

    // Init model matrix 

    aGc.LoadIdentity(EHuiGcMatrixModel);        

    // Set up display-specifc window transformations e.g. scaling for tv out        

    aGc.SetWindowTransformation(&(display->WindowTransformation()));

    aGc.UpdateProjection();                            

    TBool didDrawEffect = EFalse;

    if (iEffect)

        {

        //RDebug::Print(_L("CHuiRosterImpl::Draw trying to use effect"));

        TRgb oldColor = aGc.PenColor(); 

        TInt oldAlpha = aGc.PenAlpha(); 

        // Clear

        aGc.SetPenColor(KRgbBlack);

        aGc.SetPenAlpha(0);

        aGc.Disable(CHuiGc::EFeatureBlending);

        aGc.Disable(CHuiGc::EFeatureClipping);

        aGc.Clear();

        // Restore Gc values

        aGc.SetPenColor(oldColor);

        aGc.SetPenAlpha(oldAlpha);

        aGc.Enable(CHuiGc::EFeatureBlending);

        aGc.Enable(CHuiGc::EFeatureClipping);

        // Note: Opacity implementation in effect system  does not really work visually 

        // correct if there are semitransparent child windows. Child window opacity becomes too

        // large, because opacity is applied during visual tree drawing and thus blending child

        // visuals on top of the parent produces wrong transparency level.

        //

        // We workaround this issue here so that we force rendering to cached render

        // target (with opacity 255) and give the real opacity as a parameter to effect

        // drawing so the whole operation gets correct opacity. However there is possibility

        // that complex effect fxml would assume transparency to be handled *before*

        // some other part of the effect, so this workaround won't work correctly in those cases. 

        // To get those working, propably whole opacity effect handling should be re-written 

        // differently.

            {

        }

    if (!didDrawEffect)

        {

        DrawSelf(aGc, aDisplay);

        }

    else

        {

        // Effect was drawn, OpenGLES/OpenVG may be in different state than what Gc thinks so we restore it.

        aGc.RestoreState();