/*

* 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:    Media List Command Handler

*

*/

#include <e32base.h>

#include "glxmedialistcommandhandler.h"

#include <eikprogi.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessageprogressdefs.h>

#include <StringLoader.h>

#include <glxattributecontext.h>

#include <glxattributeretriever.h>

#include <glxfetchcontextremover.h>

#include <glxgeneraluiutilities.h>

#include <glxuiutility.h>

#include <glxmediageneraldefs.h>

#include <glxuistd.h>

#include <mglxmedialist.h>

#include <glxcommandhandlers.hrh>

#include "mglxmedialistprovider.h"

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

// Constructor for command info

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

//	

EXPORT_C CGlxMediaListCommandHandler::TCommandInfo::TCommandInfo(TInt aCommandId) 

    {

    // Set command id 

    iCommandId = aCommandId;

    // Do not stop animation before execution

    iStopAnimationForExecution = EFalse;

    // Disable for system items

    iDisallowSystemItems = EFalse;

    // Disable for DRM protected items

    iDisallowDRM = EFalse;

    // Set selection length requirement so that it does not filter

    iMinSelectionLength = 0;

    iMaxSelectionLength = KMaxTInt;

    // default minimum item count

    iMinSlideshowPlayableContainedItemCount = 0;

    // Disable for animated GIFs

    iDisallowAnimatedGIFs = EFalse;

    // Default item category is "none"

    iCategoryFilter = EMPXNoCategory;    

    // Don't apply category filter

    iCategoryRule = EIgnore;

    // Set the default viewing state

    iViewingState = EViewingStateUndefined;

    }

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

// Constructor

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

//	

EXPORT_C CGlxMediaListCommandHandler::CGlxMediaListCommandHandler(

	MGlxMediaListProvider* aMediaListProvider,

	TBool aHasToolbarItem):CGlxCommandHandler(aHasToolbarItem)

	{

	iMediaListProvider = aMediaListProvider;

	iCurrentViewingState = TCommandInfo::EViewingStateUndefined;

	}

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

// Destructor

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

//	

EXPORT_C CGlxMediaListCommandHandler::~CGlxMediaListCommandHandler()

	{

	iCommandInfoArray.Reset();

	}

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

// ExecuteL

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

//	

EXPORT_C TBool CGlxMediaListCommandHandler::ExecuteL(TInt aCommandId)

    {

    TBool consume = EFalse;

    switch (aCommandId)

        {

        case EGlxCmdStateBrowse:

            iCurrentViewingState = TCommandInfo::EViewingStateBrowse;

            break;

        case EGlxCmdStateView:

            iCurrentViewingState = TCommandInfo::EViewingStateView;

            break;

        default:                    // Do nothing

            break;

        }

    /// @todo Consume the state command. This requires changing derived classes so that they do not 

    /// receive the state commands, but use the TCommandInfo filtering for state. Too risky change

    /// to do for inc6.1.

    if ( BypassFiltersForExecute() )

        {

        MGlxMediaList& list = MediaList();

        consume = DoExecuteL(aCommandId, list);

        }

    else

        {

        // Is this command handled by this command handler

        if ( IsSupported( aCommandId ) )

            {

            MGlxMediaList& list = MediaList();

            // Do not consume if the command is disabled

            if ( !IsDisabledL(aCommandId, list) )

                {

                // Ask deriving class to execute

                consume = DoExecuteL(aCommandId, list);

                }

            }

        }

    return consume;

    }

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

// DynInitMenuPaneL

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

//	

EXPORT_C void CGlxMediaListCommandHandler::DynInitMenuPaneL(TInt aResourceId, 

        CEikMenuPane* aMenuPane)

	{

	if ( aMenuPane )

	    {

	    if ( BypassFiltersForMenu() )

	        {

			DoDynInitMenuPaneL(aResourceId, aMenuPane);

	        }

	    else

	        {

    		TInt num_items = aMenuPane->NumberOfItemsInPane();

    		TBool atLeastOneEnabledSupportedItem = EFalse;

    		//CGlxUiUtility* uiUtility  = CGlxUiUtility::UtilityL();

            //CleanupClosePushL(*uiUtility);

    		// Iterate through menu pane

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

    			{

    			CEikMenuPaneItem::SData& item = aMenuPane->ItemDataByIndexL(i);

        	    // Check if the menu command is know to this command handler

        	    if ( IsSupported( item.iCommandId ) )

        	        {

        	        TBool isDisabled = IsDisabledL(item.iCommandId, MediaList());

        	        if( !isDisabled && 

        	            iCurrentViewingState == TCommandInfo::EViewingStateView )

        	            {

                        //isDisabled = sf.IsActivePaletteItemVisible( item.iCommandId );

        	            }

        	        // Check visibility of the menu item

    				aMenuPane->SetItemDimmed( item.iCommandId, isDisabled);

    				atLeastOneEnabledSupportedItem = atLeastOneEnabledSupportedItem || (!isDisabled);

        	        }

    			}

    	   // CleanupStack::PopAndDestroy(uiUtility);

    	    if ( atLeastOneEnabledSupportedItem )

    	        {

    			DoDynInitMenuPaneL(aResourceId, aMenuPane);

    			}

    	    }

	    }

	}

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

