/*

* 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:  Active Palette 2 Model*

*/

/**

 * @file ActivePalette2Model.cpp

 * Active Palette 2 Model

 */

// INCLUDE FILES

#include <activepalette2eventdata.h>

#include <activepalette2observer.h>

#include <activepalette2itemvisible.h>

#include <activepalette2genericpluginint.h>

#include "ActivePalette2Item.h"

#include "ActivePalette2Model.h"

#include "ActivePalette2ModelObserver.h"

#include "ActivePalette2Logger.h"

#include "ActivePalette2Cfg.h"

#include "activepalette2configuration.h"

#include "ActivePalette2Utils.h"

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

// TRendererCallBacks::TRendererCallBacks()

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

//

TRendererCallBacks::TRendererCallBacks()

:   iTooltipTimer(NULL),

    iFocusTimer(NULL),

    iItemScrollTimer(NULL),

    iAppearanceTimer(NULL),

    iTooltipDescriptive(NULL),

    iFocusDescriptive(NULL),

    iItemScrollDescriptive(NULL),

    iAppearanceDescriptive(NULL)

    {

    // no implementation needed

    }

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

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

// CActivePalette2Model::NewL()

// 2 phase construction

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

//

CActivePalette2Model* CActivePalette2Model::NewL(

    MActivePalette2ModelObserver& aModelObserver,

    TSize                         aItemSize, 

    const TRendererCallBacks&     aCallbacks,

		CActivePalette2Configuration* aConfiguration /*=NULL*/ )

  {

	CActivePalette2Model * self = 

	    new (ELeave) CActivePalette2Model( aModelObserver, 

	                                       aItemSize, 

	                                       aCallbacks, 

	                                       aConfiguration );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // this

	return self;

  }

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

// CActivePalette2Model::CActivePalette2Model()

// C++ Constuctor

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

//

CActivePalette2Model::CActivePalette2Model( 

  MActivePalette2ModelObserver& aModelObserver,

  TSize                         aItemSize, 

  const TRendererCallBacks&     aCallbacks,

  CActivePalette2Configuration* aConfiguration )

  : iPreviousItemID(KInvalidId),

    iFocusedItemID(KInvalidId),

    iPaletteMoveCurrentOffset(0),

    iPaletteMoveOffsetTotalFrames(NAP2Cfg::KPaletteAppearFrames),

    iPaletteMoveAnimationDuration(NAP2Cfg::KPaletteAppearTotalTime / KMicrosecondsPerMillisecond),

    iAnimState(EPaletteAnimIdle),

    iCallbacks(aCallbacks),

    iModelObserver(aModelObserver),

    iItemSize(aItemSize),

    iTooltipConfig()

  {

  LOGTEXT( _L( "CActivePalette2Model::CActivePalette2Model entered" ));	

  if( aConfiguration )

    {

    aConfiguration->TooltipConfiguration( iTooltipConfig );

    }

  else

    {

    iTooltipConfig.iPreshowDelay     = NAP2Cfg::KTooltipPreshowDelay;

    iTooltipConfig.iFullshowPeriod   = NAP2Cfg::KTooltipFullshowPeriod;

    iTooltipConfig.iTimerTickLength  = NAP2Cfg::KTooltipTimerTickLength;

    iTooltipConfig.iTransitionSpeed  = NAP2Cfg::KTooltipShowSpeed;

    iTooltipConfig.iTransitionFrames = KErrNotSupported;

    }

  LOGTEXT( _L( "CActivePalette2Model::CActivePalette2Model left" ));	

  }

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

// CActivePalette2Model::ConstructL(void)

// 2nd phase constructor

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

//

void CActivePalette2Model::ConstructL(void)

    {

	iTooltipTimer = CPeriodic::NewL(CActive::EPriorityHigh); // high priority for smooth animation

	iFocusChangeTimer = CPeriodic::NewL(CActive::EPriorityHigh);

    iItemScrollTimer = CPeriodic::NewL(CActive::EPriorityHigh);

    iItemAnimTimer = CPeriodic::NewL(CActive::EPriorityHigh);

    iPaletteMoveTimer = CPeriodic::NewL(CActive::EPriorityHigh);

    }

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

// CActivePalette2Model::~CActivePalette2Model()

// Destructor

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

//

