/*
* 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:    Manager of visual lists
*
*/




/**
 * @internal reviewed 31/07/2007 by Rowland Cook
 */
/**
 * @internal reviewed 04/07/2007 by M Byrne
 */


#include "glxvideoiconmanager.h"

#include <data_caging_path_literals.hrh>
//#include <uiacceltk/huitexture.h>
#include <alf/alfvisual.h>
#include <mpxmediageneraldefs.h>

#include <glxlog.h>
#include <glxtracer.h>

#include <glxicons.mbg> // icons 
#include <glxmedia.h>
#include <glxuistd.h>
#include <glxuiutility.h>
#include <glxtexturemanager.h>
#include <mglxmedialist.h>
#include "mglxvisuallist.h"

const TInt KGlxLargeVideoIconWidth = 30;
const TInt KGlxLargeVideoIconHeight = 169; 

const TInt KGlxSmallVideoIconWidth = 10;
const TInt KGlxSmallVideoIconHeight = 56; 

const TReal32 KGlxVideoIconWidth = 0.18;
const TReal32 KGlxVideoIconHeight = 1.0;

// ---------------------------------------------------------------------------
// 1st phase constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxVideoIconManager* CGlxVideoIconManager::NewL(
                           MGlxMediaList& aMediaList, MGlxVisualList& aVisualList)
	{
	TRACER("CGlxVideoIconManager::NewL");
	GLX_LOG_INFO("CGlxVideoIconManager::NewL ");
	CGlxVideoIconManager* self = 
	                new(ELeave)CGlxVideoIconManager(aMediaList, aVisualList);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//	
CGlxVideoIconManager::~CGlxVideoIconManager()
	{
	TRACER("CGlxVideoIconManager::~CGlxVideoIconManager");
	GLX_LOG_INFO("CGlxVideoIconManager::~CGlxVideoIconManager");
	iMediaList.RemoveMediaListObserver(this);
	iVisualList.RemoveObserver(this);
	}

// ---------------------------------------------------------------------------
// HandleAttributesAvailableL
// ---------------------------------------------------------------------------
// 
void CGlxVideoIconManager::HandleAttributesAvailableL(TInt aItemIndex,     
    const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/)
	{
	TRACER("CGlxVideoIconManager::HandleAttributesAvailableL");
	GLX_LOG_INFO("CGlxVideoIconManager::HandleAttributesAvailableL ");
    if ( KErrNotFound != aAttributes.Find(KMPXMediaGeneralCategory,
                                            TMPXAttribute::Match) )
        {
        AddIconIfVideoL( aItemIndex );
        }
	}

// ---------------------------------------------------------------------------
// HandleFocusChangedL
// ---------------------------------------------------------------------------
//        
void CGlxVideoIconManager::HandleFocusChangedL( TInt aFocusIndex, TReal32 /*aItemsPerSecond*/, 
                MGlxVisualList* /*aList*/, NGlxListDefs::TFocusChangeType /*aType*/ )
    {
    TRACER("CGlxVideoIconManager::HandleFocusChangedL");
    GLX_LOG_INFO("CGlxVideoIconManager::HandleFocusChangedL ");
    if( aFocusIndex >= 0 && aFocusIndex < iMediaList.Count() )
	    {
	    // replace video icon if necessary
	    if( iFocusIndex != KErrNotFound && iFocusIndex < iMediaList.Count() )
	        {
	        AddIconIfVideoL( iFocusIndex );
	        }
	    	  	      
	    iFocusIndex = aFocusIndex;
	    
	    AddIconIfVideoL( aFocusIndex );
	    }  
    }
	
// ---------------------------------------------------------------------------
// HandleVisualAddedL
// ---------------------------------------------------------------------------
// 
void CGlxVideoIconManager::HandleVisualAddedL( CAlfVisual* /*aVisual*/, 
    TInt aIndex, MGlxVisualList* /*aList*/ )
	{
	TRACER("CGlxVideoIconManager::HandleVisualAddedL");
	GLX_LOG_INFO("CGlxVideoIconManager::HandleVisualAddedL ");
	if(aIndex >= 0 && aIndex < iMediaList.Count() )
	    {
	    AddIconIfVideoL( aIndex );
	    }   
	}

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//	
CGlxVideoIconManager::CGlxVideoIconManager(MGlxMediaList& aMediaList, 
                                            MGlxVisualList& aVisualList)
	: CGlxIconManager(aMediaList, aVisualList)
	{
	// No  implementation
	}

// ---------------------------------------------------------------------------
// 2nd phase construction
// ---------------------------------------------------------------------------
//	
void CGlxVideoIconManager::ConstructL()
	{
	TRACER("CGlxVideoIconManager::ConstructL");
	GLX_LOG_INFO("CGlxVideoIconManager::ConstructL ");
	BaseConstructL();

    TFileName resFile(KDC_APP_BITMAP_DIR);
    resFile.Append(KGlxIconsFilename);
    iLargeVideoIcon = &(iUiUtility->GlxTextureManager().
              CreateIconTextureL( EMbmGlxiconsQgn_indi_media_fullscreen_play, 
                    resFile, TSize( KGlxLargeVideoIconWidth, 
                                KGlxLargeVideoIconHeight ) ) );
                    
    iSmallVideoIcon = &(iUiUtility->GlxTextureManager().
              CreateIconTextureL( EMbmGlxiconsQgn_indi_media_fullscreen_play, 
                    resFile, TSize( KGlxSmallVideoIconWidth, 
                                KGlxSmallVideoIconHeight ) ) );
	
	// add as observers
	iMediaList.AddMediaListObserverL(this);	
	iVisualList.AddObserverL(this);
	
	
	// check for any visual already present in list
	TInt itemCount = iMediaList.Count();
	
	iFocusIndex = iMediaList.FocusIndex();
	
	for(TInt i = 0; i < itemCount; i++)
	    {
        AddIconIfVideoL(i);
	    }
	}

    
// ---------------------------------------------------------------------------
// AddIconIfVideoL
// ---------------------------------------------------------------------------
//    
void CGlxVideoIconManager::AddIconIfVideoL( TInt aIndex ) 
    {
    TRACER("CGlxVideoIconManager::AddIconIfVideoL");
    GLX_LOG_INFO("CGlxVideoIconManager::AddIconIfVideoL ");
    TGlxMedia item = iMediaList.Item( aIndex );
    if( EMPXVideo == item.Category() )                                               
        {
        if( aIndex == iMediaList.FocusIndex() )
            {
            iVisualList.RemoveIcon( aIndex, *iSmallVideoIcon );
            iVisualList.AddIconL( aIndex, *iLargeVideoIcon, 
                        NGlxIconMgrDefs::EGlxIconTopLeft, ETrue, ETrue, 0,
                                        KGlxVideoIconWidth, KGlxVideoIconHeight );
            }
        else
            {
            iVisualList.RemoveIcon( aIndex, *iLargeVideoIcon );
            iVisualList.AddIconL( aIndex, *iSmallVideoIcon, 
                            NGlxIconMgrDefs::EGlxIconTopLeft, ETrue, ETrue, 0,
                                        KGlxVideoIconWidth, KGlxVideoIconHeight );
            }                                        
        }
    }