/*
* 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:    Add to container command handler
*
*/




/**
 * @internal reviewed 05/06/2007 by Dave Schofield
 */

#include "glxcommandhandleraddtocontainer.h"

#include <AknUtils.h>
#include <bautils.h>
#include <data_caging_path_literals.hrh>
#include <eikmenup.h> 
#include <glxcollectionpluginalbums.hrh>
#include <glxcollectionplugintags.hrh>
#include <glxcommandfactory.h>
#include <glxcommandhandlers.hrh>
#include <glxfilterfactory.h>
#include <glxuiutility.h>
#include <glxuistd.h>
#include <glxresourceutilities.h>                // for CGlxResourceUtilities
#include <glxuiutilities.rsg>
#include <mglxmedialist.h>

#include <mpxcollectioncommanddefs.h>
#include <mpxcollectionpath.h>
#include <mpxcommandgeneraldefs.h>
#include <mpxmediaarray.h>
#include <mpxmediacontainerdefs.h>
#include <StringLoader.h>

#include "glxmediaselectionpopup.h"
#include <glxicons.mbg>
#include <glxtracer.h>

TInt CGlxCommandHandlerAddToContainer::iSelectionCount = 0;

// ---------------------------------------------------------------------------
// Return add to album command handler
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* 
    CGlxCommandHandlerAddToContainer::NewAddToAlbumCommandHandlerL(
        MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem) 
    {
    TRACER("CGlxCommandHandlerAddToContainer::NewAddToAlbumCommandHandlerL");
    return CGlxCommandHandlerAddToContainer::NewL (aMediaListProvider, 
                                                EGlxCmdAddToAlbum, aHasToolbarItem);
    }

// ---------------------------------------------------------------------------
// Return add to album command handler for singleclick options menu
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* 
    CGlxCommandHandlerAddToContainer::NewAddToAlbumSingleClickCommandHandlerL(
        MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem) 
    {
    return CGlxCommandHandlerAddToContainer::NewL (aMediaListProvider, 
                              EGlxCmdSingleClickAddToAlbum, aHasToolbarItem);
    }


// ---------------------------------------------------------------------------
// Return add (to) tags command handler
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* 
    CGlxCommandHandlerAddToContainer::NewAddToTagCommandHandlerL(
        MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem) 
    {
    TRACER("CGlxCommandHandlerAddToContainer::NewAddToTagCommandHandlerL");
    return CGlxCommandHandlerAddToContainer::NewL(aMediaListProvider, 
                                                EGlxCmdAddTag, aHasToolbarItem);
    }

// ---------------------------------------------------------------------------
// Return add (to) tags command handler for singleclick option menu
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* 
    CGlxCommandHandlerAddToContainer::NewAddToTagSingleClickCommandHandlerL(
        MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem) 
    {
    return CGlxCommandHandlerAddToContainer::NewL(aMediaListProvider, 
                                EGlxCmdSingleClickAddTag, aHasToolbarItem);
    }