CActivePalette2Model::~CActivePalette2Model()

    {

	LOGTEXT( _L( "CActivePalette2Model::~CActivePalette2Model entered" ));

	if (iTooltipTimer) 

	    {

		iTooltipTimer->Cancel();	

		delete iTooltipTimer;

	    }

	if (iFocusChangeTimer) 

	    {

		iFocusChangeTimer->Cancel();	

		delete iFocusChangeTimer;

	    }

    if (iItemScrollTimer)

        {

		iItemScrollTimer->Cancel();	

		delete iItemScrollTimer;

        }

	if (iItemAnimTimer) 

	    {

		iItemAnimTimer->Cancel();	

		delete iItemAnimTimer;

	    }

	if (iPaletteMoveTimer) 

	    {

		iPaletteMoveTimer->Cancel();	

		delete iPaletteMoveTimer;

	    }

	iItemsArray.ResetAndDestroy();

	iItemsArray.Close();

	iVisibilityArray.Reset();

	iVisibilityArray.Close();

	LOGTEXT( _L( "CActivePalette2Model::~CActivePalette2Model left" ));

    }

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

// CActivePalette2Model::FindItem()

// item data management

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

//

CActivePalette2Item* CActivePalette2Model::FindItem(const TInt aItemId) const

    {

	TInt index = ItemIndexFromId(aItemId);

	if ( ValidItemIndex(index) ) 

	    {

	    return static_cast<CActivePalette2Item *>(iItemsArray[index]);

	    }

    else

        {

    	return NULL;

        }

    }

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

// CActivePalette2Model::DoInstallItemL()

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

//

TInt CActivePalette2Model::DoInstallItemL(TInt aItemId, 

                                          TBool aVisible,

										  const TUid& aPluginUid, 

										  const TDesC8& aCustomDataDes, 

										  TInt aCustomDataInt)

    {

	// check if item ID is unique

	if ( ItemIndexFromId(aItemId) != KInvalidItemIndex )

	    {

		return KErrArgument;

	    }

	// item and plugin instantiate

	CActivePalette2Item* item = CActivePalette2Item::NewLC(aItemId,aPluginUid, *this);

	item->InitPluginL(aCustomDataDes, aCustomDataInt);

    User::LeaveIfError(iItemsArray.Append(item));

    User::LeaveIfError(iVisibilityArray.Append(aVisible));

	CleanupStack::Pop(item);

    if ( aVisible )

        {

        EnforceConstraints();

        } 

	return KErrNone;	

    }

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

// CActivePalette2Model::RemoveItem()

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

//

TInt CActivePalette2Model::RemoveItem(const TInt aItemId)

    {

	LOGTEXT1( _L( "CActivePalette2Model::RemoveItem entered, Item ID: %d" ), 

			 aItemId);

	TInt res(KErrNone);

	CActivePalette2Item* item = FindItem(aItemId);

	TInt index = ItemIndexFromId(aItemId);

	if (item)    // valid item

	    {

		iItemsArray.Remove(index); // unregister

		iVisibilityArray.Remove(index);

		// destroy item	

		CBase::Delete(item);     // implies plugin shutodown and DLL unload

        EnforceConstraints();

	    }

	else

	    {

		res = KErrArgument;

	    }

	LOGTEXT1( _L( "CActivePalette2Model::RemoveItem left, res %d" ), res);

	return res;	

    }

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

// CActivePalette2Model::HandleItemSelected()

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

//

void CActivePalette2Model::HandleItemSelected(const TInt aItemIndex)

    {

	LOGTEXT1( _L( "CActivePalette2Model::HandleItemSelected entered, Item ID: %d" ), 

			 aItemIndex);

    if ( ValidItemIndex(aItemIndex) )

        {

    	CActivePalette2Item* item = iItemsArray[aItemIndex];

    	if (item)

        	{

    		TInt err;

    		LOGTEXT( _L( "... calling plugin's HandleItemSelectedL" ));

    		TRAP(err, item->Plugin().HandleItemSelectedL());

    		LOGTEXT1( _L( "... res : %d" ), err);

    		if (KErrNone != err)

    		    {

    		    // leave during item selection handling, invoke callback now

    			NotifyItemComplete(*item, err, KNullDesC8, KActivePaletteNoDataInt);

    		    }

    	    } 

    	else

    	    {

    		LOGTEXT( _L( "... INTERNAL FAULT: item object not found" ));	

    	    }

        }

	LOGTEXT( _L( "CActivePalette2Model::HandleItemSelected left" ));

    }

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

// CActivePalette2Model::DispatchMessage()

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

//

TInt CActivePalette2Model::DispatchMessage(const TInt aItemId, const TInt aMessageID, const TDesC8& aDataDes, const TInt aDataInt)

    {

	LOGTEXT2( _L( "CActivePalette2Model::DispatchMessgage entered, Item ID: %d, Message ID : %d" ), 

			 aItemId, aMessageID);

	TInt res;

	CActivePalette2Item* item = FindItem(aItemId);

	if (item)

	    {

		TInt err;

		LOGTEXT( _L( "...calling plugin's HandleMessageL" ));

		TRAP(err, item->Plugin().HandleMessageL(aMessageID, aDataDes, aDataInt));

		LOGTEXT1( _L( "... res : %d" ), err);

		res = err; // retransmit error code

	    }

	else

	    {

		res = KErrArgument;

	    }

	LOGTEXT1( _L( "CActivePalette2Model::DispatchMessgage left, res %d" ), res);

	return res;

    }

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

