/*

* 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:

*

*/

#include <e32keys.h>

#include <e32math.h>

#include <AknsDrawUtils.h>

#include <layoutmetadata.cdl.h>

#include <aknlongtapdetector.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#include <aknlistboxtfx.h>

#endif

#include "mmwidgetcontainer.h"

#include "mmlistboxmodel.h"

#include "mmmarqueeadapter.h"

#include "mmwidgetobserver.h"

#include "mmvisibilityobserver.h"

#include "mmlistboxcontainer.h"

#include "mmgridcontainer.h"

#include "mmlistboxitemdrawer.h"

#include "mmmarqueeadapter.h"

#include "mmfloatingitem.h"

#include "hnsuitemodel.h"

#include "hnitemsorder.h"

#include "menudebug.h"

#include "mmdraweranimator.h"

#include "hnglobals.h"

#include "mmpostevaluationprocessor.h"

#include "mmgrid.h"

#include "mmlongtapobserver.h"

class CMmTemplateLibrary;

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

//

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

//

TMmWidgetPosition::TMmWidgetPosition()

    : iVerticalItemOffset( 0 )

    , iTopItemIndex( KErrNotFound )

    , iValid( EFalse )

    , iLandscape( EFalse )

    , iHighlightedItemId( KErrNotFound )

    {

    }

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

//

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

//

EXPORT_C CMmWidgetContainer* CMmWidgetContainer::NewGridContainerL( const TRect& aRect,

        MObjectProvider* aObjectProvider, CMmTemplateLibrary* aLibrary )

    {

    return CMmGridContainer::NewL( aRect, aObjectProvider, aLibrary );

    }

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

//

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

//

EXPORT_C CMmWidgetContainer* CMmWidgetContainer::NewListBoxContainerL( const TRect& aRect,

        MObjectProvider* aObjectProvider, CMmTemplateLibrary* aTemplateLibrary )

    {

    return CMmListBoxContainer::NewL( aRect, aObjectProvider, aTemplateLibrary );

    }

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

//

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

//

void CMmWidgetContainer::ConstructL()

	{

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

    	KAknsIIDQsnBgAreaMainAppsGrid, Rect(), EFalse);

    iLongTapDetector = CAknLongTapDetector::NewL( this );

    iLongTapDetector->EnableLongTapAnimation(ETrue);

	}

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

//

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

//

CMmWidgetContainer::CMmWidgetContainer()

    : iIsFaded( EFalse )

    , iHasFocus( ETrue )

    , iInForeground( ETrue )

    {

    iMarqueeAdapter = NULL;

    iBgContext = NULL;

    iWidgetPositionCache.iValid = EFalse;

    iLongTapInProgress = EFalse;

    }

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

//

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

//

CMmWidgetContainer::~CMmWidgetContainer()

    {

    AknsUtils::DeregisterControlPosition( this );

    AknsUtils::DeregisterControlPosition( this->iWidget );

    delete iBgContext;

    delete iPostProcessor;

    delete iLongTapDetector;

    }

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

//

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

//

EXPORT_C void CMmWidgetContainer::EnableLongTapAnimation( TBool aEnable )

    {

    if ( iLongTapDetector )

        {

        iLongTapDetector->EnableLongTapAnimation( aEnable );

        }

    }

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

//

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

//

void CMmWidgetContainer::SizeChanged()

    {

    if ( iWidget && iWidgetRect != Rect() )

        {

    	CMmTemplateLibrary * templateLibrary =

    	static_cast<CMmListBoxItemDrawer*> (

    			Widget()->View()->ItemDrawer() )->TemplateLibrary();

        if ( Rect() != templateLibrary->GetParentRect(

        		Layout_Meta_Data::IsLandscapeOrientation() ) )

        	{

        	templateLibrary->CleanAndClearCache();

        	}

        iWidget->View()->SetViewRect( Rect() );

        iWidget->SetRect( Rect() );

        iWidgetRect = Rect();

        }

    if ( iBgContext )

        {

        TRect rect = iCoeEnv->ScreenDevice()->SizeInPixels();

        iBgContext->SetRect( rect );

        SetItemDrawerAndViewBgContext( iBgContext );

        }

    AknsUtils::RegisterControlPosition( this );

    AknsUtils::RegisterControlPosition( this->iWidget );

    }

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

//

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

//

void CMmWidgetContainer::Draw( const TRect& /*aRect*/ ) const

    {

    // do nothing

    }

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

//

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

//