// ActivateL

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

//

EXPORT_C void CGlxMediaListCommandHandler::DoActivateL(TInt /*aViewId*/)

    {

    }

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

// Default implementation does nothing

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

//

EXPORT_C void CGlxMediaListCommandHandler::Deactivate()

    {

    // Do nothing

    }

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

// OfferKeyEventL

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

//

EXPORT_C TKeyResponse CGlxMediaListCommandHandler::OfferKeyEventL(

        const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

    {

    return EKeyWasNotConsumed;

    }

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

// PreDynInitMenuPaneL

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

//

EXPORT_C void CGlxMediaListCommandHandler::PreDynInitMenuPaneL( TInt /*aResourceId*/ )

    {

    // No implementation

    }

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

// CGlxMediaListCommandHandler::GetRequiredAttributesL

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

//

EXPORT_C void CGlxMediaListCommandHandler::GetRequiredAttributesL(

		                            RArray< TMPXAttribute >& aAttributes, 

            		                TBool aFilterUsingSelection, 

            		                TBool aFilterUsingCommandId,

                                    TInt aCommandId) const

    {

    if (!aFilterUsingCommandId || IsSupported(aCommandId))

    	{

    	GetRequiredAttributesL(aAttributes, aFilterUsingSelection);

    	}

    }

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

// Check if command is currently disabled

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

//	

EXPORT_C TBool CGlxMediaListCommandHandler::IsDisabledL(TInt aCommandId, 

        MGlxMediaList& aMediaList) const 

    {

    __ASSERT_DEBUG(IsSupported(aCommandId), Panic(EGlxPanicIllegalArgument));

    const TCommandInfo& info = CommandInfo(aCommandId);

    // Perform expensive checks only if necessary

    TBool isDisabled = IsDisabled(info);

    if (!isDisabled)

        {

        	/** 

            * The disabling check must be done so that we go through the selection 

            * and check each item separately against all filter rules.

            *

            * There can for example be a filter that does not allow system items, 

            * anim gifs or videos. Now if the selection contains 10 items and 3 of 

            * them are system items, 4 are anim gifs and 3 are videos we need to disable the 

            * command. If that selection contained 1 "normal" image we must enable

            * the command accordingly.

            */

	        // assume this item is not disabled

	        // Check through all selected items, if no selection then the focused item

            TGlxSelectionIterator iterator;

            iterator.SetToFirst( &aMediaList );

            // Loop until iterator does not give any more indexes 

            TInt index = KErrNotFound;

            while ( KErrNotFound != (index = iterator++ ) )

                {

                // get the media item

                const TGlxMedia& item = aMediaList.Item( index );

                // check category rule first

                TMPXGeneralCategory cat = item.Category();

                if( ( TCommandInfo::EIgnore != info.iCategoryRule )&&

                    ( cat != EMPXNoCategory ) )

                    {

                    // get category attribute

                    // did we want to deny all items of this type

                    if( TCommandInfo::EForbidAll == info.iCategoryRule )

                        {

                        // disable if the category was same

                        isDisabled = (info.iCategoryFilter == cat);

                        }

                    else

                        {

                        // assign the value

                        isDisabled = info.iCategoryFilter != cat;

                        // disable if the category was not same

                        if( isDisabled )

                            {

                            // we found first that is not same so end the loop

                            break;

                            }

                        }

                    }

                // Check system item if not yet disabled by previous rules

                TBool isSystemItem = EFalse;

                if( ( !isDisabled )&&( info.iDisallowSystemItems )&&

                    ( item.GetSystemItem(isSystemItem) ) )

                    {

                    // disable if this was system item

                    isDisabled = isSystemItem;

                    }

                // Check DRM if not yet disabled by previous rules

                if( (!isDisabled )&&( info.iDisallowDRM ) )

                    {

                    // disable if DRM protected

                    isDisabled = item.IsDrmProtected();

                    }

                // Check animated GIF if not yet disabled by previous rules

                TInt frameCount(0);

                if( ( !isDisabled )&&( info.iDisallowAnimatedGIFs )&&

                    ( item.GetFrameCount(frameCount) ) )

                    {

                    // disable if framecount is greater than one

                    isDisabled = ( 1 < frameCount );

                    }

                // Check minimum item count if not yet disabled by previous rules

                TInt count(0);

                if( ( !isDisabled )&&( info.iMinSlideshowPlayableContainedItemCount )&&

                    ( item.GetSlideshowPlayableContainedItemCount(count) ) )

                    {

                    // disable if less than required amount of items in container (ignore non-containers, i.e. -1)

                    if( count != -1 )

                        {

                        isDisabled = ( count < info.iMinSlideshowPlayableContainedItemCount );

                        }

                    }

                // when we find the first item for which the command is not disabled

                // we can end the loop unless the category rule states we need to check them all

                if( ( !isDisabled )&&( TCommandInfo::ERequireAll != info.iCategoryRule ) )

                    {

                    // this is the exit of the loop in case there is an item to enable for

                    break;

                    }

                }

            // Check deriving class if we are still not disabled

            if ( !isDisabled )

                {

                isDisabled = DoIsDisabled( aCommandId, aMediaList );

                }

            }

    return isDisabled;

    }

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

// MediaList

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

//	

EXPORT_C MGlxMediaList& CGlxMediaListCommandHandler::MediaList()

	{

	return iMediaListProvider->MediaList();

	}

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

// MediaList

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

//	

EXPORT_C const MGlxMediaList& CGlxMediaListCommandHandler::MediaList() const

	{

	return const_cast<CGlxMediaListCommandHandler*>(this)->MediaList();

	//return iMediaListProvider->MediaList();

	}

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

// Default implementation of elaborate filtering returns EFalse for "not disabled"

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

//

EXPORT_C TBool CGlxMediaListCommandHandler::DoIsDisabled(TInt /*aCommandId*/, 

        MGlxMediaList& /*aList*/) const

    {

    return EFalse;

    }

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

// Return selection length. Length is zero if static item is focused

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

//

EXPORT_C TInt CGlxMediaListCommandHandler::SelectionLength() const

    {

    const MGlxMediaList& ml = MediaList();

    TInt selectionLength = ml.SelectionCount();

    // If there is no selection, treat the focused item as selected, unless

    // it is a static item

    if ( 0 == selectionLength )

        {

        if (ml.Count() > 0) 

            {

            // see if item is a static item

            // get focussed item

            const TGlxMedia&  item = ml.Item(ml.FocusIndex());

            if(!item.IsStatic())

                {

                // not static item - set selection length to 1

                selectionLength = 1;

                }

            }

        }

    return selectionLength;

    }

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

// Add the command to command array

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

//	

EXPORT_C void CGlxMediaListCommandHandler::AddCommandL(

        const CGlxMediaListCommandHandler::TCommandInfo& aCommand)

	{

	// Make sure command not already added

	__ASSERT_DEBUG(!IsSupported(aCommand.iCommandId), Panic(EGlxPanicAlreadyAdded));

	// This function is rarely called, so copying the object should be ok

	iCommandInfoArray.AppendL(aCommand);

	}

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

// Return index of command info by command id

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

//	

EXPORT_C TInt CGlxMediaListCommandHandler::CommandInfoIndex(TInt aCommandId) const

	{

	// Find the index of the command

	TInt index = KErrNotFound;

    TInt count = iCommandInfoArray.Count();

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

        {

        if (iCommandInfoArray[i].iCommandId == aCommandId)

            {

            index = i;

            break;

            }

        }

    return index;

	}

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

// DoDynInitMenuPaneL

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

//	

EXPORT_C void CGlxMediaListCommandHandler::DoDynInitMenuPaneL(TInt /*aResourceId*/, CEikMenuPane* /*aMenuPane*/)

    {

    // No implementation by default

    }

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

// Return command info by id

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

//	 

EXPORT_C CGlxMediaListCommandHandler::TCommandInfo& 

        CGlxMediaListCommandHandler::CommandInfo(TInt aCommandId)  

    {

    // Assuming the deriving class knows the command ids it supports

    __ASSERT_DEBUG(IsSupported(aCommandId), Panic(EGlxPanicIllegalArgument));

    return iCommandInfoArray[CommandInfoIndex(aCommandId)];

    }

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

// Return command info by id

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

//	 

const CGlxMediaListCommandHandler::TCommandInfo& 

        CGlxMediaListCommandHandler::CommandInfo(TInt aCommandId) const

    {

    // Assuming the deriving class knows the command ids it supports

    __ASSERT_DEBUG(IsSupported(aCommandId), Panic(EGlxPanicIllegalArgument));

    return iCommandInfoArray[CommandInfoIndex(aCommandId)];

    }

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

// return ETrue if command is handled by this command handler

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

//	

EXPORT_C TBool CGlxMediaListCommandHandler::IsSupported(TInt aCommandId) const

    {

    return CommandInfoIndex(aCommandId) != KErrNotFound;

    }

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

// BypassFiltersForExecute

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

//	

EXPORT_C TBool CGlxMediaListCommandHandler::BypassFiltersForExecute() const

    {

    // Return false by default: should only return true in special circumstances

    return EFalse;

    }

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

// CGlxMediaListCommandHandler::DoGetRequiredAttributesL

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

//	

EXPORT_C void CGlxMediaListCommandHandler::

        DoGetRequiredAttributesL( RArray<TMPXAttribute>& /*aAttributes*/, TBool /*aFilterUsingSelection*/) const

    {

    // No implementation required

    }