photosgallery/viewframework/commandhandlers/commoncommandhandlers/src/glxcommandhandlersortorder.cpp
/*
* 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: SortOrder command handler
*
*/
#include "glxcommandhandlersortorder.h"
#include <data_caging_path_literals.hrh>
#include <glxcommandhandlers.hrh>
#include <glxpanic.h>
#include <glxtracer.h>
#include <glxlog.h>
#include <centralrepository.h> // For CRepository
#include <mglxmedialist.h> // For MGlxMediaList
#include <glxsettingsmodel.h> // For cenrep setting
// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerSortOrder* CGlxCommandHandlerSortOrder::NewL(
MGlxMediaListProvider* aMediaListProvider,
const TUint32 aCRKey)
{
CGlxCommandHandlerSortOrder* self = new ( ELeave )
CGlxCommandHandlerSortOrder(aMediaListProvider, aCRKey);
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CGlxCommandHandlerSortOrder::CGlxCommandHandlerSortOrder(
MGlxMediaListProvider* aMediaListProvider,
const TUint32 aCRKey)
: CGlxMediaListCommandHandler(aMediaListProvider), iKey(aCRKey)
{
// Do nothing
}
// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CGlxCommandHandlerSortOrder::ConstructL()
{
TRACER("CGlxCommandHandlerSortOrder::ConstructL");
// Add supported commands
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::ConstructL::Add alphabetical sort order command handler");
TCommandInfo info( EGlxCmdSortByAlphabetical );
info.iMinSelectionLength = 1;
info.iMaxSelectionLength = KMaxTInt;
AddCommandL(info);
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::ConstructL::Add frequency sort order command handler");
TCommandInfo info2( EGlxCmdSortByCount );
info2.iMinSelectionLength = 1;
info2.iMaxSelectionLength = KMaxTInt;
AddCommandL(info2);
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CGlxCommandHandlerSortOrder::~CGlxCommandHandlerSortOrder()
{
// Do nothing
}
// -----------------------------------------------------------------------------
// DoExecute - the relevant action for the command id
// -----------------------------------------------------------------------------
//
TBool CGlxCommandHandlerSortOrder::DoExecuteL(TInt aCommandId,
MGlxMediaList& aList)
{
TRACER("CGlxCommandHandlerSortOrder::DoExecuteL");
__ASSERT_DEBUG( NULL != &aList, Panic(EGlxPanicIllegalArgument) );
GLX_LOG_INFO1("CGlxCommandHandlerSortOrder::DoExecuteL::Command Id (%d)",aCommandId);
TGlxFilterSortOrder newSortOrder = EGlxFilterSortOrderNotUsed;
TGlxFilterSortDirection newSortDirection = EGlxFilterSortDirectionNotUsed;
TBool handledCommand = EFalse;
switch (aCommandId)
{
case EGlxCmdSortByAlphabetical:
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoExecuteL::Sort Alphabetically");
newSortOrder = EGlxFilterSortOrderAlphabetical;
newSortDirection = EGlxFilterSortDirectionAscending;
handledCommand = ETrue;
break;
}
case EGlxCmdSortByCount:
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoExecuteL::Sort by count");
newSortOrder = EGlxFilterSortOrderItemCount;
newSortDirection = EGlxFilterSortDirectionDescending;
handledCommand = ETrue;
break;
}
default:
{
break;
}
}
// Check if the existing and the new sort order are different, the change the filter in MediaList
if( newSortOrder != EGlxFilterSortOrderNotUsed )
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoExecuteL::Create a new sort order");
TGlxFilterProperties filterProperties;
filterProperties.iSortOrder = newSortOrder;
filterProperties.iSortDirection = newSortDirection;
CMPXFilter* newFilter = TGlxFilterFactory::CreateCombinedFilterL(filterProperties,
aList.Filter());
CleanupStack::PushL(newFilter);
aList.SetFilterL(newFilter);
// Update central repository with new sort order
CGlxSettingsModel::SetValueL(iKey,newSortOrder);
CleanupStack::PopAndDestroy(newFilter);
}
return handledCommand;
}
// -----------------------------------------------------------------------------
// DoIsDisabled
// -----------------------------------------------------------------------------
//
TBool CGlxCommandHandlerSortOrder::DoIsDisabled(TInt aCommandId,
MGlxMediaList& aList) const
{
TRACER("CGlxCommandHandlerSortOrder::DoIsDisabled");
__ASSERT_DEBUG( NULL != &aList, Panic(EGlxPanicIllegalArgument) );
// Get the existing filter & try to find out what is the current sort order
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoIsDisabled::Get the existing filter");
TGlxFilterSortOrder currentSortOrder = CurrentSortOrder(aList);
GLX_LOG_INFO1("CGlxCommandHandlerSortOrder::DoIsDisabled::Command Id (%d)",aCommandId);
TBool disabled = EFalse;
TInt count(aList.Count());
switch( aCommandId)
{
case EGlxCmdSortByAlphabetical:
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoIsDisabled::Sort Alphabetically");
// If the filter is already Alphabetical sort then hide the menu
if( count )
{
disabled = ( currentSortOrder == EGlxFilterSortOrderAlphabetical);
}
else
{
disabled = ETrue; // Menu options should appear only if the list count is non-zero
}
break;
}
case EGlxCmdSortByCount:
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoIsDisabled::Sort by count");
// If the filter is already Frequency sort then hide the menu
if( count )
{
disabled = ( currentSortOrder == EGlxFilterSortOrderItemCount);
}
else
{
disabled = ETrue; // Menu options should appear only if the list count is non-zero
}
break;
}
default:
{
break;
}
}
return disabled;
}
// -----------------------------------------------------------------------------
// GetSortOrder
// -----------------------------------------------------------------------------
//
TGlxFilterSortOrder CGlxCommandHandlerSortOrder::CurrentSortOrder(MGlxMediaList& aList) const
{
TRACER("CGlxCommandHandlerSortOrder::CurrentSortOrder");
__ASSERT_DEBUG( NULL != &aList, Panic(EGlxPanicIllegalArgument) );
TGlxFilterSortOrder currentSortOrder = EGlxFilterSortOrderNotUsed;
CMPXFilter* filter = aList.Filter();
if ( filter )
{
GLX_LOG_INFO("CGlxCommandHandlerSortOrder::DoIsDisabled::Find the existing sort order");
currentSortOrder = filter->ValueTObjectL<TGlxFilterSortOrder>(KGlxFilterGeneralSortType);
}
return currentSortOrder;
}
//End of file