TTypeUid::Ptr CMmWidgetContainer::MopSupplyObject(TTypeUid aId)

    {

    if (aId.iUid == MAknsControlContext::ETypeId && iBgContext )

        {

        return MAknsControlContext::SupplyMopObject(aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject(aId);

    }

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

//

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

//

void CMmWidgetContainer::HandleButtonDownL(const TPointerEvent& aPointerEvent )

    {

    iTapPoint = aPointerEvent.iPosition;

    iLastDragPoint = aPointerEvent.iPosition;

    iLastDragHighlight = GetHighlight();

    if( !iWidget->View()->XYPosToItemIndex(

    		aPointerEvent.iPosition, iDraggedIndex ) )

        {

        iDraggedIndex = KErrNotFound;

        }

    iItemRelativeTapPoint = aPointerEvent.iPosition - iWidget->View()->ItemPos(

    		iDraggedIndex );

    }

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

//

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

//

void CMmWidgetContainer::HandleButtonUpL(const TPointerEvent& /*aPointerEvent*/ )

    {

    iTapPoint = TPoint( 0, 0 );

    CancelDragL( EFalse );

    }

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

//

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

//

void CMmWidgetContainer::HandleResourceChange( TInt aType )

    {

    if ( aType == KEikDynamicLayoutVariantSwitch ||

            aType == KAknsMessageSkinChange )

        {

        static_cast<CMmListBoxItemDrawer*>( iDrawer )->InvalidateCache();

        CMmTemplateLibrary * templateLibrary =

        static_cast<CMmListBoxItemDrawer*>( iDrawer )->TemplateLibrary();

        templateLibrary->CleanAndClearCache();

        }

    CCoeControl::HandleResourceChange( aType );

	if ( aType == KEikDynamicLayoutVariantSwitch && !IsHighlightVisible() )

		{

		}

    }

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

//

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

//

EXPORT_C void CMmWidgetContainer::ItemIconZoomL( TInt /*aItemIndex */)

    {

    TInt index = GetHighlight();

    if (index != iDraggedIndex)

        {

        iDrawer->AnimateItemZoomInL( index );

        }

    }

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

//

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

//

EXPORT_C CHnSuiteModel* CMmWidgetContainer::GetSuiteModelL()

	{

	return GetMmModel()->GetSuiteModel();

	}

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

//

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

//

void CMmWidgetContainer::HandleDragL(const TPointerEvent& aPointerEvent,

        TBool aAbortAnimation )

    {

    DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: iLastDragHighlight = %d ",

    		iLastDragHighlight ));

    TInt highlight = GetHighlight();

    DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: highlight = %d ", highlight ));

    TPoint dragDelta ( iLastDragPoint - aPointerEvent.iPosition);

    TInt dragSpeed = dragDelta.iX * dragDelta.iX + dragDelta.iY * dragDelta.iY;

    TBool tooFast = (dragSpeed > MmEffects::KDragSpeedIgnoreThreshold);

    if (iLastDragHighlight != highlight )

        {

       	iDragAndDropObserver->HandleDragOverL( GetHighlight() );

        }

    if (!tooFast)

    	{

		TSize itemSize = iWidget->View()->ItemSize( highlight );

		TPoint itemPos = iWidget->View()->ItemPos( highlight );

		if ( PointInItemReorderAreaL( highlight, aPointerEvent.iPosition ) )

		   {

		   CHnSuiteModel* model = GetMmModel()->GetSuiteModel();

		   CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( highlight ));

		   if (iDrawer->GetAnimator()->IsReadyForNewAnimation() && !aAbortAnimation

				   && onItemModel->GetItemType() != EItemTypeParentFolder

				   && iDraggedIndex != highlight)

				   {

				   GetMmModel()->ReorderModelL( iDraggedIndex, highlight );

				   AnimateShiftL( highlight );

				   iDrawer->SetDraggedIndexL( highlight,

						   aPointerEvent.iPosition - iItemRelativeTapPoint );

				   iDraggedIndex = highlight;

				   iDragAndDropObserver->HandleDraggedIndexUpdatedL( highlight );

				   }

		   }

    	}

    if ( DeltaSquare( iTapPoint, aPointerEvent.iPosition ) > KDragDelta &&

				!iDrawer->IsDraggable() )

		{

		iDrawer->SetDraggedIndexL( iDraggedIndex, iTapPoint - iItemRelativeTapPoint );

		iDrawer->SetDraggableL( ETrue );

		}

	else if ( iDrawer->IsDraggable() )

		{

		iDrawer->SetDraggedPointL( aPointerEvent.iPosition - iItemRelativeTapPoint );

		}

    DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: iLastDragHighlight = %d ", iLastDragHighlight ));

    DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: highlight = %d ", highlight ));

    iLastDragPoint = aPointerEvent.iPosition;

    iLastDragHighlight = highlight;

    }

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

//

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

//

void CMmWidgetContainer::AnimateShiftL(TInt aHighlight)

	{

    TInt lowerVal =  (iDraggedIndex < aHighlight)? iDraggedIndex : aHighlight;

    TInt higherVal = (iDraggedIndex < aHighlight)? aHighlight : iDraggedIndex;

    TInt switchOperation = (iDraggedIndex < aHighlight) ? EFalse : ETrue;

       for(TInt iter(lowerVal); iter < higherVal; iter++ )

           {

           TInt from = iter + 1;

           TInt to = iter;

           if (switchOperation)

               {

               from = iter;

               to = iter + 1;

               }

           iDrawer->AnimateItemSwapL( from, to );

        }

     }

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

