/*

* 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 12/06/2007 by Alex Birkett

 */

#include "glxmarkediconmanager.h"

#include <mglxvisuallist.h>

#include <mglxmedialist.h>

#include <alf/alftexture.h>

#include <alf/alfvisual.h>

#include <alf/alfbrush.h>

#include <glxuiutility.h>

#include <glxtracer.h>

#include <glxtexturemanager.h>

#include <aknconsts.h>

#include <avkon.mbg>

const TInt KGlxMarkedIconSize = 13;

const TInt KGlxMarkedIconBorder = 2;

const TInt KGlxMarkingOpaque = 127;

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

// 1st phase constructor

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

//

CGlxMarkedIconManager* CGlxMarkedIconManager::NewL(MGlxMediaList& aMediaList, 

                                                    MGlxVisualList& aVisualList)

    {

    CGlxMarkedIconManager* self = 

            new(ELeave)CGlxMarkedIconManager(aMediaList, aVisualList);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

//  

CGlxMarkedIconManager::~CGlxMarkedIconManager()

    {   

    iMediaList.RemoveMediaListObserver(this);

    iVisualList.RemoveObserver(this);

	if( iBlackTexture )

	    {

	    // call texture manager to remove the texture

	    // Ui Utility is owned by base 

	    if(iUiUtility)

		    {

	        iUiUtility->GlxTextureManager().RemoveTexture( *iBlackTexture );

		    }

	    }

    }

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

// SetMultipleMarkingModeIndicatorsL

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

//  

void CGlxMarkedIconManager::SetMultipleMarkingModeIndicatorsL(TBool 

                                                    aMultipleModeEnabled)

    {

    TRACER("CGlxMarkedIconManager::SetMultipleMarkingModeIndicatorsL");

    iMultipleMarkingEnabled = aMultipleModeEnabled;

    // set/remove opaque overlay on visible unmarked items

    TInt count = iMediaList.Count();

    for(TInt i = 0; i<count; i++)

        {

        if(!iMediaList.IsSelected(i))

            {

            if(iMultipleMarkingEnabled)

                {

                // attempt to add overlay icon to unmarked item

                iVisualList.AddIconL( i, *iBlackTexture, 

                   NGlxIconMgrDefs::EGlxIconTopLeft, ETrue, ETrue, 0 );

                }

            else

                {

                // attempt to remove overlay

                iVisualList.RemoveIcon( i, *iBlackTexture );

                }

            }

        }

    }

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

// HandleItemAddedL

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

//

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

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

    {

    // No implementation required   

    }

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

// HandleMediaL

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

void CGlxMarkedIconManager::HandleMediaL(TInt /*aListIndex*/, 

                                                    MGlxMediaList* /*aList*/)

    {

    // No implementation required

    }

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

// HandleItemRemovedL

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

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

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

    {

    // No implementation required

    }

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

// HandleItemModifiedL

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

void CGlxMarkedIconManager::HandleItemModifiedL(const RArray<TInt>& 

                                    /*aItemIndexes*/, MGlxMediaList* /*aList*/)

    {

    // No implementation required

    }

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

// HandleAttributesAvailableL

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

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

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

    {

    // No implementation required

    }

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

// HandleFocusChangedL

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

void CGlxMarkedIconManager::HandleFocusChangedL(NGlxListDefs::TFocusChangeType /*aType*/, 

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

    {

    // No implementation required

    }

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

// HandleItemSelectedL

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

void CGlxMarkedIconManager::HandleItemSelectedL(TInt aIndex, TBool aSelected, 

                                                    MGlxMediaList* /*aList*/)

    {

    TRACER("CGlxMarkedIconManager::HandleItemSelectedL");

    // if selected add tick icon else remove tick item 

    // (assuming item is already marked)

    if(aSelected)

        {

        iVisualList.AddIconL( aIndex, *iMarkTexture, 

                                NGlxIconMgrDefs::EGlxIconTopRight, 

                                ETrue, EFalse, KGlxMarkedIconBorder );

        if(iMultipleMarkingEnabled)

            {

            // attempt to remove overlay

            iVisualList.RemoveIcon( aIndex, *iBlackTexture );

            }

        }

    else

        {

        // only 1 icon to choose from

        iVisualList.RemoveIcon( aIndex, *iMarkTexture );

        if(iMultipleMarkingEnabled)

            {

            // attempt to add overlay icon to unmarked item

            iVisualList.AddIconL( aIndex, *iBlackTexture, 

                   NGlxIconMgrDefs::EGlxIconTopLeft, ETrue, ETrue, 0 );

            }

        }

    }

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

// HandleMessageL

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

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

                                            MGlxMediaList* /*aList*/)

    {

    // No implementation required

    }

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

// HandleFocusChangedL

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

void CGlxMarkedIconManager::HandleFocusChangedL( TInt /*aFocusIndex*/, 

                    TReal32 /*aItemsPerSecond*/, MGlxVisualList* /*aList*/,

                    NGlxListDefs::TFocusChangeType /*aType*/ )    

    {

    // No implementation required

    }

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

// HandleSizeChanged

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

void CGlxMarkedIconManager::HandleSizeChanged( const TSize& /*aSize*/, 

                                                MGlxVisualList* /*aList*/ )

    {

    // No implementation required

    }

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

// HandleVisualRemoved

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

void CGlxMarkedIconManager::HandleVisualRemoved( const CAlfVisual* /*aVisual*/, 

                                                 MGlxVisualList* /*aList*/ )

    {

    // No implementation required

    }

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

// HandleItemAddedL

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

void CGlxMarkedIconManager::HandleVisualAddedL( CAlfVisual* /*aVisual*/, 

                                    TInt aIndex, MGlxVisualList* /*aList*/ )

    {

    TRACER("CGlxMarkedIconManager::HandleVisualAddedL");

    // add brushes to any new visuals if required

    // aIndex should be index to media list

    if(iMediaList.IsSelected(aIndex))

        {

        iVisualList.AddIconL( aIndex, *iMarkTexture, 

                   NGlxIconMgrDefs::EGlxIconTopRight, 

                   ETrue, EFalse, KGlxMarkedIconBorder );

        }

    else

        {

        // if in multiple marking mode

        // ensure non-selected items have overlay

        if(iMultipleMarkingEnabled)

            {

            iVisualList.AddIconL( aIndex, *iBlackTexture, 

                   NGlxIconMgrDefs::EGlxIconTopLeft, ETrue, ETrue, 0 );

            }

        }

    }

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

// Constructor

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

//  

CGlxMarkedIconManager::CGlxMarkedIconManager(MGlxMediaList& aMediaList, 

                                                MGlxVisualList& aVisualList)

    : CGlxIconManager(aMediaList, aVisualList)

    {

    // No implementation required

    }

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

// 2nd phase construction

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

//  

void CGlxMarkedIconManager::ConstructL()

    {

    TRACER("CGlxMarkedIconManager::ConstructL");

    BaseConstructL();

    // create 'tick' icon

    TFileName resFile(KAvkonBitmapFile);

    // get texture manager from UI utility (owned by base class)

    CGlxTextureManager& tm = iUiUtility->GlxTextureManager();

    // get mark texture frim texture manager

    iMarkTexture = &(tm.CreateIconTextureL( EMbmAvkonQgn_indi_marked_grid_add, 

                            resFile, TSize( KGlxMarkedIconSize, KGlxMarkedIconSize) ) );

    TRgb overlayColour( KRgbBlack );

    overlayColour.SetAlpha( KGlxMarkingOpaque );

    iBlackTexture = &( tm.CreateFlatColourTextureL( overlayColour ) );

    // add as observers

    iMediaList.AddMediaListObserverL(this); 

    iVisualList.AddObserverL(this);

    }