/*

* Copyright (c) 2008-2009 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:  Interface to Alf Objects  

*

*/

#include "glxmulmodelproviderbase.h"

#include <alf/alfenv.h>

#include <alf/alfevent.h>

#include <alf/ialfwidgetfactory.h>

#include <alf/alfwidgetenvextension.h>

#include <mul/imulwidget.h>

#include <mul/mulevent.h>

#include <mul/mulvisualitem.h>

#include <glxlog.h>  //Logging

#include <glxtracer.h>

#include <glxnavigationalstate.h>

#include <glxnavigationalstatedefs.h>

#include <data_caging_path_literals.hrh>// for KDC_APP_RESOURCE_DIR

#include <glxuiutilities.rsg>

#include <glxgeneraluiutilities.h>

#include <glxtexturemanager.h>

#include <glxicons.mbg>

#include <glxuistd.h>

#include "glxdrmgiftexturecreator.h"

using namespace Alf;

static const char* const KListWidget = "ListWidget";

static const char* const KGridWidget = "GridWidget";

static const char* const KCoverFlowWidget = "CoverflowWidget";

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

// BaseConstructL

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

//

void CGlxMulModelProviderBase::BaseConstructL(

     CAlfEnv& aEnv, 

     Alf::mulwidget::TLogicalTemplate aDefaultTemplate,

     TInt aDataWindowSize )

    {

    TRACER("CGlxMulModelProviderBase::BaseConstructL");

    // Create navigational state 

    iNavigationalState = CGlxNavigationalState::InstanceL();

    iEnv = &aEnv;

    iDefaultTemplate = aDefaultTemplate;

    iDataWindowSize = aDataWindowSize;

    }

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

// Constructor

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

//

CGlxMulModelProviderBase::CGlxMulModelProviderBase( IMulWidget& aWidget )

        : iWidget( aWidget ),iPreviousFocusIndex(-1)

    {

    }

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

// Destructor

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

//

CGlxMulModelProviderBase::~CGlxMulModelProviderBase()

    { 

    TRACER("CGlxMulModelProviderBase::~CGlxMulModelProviderBase");

    if(iDrmGifTextureCreator)

        {

        delete iDrmGifTextureCreator;

        iDrmGifTextureCreator = NULL;

        }

    //   remove event handler

	iWidget.RemoveEventHandler( *this );

    if ( iNavigationalState )

          {

          iNavigationalState->Close();

          }

	}    

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

// HandleItemAddedL

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

// 

void CGlxMulModelProviderBase::HandleItemAddedL( TInt /*aStartIndex*/, TInt 

	/*aEndIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// HandleItemRemoved

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

//	

void CGlxMulModelProviderBase::HandleItemRemovedL( TInt /*aStartIndex*/, TInt 

	/*aEndIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// HandleAttributesAvailableL

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

//	

void CGlxMulModelProviderBase::HandleAttributesAvailableL( TInt /*aItemIndex*/, 

	const RArray<TMPXAttribute>& /*aAttributes*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// HandleFocusChangedL

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

//	

void CGlxMulModelProviderBase::HandleFocusChangedL( NGlxListDefs::

	TFocusChangeType /*aType*/, TInt /*aNewIndex*/, TInt /*aOldIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// HandleItemSelected

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

//	

void CGlxMulModelProviderBase::HandleItemSelectedL(TInt aIndex, 

	TBool aSelected, MGlxMediaList* /*aList*/ )

	{

	TRACER("CGlxMulModelProviderBase::HandleItemSelectedL");

	std::vector<int> itemIndex;	

	itemIndex.push_back( aIndex);	

	// changed code ---statr

	if(aSelected) 

	    {

	    iModel->SetMarkedIndices(MulWidgetDef::EMulMark,itemIndex);

	    }

	else 

	    {	

	    iModel->SetMarkedIndices(MulWidgetDef::EMulUnmark,itemIndex);	

	    }

	}

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

// accept

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

//	

bool CGlxMulModelProviderBase::accept( Alf::CAlfWidgetControl& /*aControl*/, const 

	TAlfEvent& /*aEvent*/ ) const

	{

	TRACER("CGlxMulModelProviderBase::accept");

	//Need implementation

	return NULL;

	}

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

// offerEvent

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

//