// CActivePalette2Model::Observer()

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

//

MActivePalette2ModelObserver& CActivePalette2Model::Observer(void) const

    {

	return iModelObserver;

    }

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

// CActivePalette2Model::ItemIndexFromId()

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

//

TInt CActivePalette2Model::ItemIndexFromId(const TInt aItemId) const

    {

    TInt res = KInvalidItemIndex;

    TInt currentItemIndex = 0;

    while ( res == KInvalidItemIndex && ValidItemIndex(currentItemIndex) )

        {

        if ( iItemsArray[currentItemIndex]->ItemId() == aItemId )

            {

            res = currentItemIndex;

            }

        else

            {

            currentItemIndex++;

            }

        }

    return res;    

    }

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

// CActivePalette2Model::TooltipText()

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

//

TDesC* CActivePalette2Model::TooltipText()

    {

    if ( ValidItemIndex(iFocusedItem) )

        {

        CActivePalette2Item& api = static_cast<CActivePalette2Item &> (*iItemsArray[iFocusedItem]);

        return api.Tooltip();

        }

    else

        {

        return NULL;

        }

    }

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

// CActivePalette2Model::ShowTooltip()

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

//

TBool CActivePalette2Model::ShowTooltip()

    {

    return iShowTooltip;

    }

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

// CActivePalette2Model::TooltipCurrentFrame()

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

//

TInt CActivePalette2Model::TooltipCurrentFrame()

    {

    return iTooltipCurrentFrame;

    }

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

// CActivePalette2Model::TooltipTotalFrames()

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

//

TInt CActivePalette2Model::TooltipTotalFrames()

    {

    return iTooltipTotalFrames;

    }

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

// CActivePalette2Model::TooltipScreenPosition()

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

//

TInt CActivePalette2Model::TooltipScreenPosition()

    {

    return FocusedItem();

    }

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

// CActivePalette2Model::CompelTooltip()

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

//

void CActivePalette2Model::CompelTooltip()

    {

    TInt tooltip_width = iModelObserver.TooltipUpdated();

    if( iTooltipConfig.iTransitionFrames > 0 )

      iTooltipTotalFrames = iTooltipConfig.iTransitionFrames;

    else

      iTooltipTotalFrames = tooltip_width / iTooltipConfig.iTransitionSpeed;

    TooltipSetState( ETooltipRise );

    }

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

// CActivePalette2Tooltip::RemoveTooltip(void)

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

//

void CActivePalette2Model::RemoveTooltip(void)

	{

	TooltipSetState(ETooltipNone);

	}

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

// CActivePalette2Tooltip::TooltipSteadyAniAction()

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

//

TInt CActivePalette2Model::TooltipSteadyAniAction(void)

	{

	// start shrinking

    TooltipSetState(ETooltipSet);

	return KCallbackFinished;	

	}

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

// CActivePalette2Tooltip::TooltipRiseAniAction()

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

//

TInt CActivePalette2Model::TooltipRiseAniAction(void)

	{

	TInt res = KCallbackFinished;

	iShowTooltip = ETrue;

	if ( iCallbacks.iTooltipTimer )

    	{

    	if (iTooltipCurrentFrame >= iTooltipTotalFrames)

    		{

    		TooltipSetState(ETooltipSteady);

    		}

    	else

    		{

    		res = KCallbackCallAgain;

    		iTooltipCurrentFrame++;

    		}

        iCallbacks.iTooltipTimer->TooltipAnimated();

        }

    else if ( iCallbacks.iTooltipDescriptive )

        {

        TInt duration( (iTooltipTotalFrames*iTooltipConfig.iTimerTickLength) / KMicrosecondsPerMillisecond );

        iCallbacks.iTooltipDescriptive->AnimateTooltip( ETrue, duration );

        iTooltipTimer->Cancel();

        }

    else

        {

        // just for Lint.

        }

	return res;

	}

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

// CActivePalette2Tooltip::TooltipDisappearAniAction()

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

//

TInt CActivePalette2Model::TooltipDisappearAniAction(void)

	{

	TInt res = KCallbackFinished;

	if ( iCallbacks.iTooltipTimer )

    	{

    	if (iTooltipCurrentFrame <= 0)

    		{

    		TooltipSetState(ETooltipNone);

    		}

    	else

    		{

    		res = KCallbackCallAgain;

    		iTooltipCurrentFrame--;

    		}

        if ( iCallbacks.iTooltipTimer )

            {		

            iCallbacks.iTooltipTimer->TooltipAnimated();

            }

        }

    else if ( iCallbacks.iTooltipDescriptive )