// ---------------------------------------------------------------------------
// Return add (to) Favourites command handler
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* 
    CGlxCommandHandlerAddToContainer::NewAddToFavCommandHandlerL(
        MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem) 
    {
    TRACER("CGlxCommandHandlerAddToContainer::NewAddToFavCommandHandlerL");
    return CGlxCommandHandlerAddToContainer::NewL(aMediaListProvider, 
                                    EGlxCmdAddToFavourites, aHasToolbarItem);
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer* CGlxCommandHandlerAddToContainer::NewL(
        MGlxMediaListProvider* aMediaListProvider, TInt aCommandId, TBool aHasToolbarItem)
    {
    TRACER("CGlxCommandHandlerAddToContainer::NewL");
    CGlxCommandHandlerAddToContainer* self = 
        new ( ELeave ) CGlxCommandHandlerAddToContainer( aMediaListProvider, aHasToolbarItem );
    CleanupStack::PushL( self );
    self->ConstructL( aCommandId );
    CleanupStack::Pop( self );
    return self;
    }
    
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CGlxCommandHandlerAddToContainer::CGlxCommandHandlerAddToContainer(
    MGlxMediaListProvider* aMediaListProvider, TBool aHasToolbarItem)
        : CGlxMpxCommandCommandHandler( aMediaListProvider, aHasToolbarItem )
    {
    // Do nothing
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CGlxCommandHandlerAddToContainer::ConstructL(TInt aCommandId)
    {
    TRACER("CGlxCommandHandlerAddToContainer::ConstructL");
    // Load resource
	TParse parse;
    parse.Set(KGlxUiUtilitiesResource, &KDC_APP_RESOURCE_DIR, NULL);
    TFileName resourceFile;
    resourceFile.Append(parse.FullName());
    CGlxResourceUtilities::GetResourceFilenameL(resourceFile);  
   	iResourceOffset = CCoeEnv::Static()->AddResourceFileL(resourceFile);
	// Reset the Flag inorder to allow for a new selection pop-up to be created.
   	iIsProcessOngoing = EFalse;
   	// Add supported command
   	TCommandInfo info(aCommandId);
   	
    // Filter out static items - user must have selected at least one item to
    // enable the command handler    
    const TInt KGlxCommandHandlerMinSelectionAllowSingle = 1;
    info.iMinSelectionLength = KGlxCommandHandlerMinSelectionAllowSingle;
    
   	AddCommandL(info);
   	iCommandId = aCommandId;
	}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerAddToContainer::~CGlxCommandHandlerAddToContainer()
    {
    TRACER("CGlxCommandHandlerAddToContainer::~CGlxCommandHandlerAddToContainer");
    if ( iResourceOffset )
        {
        CCoeEnv::Static()->DeleteResourceFile(iResourceOffset);
        }
	// Reset the Flag inorder to allow for a new selection pop-up to be created.
    iIsProcessOngoing = EFalse;
    }

// ---------------------------------------------------------------------------
// Create an add to container command
// ---------------------------------------------------------------------------
//
CMPXCommand* CGlxCommandHandlerAddToContainer::CreateCommandL(TInt aCommandId, 
        MGlxMediaList& aMediaList, TBool& /*aConsume*/) const
    {
    TRACER("CGlxCommandHandlerAddToContainer::CreateCommandL");
	// Ignore the current command in case the previous command has still not been completed
	if(iIsProcessOngoing)
	    {
	    return NULL;
	    }
    iSelectionCount = 0;
	// Set the Flag inorder to block any new subsequent selection pop-ups from getting created.
	iIsProcessOngoing = ETrue;
    CMPXCollectionPath* targetCollection = CMPXCollectionPath::NewL();
    CleanupStack::PushL(targetCollection);
    TBool enableMultipleSelection = EFalse;
    TBool enablePopup = EFalse;
    CMPXFilter* filter = NULL;
    switch(aCommandId)
        {
        case EGlxCmdAddToFavourites:
            {
            targetCollection->AppendL(KGlxCollectionPluginAlbumsImplementationUid);
            // The target collection has also to be appeneded with the the relation id.
            // appending another level into the albums to get favourites and 1 is the relation id of albums
            targetCollection->AppendL( TMPXItemId(1) );
            targetCollection->Set( 0 );
            break;
            }
        case EGlxCmdAddToAlbum:
        case EGlxCmdSingleClickAddToAlbum:
            {
            enablePopup = ETrue;
            targetCollection->AppendL(KGlxCollectionPluginAlbumsImplementationUid);
	        filter = TGlxFilterFactory::CreateCameraAlbumExclusionFilterL();
	        CleanupStack::PushL(filter);
            break;
            }
        case EGlxCmdAddTag:
        case EGlxCmdSingleClickAddTag:
            {
            enableMultipleSelection = ETrue;
            enablePopup = ETrue;
            targetCollection->AppendL(KGlxTagCollectionPluginImplementationUid);
            filter = TGlxFilterFactory::CreateIncludeEmptyContainersFilterL();
            CleanupStack::PushL(filter);
            break;
            }
        }
               
    CMPXCollectionPath* sourceItems = aMediaList.PathLC( NGlxListDefs::EPathFocusOrSelection );
    CMPXCommand* command = NULL;
    if (enablePopup )
        {
        CGlxMediaSelectionPopup* popup = new (ELeave) CGlxMediaSelectionPopup;
        
        TBool accepted = EFalse;
        CMPXCollectionPath* targetContainers = 
            popup->ExecuteLD(*targetCollection, accepted, enableMultipleSelection, ETrue, filter);

        if (accepted)
            {        
            // Set the container selection count to give correct completion text
            TArray<TInt> selection = targetContainers->Selection();
            iSelectionCount = selection.Count();
            
            CleanupStack::PushL(targetContainers);
            command = TGlxCommandFactory::AddToContainerCommandLC(
                *sourceItems, *targetContainers);
            CleanupStack::Pop(command); 
            CleanupStack::PopAndDestroy(targetContainers);
            }
        else
	    	{
    		// Reset the Flag inorder to allow any new selection pop-up to be created.
	    	iIsProcessOngoing = EFalse;
	    	}
        }
    else
        {
        command = TGlxCommandFactory::AddToContainerCommandLC(
            *sourceItems, *targetCollection);
        CleanupStack::Pop(command); 
        }
    CleanupStack::PopAndDestroy(sourceItems);
    if (filter)
        {
        CleanupStack::PopAndDestroy(filter);
        }
    CleanupStack::PopAndDestroy(targetCollection);
	return command;
    } 

// -----------------------------------------------------------------------------
// CGlxCommandHandlerAddToContainer::CompletionTextL
// -----------------------------------------------------------------------------
//	
HBufC* CGlxCommandHandlerAddToContainer::CompletionTextL() const
    {
    TRACER("CGlxCommandHandlerAddToContainer::CompletionTextL()");
    if (iCommandId == EGlxCmdAddToAlbum || 
        iCommandId == EGlxCmdSingleClickAddToAlbum )
    	{
   		if (iSelectionCount > 1)
   			{
	   		return StringLoader::LoadL(R_GLX_COMPLETION_ADD_TO_CONTAINER_MULTI_ITEM_ALBUM);
   			}
   		return StringLoader::LoadL(R_GLX_COMPLETION_ADD_TO_CONTAINER_ONE_ITEM_ALBUM);
    	}
   	else if (iCommandId == EGlxCmdAddTag || 
             iCommandId == EGlxCmdSingleClickAddTag)
   		{
   		if (iSelectionCount > 1)
   			{
	   		return StringLoader::LoadL(R_GLX_COMPLETION_ADD_TO_CONTAINER_MULTI_ITEM_TAG);
   			}
		return StringLoader::LoadL(R_GLX_COMPLETION_ADD_TO_CONTAINER_ONE_ITEM_TAG);	
   		}
    else // considered as favourites 
        {
        return StringLoader::LoadL(R_GLX_COMPLETION_ADD_TO_FAVOURITES);
        }
    }

// -----------------------------------------------------------------------------
// CGlxCommandHandlerAddToContainer::DoHandleCommandCompleteL
// -----------------------------------------------------------------------------
//
void CGlxCommandHandlerAddToContainer::DoHandleCommandCompleteL(TAny* /*aSessionId*/,
        CMPXCommand* /*aCommandResult*/, TInt /*aError*/, MGlxMediaList* /*aList*/)
      {
      TRACER("CGlxCommandHandlerAddToContainer::DoHandleCommandCompleteL()");
	  // Reset the Flag inorder to allow any new selection pop-up to be created.
      iIsProcessOngoing = EFalse;
      }



// -----------------------------------------------------------------------------
// DialogDismissedL
// -----------------------------------------------------------------------------
//  
void CGlxCommandHandlerAddToContainer::DialogDismissedL(TInt aButtonId)
    {
    TRACER("CGlxCommandHandlerAddToContainer::DialogDismissedL");
    iIsProcessOngoing = EFalse;
    CGlxMpxCommandCommandHandler::DialogDismissedL(aButtonId);
    }



// ---------------------------------------------------------------------------
// CGlxCommandHandlerAddToContainer::DoActivateL
// ---------------------------------------------------------------------------
//
void CGlxCommandHandlerAddToContainer::DoActivateL(TInt /*aViewId*/)
	{

 	}

void CGlxCommandHandlerAddToContainer::PopulateToolbarL()
	{

	}

// ---------------------------------------------------------------------------
// CGlxCommandHandlerAddToContainer::DoIsDisabled
// ---------------------------------------------------------------------------
//
TBool CGlxCommandHandlerAddToContainer::DoIsDisabled(TInt aCommandId, 
                                                 MGlxMediaList& aList) const
    {
	TRACER("CGlxCommandHandlerAddToContainer::DoIsDisabled");
    if ( (EGlxCmdSingleClickAddToAlbum==aCommandId || 
          EGlxCmdSingleClickAddTag == aCommandId) && 
          aList.SelectionCount() > 0 )
        {   
        return EFalse;
        }
    else if (EGlxCmdAddToAlbum==aCommandId || EGlxCmdAddTag == aCommandId)
        {
        return EFalse;
        }

    return ETrue;
    }