AlfEventStatus CGlxMulModelProviderBase::offerEvent( Alf::CAlfWidgetControl& 

		/*aControl*/, const TAlfEvent& aEvent )

	{

	TRACER("CGlxMulModelProviderBase::offerEvent");

	AlfEventStatus response = EEventNotHandled;

	if ( aEvent.IsCustomEvent() )

		{

		switch ( aEvent.CustomParameter() ) 

			{

			case KAlfActionIdDeviceLayoutChanged:

				{

				HandleOrientationChanged();

				response = EEventNotHandled;

				}

				break;

			case Alf::ETypeHighlight:

				{

				if ( !iWithinFocusChangeCall )

					{

					HandleFocusChanged( FocusIndex(), iPreviousFocusIndex );

					}

				response = EEventHandled;

				}

				break;

		}

	return response;

	}

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

// setActiveStates

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

//

void CGlxMulModelProviderBase::setActiveStates( unsigned int /*aStates*/ ) 

    {

    }

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

// setEventHandlerData

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

//  

void CGlxMulModelProviderBase::setEventHandlerData( const Alf::AlfWidgetEventHandlerInitData& /*aData*/ )

    {

    }

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

// eventHandlerData

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

//  

Alf::AlfWidgetEventHandlerInitData* CGlxMulModelProviderBase::eventHandlerData() 

    {

    TRACER("CGlxMulModelProviderBase::eventHandlerData");

    return NULL; 

    }

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

// makeInterface

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

//    

Alf::IAlfInterfaceBase* CGlxMulModelProviderBase::makeInterface(const Alf::IfId& /*aType */)

    {

    TRACER("CGlxMulModelProviderBase::makeInterface");

    return this;

    }

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

// eventHandlerType

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

//    

IAlfWidgetEventHandler::AlfEventHandlerType CGlxMulModelProviderBase::

    eventHandlerType() 

	{

	TRACER("CGlxMulModelProviderBase::eventHandlerType");

	// To Avoid Compiler warning

	return IAlfWidgetEventHandler::ELogicalEventHandler;

	}

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

// eventExecutionPhase

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

//    

IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase 

    CGlxMulModelProviderBase::eventExecutionPhase()

	{

	TRACER("CGlxMulModelProviderBase::eventExecutionPhase");

	return EBubblingPhaseEventHandler;

	}

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

// UpdateItemL

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

//	

void CGlxMulModelProviderBase::UpdateItems( TInt aIndex, TInt aCount )

    {

    TRACER("CGlxMulModelProviderBase::UpdateItems");

    try 

        {

        iModel->Update( aIndex, aCount );

        }

    catch (...)

        {

        throw std::bad_alloc();

        }

    }

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

// SetDataT

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

//	

void CGlxMulModelProviderBase::SetDataT( const CGlxBinding& aBinding,

        const TGlxMedia& aMedia, TInt aAtIndex, MGlxMediaList& aMediaList )

    {

    TRACER("CGlxMulModelProviderBase::SetDataT");

    if(IsFocused(aAtIndex))

        {

        TBool drm = EFalse;

        TGlxMediaGeneralRightsValidity isValid = EGlxDrmRightsValidityUnknown;

        if (aMedia.GetDrmProtected(drm))

            {

            aMedia.GetDrmValidity(isValid);

            GLX_DEBUG2("CGlxMulModelProviderBase::SetDataT DrmValidity(%d)", isValid);

            }

        TInt frameCount;

        aMedia.GetFrameCount(frameCount);

        GLX_DEBUG2("CGlxMulModelProviderBase::SetDataT framecount=%d", frameCount);

        //Create the DRM gif texture intance only if the DRM gif image is

        //valid and focused

        if (frameCount > 1 && drm && isValid == EGlxDrmRightsValid)

            {

            if (!iDrmGifTextureCreator)

                {

                iDrmGifTextureCreator = CGlxDrmGifTextureCreator::NewL(

                        aBinding, aMedia, aAtIndex, iModel, aMediaList);

                }

            else

                {

                iDrmGifTextureCreator->UpdateNewImageL(aMedia, aAtIndex);

                }

            }

        else

            {

            //if the focus is changed then delete the DRMGifTextureCreator 

            //instance if any

            if (iDrmGifTextureCreator)

                {

                delete iDrmGifTextureCreator;

                iDrmGifTextureCreator = NULL;

                }

            iModel->SetData(aAtIndex, CreateItemT(aBinding, aMedia,

                    IsFocused(aAtIndex)));

            }

        }

    else

        {

        iModel->SetData( aAtIndex, CreateItemT( aBinding, aMedia, 

            IsFocused( aAtIndex ) ) );

        }

    }

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

// CreateItemT

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

//    

auto_ptr<MulVisualItem> CGlxMulModelProviderBase::CreateItemT( 

    const CGlxBinding& aBinding, const TGlxMedia& aMedia, TBool aIsFocused )     

    {

    TRACER("CGlxMulModelProviderBase::CreateItemT");

    auto_ptr<MulVisualItem> item( new ( EMM ) MulVisualItem() );

    aBinding.PopulateT( *item, aMedia, aIsFocused );

    return item;

    }

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

// CreateModelL

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

//    

void CGlxMulModelProviderBase::CreateModelL()

    {

    const char* KLoadNameModel( "mulmodel" );

    try 

        {

        IAlfWidgetFactory& widgetFactory = AlfWidgetEnvExtension::widgetFactory(*iEnv);

        std::auto_ptr< Alf::IMulModel > model( 

                widgetFactory.createModel< IMulModel >( KLoadNameModel ) );

        iModel = model.release(); 

        if( iDataWindowSize > 0 )

            {

            iModel->SetDataWindow(iDataWindowSize);

            }

        iModel->SetDataProvider( *this );

        iModel->SetTemplate( iDefaultTemplate );

        }

    catch (...)

        {

        User::Leave( KErrNoMemory );

        }

    }

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

// InsertItemsL

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

//    

void CGlxMulModelProviderBase::InsertItemsL( TInt aIndex, TInt aCount, TInt aMediaListFocusIndex )

    {

    TRACER("CGlxMulModelProviderBase::InsertItemsL");

    // The order of calling should be Model->Insert(..), 

    // Model->SetHighlight(..) and Widget.SetModel(..)

    // Change the order once bug EPBA-7JRDXV ( SetModel Crashes if highlight 

    // index is set >0 before setting model. )is fixed. 

    if(!iWidget.model())

        {

        CreateModelL();

        }

    if(iWidget.model())

        {

        iModel->SetTemplate( iDefaultTemplate );

        }

    iModel->Insert( aIndex, aCount );     

    if( aMediaListFocusIndex >= 0 )

        {

        SetFocusIndex( aMediaListFocusIndex );

        }

    if(!iWidget.model())

        {

        iWidget.SetModel( iModel->Accessor() );

        CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

        CleanupClosePushL( *uiUtility );

        TSize defaultIconSize = uiUtility->GetGridIconSize();

        TFileName resFile(KDC_APP_BITMAP_DIR);

        resFile.Append(KGlxIconsFilename);

        TInt defaultTextureId =  uiUtility->

                        GlxTextureManager().CreateIconTextureL( 

                        EMbmGlxiconsQgn_prop_image_notcreated, resFile, 

                        defaultIconSize ).Id();

        static_cast<IMulCoverFlowWidget&>(iWidget).SetDefaultImage( defaultTextureId ) ;

        CleanupStack::PopAndDestroy( uiUtility );

        }    

    }

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

// RemoveItem

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

//    

void CGlxMulModelProviderBase::RemoveItems( TInt aIndex, TInt aCount )

    {

    TRACER("CGlxMulModelProviderBase::RemoveItems");

    // RemoveItems does not throw according to model documentation

    iModel->Remove( aIndex, aCount );

    }    

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

// SetFocusIndex

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

//    

void CGlxMulModelProviderBase::SetFocusIndex( TInt aIndex )

    {

    TRACER("CGlxMulModelProviderBase::SetFocusIndex");

    iModel->SetHighlight( aIndex );

    }

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

// IsFocused

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

//

TBool CGlxMulModelProviderBase::IsFocused( TInt aIndex ) const 

    {

    TRACER("CGlxMulModelProviderBase::IsFocused");

    return aIndex == FocusIndex() && aIndex != LAST_INDEX;

    }

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

// FocusIndex

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

//

TInt CGlxMulModelProviderBase::FocusIndex() const

    {

    TRACER("CGlxMulModelProviderBase::FocusIndex");

    TInt index = 0;

    /// @todo use multiline widget instead of this widget hack. Currently model does not have interface for highlight.

    // We are comparing depending on teh widget name which we are setting during the 

    // widget creation, but for that we had to do dynamic_cast which fails on hardware

    // and is not the preffered way of doing, so as of now we have to check using widget name

    if(UString(KListWidget) == UString(iWidget.widgetName() ) )

        {

        index = iModel->Highlight();

        }

    else if ( UString(KGridWidget) == UString(iWidget.widgetName() ) )

        {

        index = iModel->Highlight();

        }

    else if (UString(KCoverFlowWidget) == UString(iWidget.widgetName() ) )

        {

      	index = iModel->Highlight();

	    }

    else

        {

        return KErrGeneral;

        }

    return index;

    }

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

// HandleMessageL

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

//    

 void CGlxMulModelProviderBase::HandleMessageL( const CMPXMessage& /*aMessage*/, 

	MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleError

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

//

void CGlxMulModelProviderBase::HandleError( TInt /*aError*/ ) 

    {

    }

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