//

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

//

EXPORT_C void CMmWidgetContainer::CancelDragL( TBool aAnimate )

    {

    if (aAnimate)

        {

        iDrawer->AnimateDragItemTransitionL();

        }

    SetHighlightAfterDrag();

    iDraggedIndex = -1;

    iDrawer->SetDraggedIndexL( iDraggedIndex, TPoint(0,0) );

    SetDraggableL( EFalse );

    TInt dragFloatingItem;

    do

        {

        dragFloatingItem = iDrawer->GetFloatingItemIndex( EDrag );

        iDrawer->RemoveFloatingItem( dragFloatingItem );

        }

    while ( dragFloatingItem != KErrNotFound );

    iDrawer->GetAnimator()->CancelNextRedrawL();

    }

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

//

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

//

TBool CMmWidgetContainer::IsFolderL(TInt aItemIndex)

	{

	TBool result = EFalse;

	CHnSuiteModel* model = GetMmModel()->GetSuiteModel();

	if (model)

		{

		CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( aItemIndex ));

	    if (onItemModel)

	    	{

	    	result = onItemModel->GetItemType() == EItemTypeParentFolder ||

	      		onItemModel->GetItemType() == EItemTypeFolder;

	    	}

		}

	return result;

	}

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

//

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

//

TBool CMmWidgetContainer::IsNoItemDragged()

	{

	TBool noItemDragged = EFalse;

	noItemDragged = ( KErrNotFound == iDraggedIndex ) ? ETrue : noItemDragged;

	CHnSuiteModel* model = GetMmModel()->GetSuiteModel();

	if ( !noItemDragged && model)

		{

		CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( iDraggedIndex ));

	    if (onItemModel)

	    	{

	    	noItemDragged = ( onItemModel->GetItemType() == EItemTypeParentFolder );

	    	}

		}

	return noItemDragged;

	}

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

//

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

//

EXPORT_C void CMmWidgetContainer::SetHasFocusL( TBool aHasFocus )

    {

    if ( !!aHasFocus != !!iHasFocus ) // logical Ex-OR

        {

        iHasFocus = aHasFocus;

        StartOrStopMarquee();

        }

    if ( !aHasFocus )

    	{

    	SetHighlightVisibilityL( EFalse );

    	}

    }

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

//

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

//

EXPORT_C void CMmWidgetContainer::SetIsFaded( TBool aIsFaded )

    {

    if ( !!aIsFaded != !!iIsFaded ) // logical Ex-OR

        {

        iIsFaded = aIsFaded;

        StartOrStopMarquee();

        }

    }

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

//

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

//

TBool CMmWidgetContainer::LongTapInProgress() const

    {

    return iLongTapInProgress;

    }

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

//

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

//

TBool CMmWidgetContainer::IsDeleteLockedL( TInt aItemIndex )

	{

	TBool result = ETrue;

	CHnSuiteModel* model = GetMmModel()->GetSuiteModel();

	if (model)

		{

		CHnItemModel* onItemModel = model->GetItemModel(model->IdByIndex(

				aItemIndex));

		if (onItemModel)

			{

			result = onItemModel->IsDeleteLocked();

			}

		}

	return result;

	}

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

//

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

//

void CMmWidgetContainer::ManageFolderZoomingL( TBool aDraggedItemOverIcons )

	{

	TBool isAnimated;

	isAnimated = EFalse;

	for(int i=0; i< iDrawer->GetFloatingItemCount(); i++)

		{

	    TMmFloatingItem& current = iDrawer->GetFloatingItemAtIndex(i);

	    if (/*current.GetFloatingItemType() != EZoomTransition &&*/

	    		current.GetFloatingItemType() != EPostHighlightChangeRefreshItem &&

 				current.GetDrawnItemIndex() == GetHighlight() )

	    	{

	        isAnimated = ETrue;

	        break;

	        }

	    }

	if (!isAnimated)

		{

		if ( GetHighlight() != iDraggedIndex &&

			 IsFolderL( GetHighlight() ) &&

			 !IsDeleteLockedL( GetHighlight() ) &&

			 iDrawer->IsDraggable() )

			{

			iDrawer->AnimateItemZoomInL( GetHighlight() );

			}

		}

	isAnimated = EFalse;

	for(int i=0; i< iDrawer->GetFloatingItemCount(); i++)

		{

	    TMmFloatingItem& current = iDrawer->GetFloatingItemAtIndex(i);

	    if (current.GetFloatingItemType() != EZoomTransition &&

	    		current.GetFloatingItemType() != EPostHighlightChangeRefreshItem &&

				current.GetDrawnItemIndex() == iLastDragHighlight )