/*
* Copyright (c) 2002-2007 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:  Group item definitions
*
*/



// INCLUDE FILES
#include "CGflmGroupItem.h"
#include "MGflmItemGroup.h"
#include <e32std.h>


// CONSTANTS
const TInt KIconIdUndefined = -1;
const TInt KSortCollationLevel = 3;


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CGflmGroupItem::CGflmGroupItem
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CGflmGroupItem::CGflmGroupItem()
    : iIconId( KIconIdUndefined )
    {
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::~CGflmGroupItem()
// -----------------------------------------------------------------------------
//
CGflmGroupItem::~CGflmGroupItem()
    {
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::GetIconId()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CGflmGroupItem::GetIconId( TInt& aIconId )
    {
    if ( iIconId == KIconIdUndefined )
        {
        aIconId = 0;
        return KErrNotFound;
        }
    aIconId = iIconId;
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::SetIconId()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CGflmGroupItem::SetIconId( const TInt aIconId )
    {
    iIconId = aIconId;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CanUseCompareF()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CGflmGroupItem::CanUseCompareF() const    
    {
    if ( iStatus & ECanUseCompareF )
        {
        return ETrue;
        }
    if ( iStatus & ECannotUseCompareF )
        {
        return EFalse;
        }

    TPtrC name( Name() );
    TInt len( name.Length() );
    const TText* ptr = name.Ptr();
    while ( len-- > 0 )
        {
        TText ch = *ptr++;
        // Do not allow CompareF for non Ascii or special chars
        if ( !( ( ch >= 0x000A && ch <= 0x0039 ) ||  // Ascii basic symbols
                ( ch >= 0x0041 && ch <= 0x005A ) ||  // Ascii capital alpha
                ( ch >= 0x0061 && ch <= 0x007A ) ) ) // Ascii small alpha
            {
            iStatus |= ECannotUseCompareF;
            return EFalse;
            }
        }
    iStatus |= ECanUseCompareF;
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::SetGroup()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CGflmGroupItem::SetGroup( MGflmItemGroup* aGroup )
    {
    iGroup = aGroup;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::GetSortL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//

TLinearOrder< CGflmGroupItem > CGflmGroupItem::GetSortL(
        TGflmSortMethod aSortMethod )
    {
    switch( aSortMethod )
        {
        case EByName:
            {
            return CompareByName;
            }
        case EByType:
            {
            return CompareByType;
            }
        case EMostRecentFirst:
            {
            return CompareMostRecentFirst;
            }
        case ELargestFirst:
            {
            return CompareLargestFirst;
            }
        default:
            {
            User::Leave( KErrNotSupported );
            }
        }
    return CompareByName;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareByItemType
// Compares two CGflmGroupItem objects by name (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareByItemType(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    TGflmItemType first( aFirst.Type() );
    TGflmItemType second( aSecond.Type() );
    if ( first < second )
        {
        return -1;
        }
    else if ( first > second )
        {
        return 1;
        }
    return 0;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareByNameWithoutItemType
// Compares two CGflmGroupItem objects by name (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareByNameWithoutItemType(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    // Do not use CompareC by default with collation
    // because it is very bad for performance when sorting
    // large folders i.e. several 1000s of files with long item names
    // e.g. names containing over 40 chars

    // However, some languages are not sorted correctly with CompareF,
    // so do cached name check to decide what comparison to use.

    if ( !aFirst.CanUseCompareF() || !aSecond.CanUseCompareF() )
        {
        if ( aFirst.iGroup )
            {
            const TCollationMethod* collate =
                aFirst.iGroup->CollationMethod();
            if ( collate )
                {
                return aFirst.Name().CompareC(
                    aSecond.Name(),
                    KSortCollationLevel,
                    collate );
                }
            }
        }

    return aFirst.Name().CompareF( aSecond.Name() );
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareByName
// Compares two CGflmGroupItem objects by name (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareByName(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    TInt ret( CompareByItemType( aFirst, aSecond ) );
    if ( !ret )
        {
        return CompareByNameWithoutItemType( aFirst, aSecond );
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareByType
// Compares two CGflmGroupItem objects by file extension (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareByType(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    TInt ret( CompareByItemType( aFirst, aSecond ) );
    if ( ret )
        {
        return ret;
        }

    // Do not use CompareC by default with collation
    // because it is very bad for performance when sorting
    // large folders i.e. several 1000s of files with long item names
    // e.g. names containing over 40 chars

    // However, some languages are not sorted correctly with CompareF,
    // so do cached name check to decide what comparison to use.

    if ( !aFirst.CanUseCompareF() || !aSecond.CanUseCompareF() )
        {
        if ( aFirst.iGroup )
            {
            const TCollationMethod* collate =
                aFirst.iGroup->CollationMethod();
            if ( collate )
                {
                ret = aFirst.Ext().CompareC(
                    aSecond.Ext(),
                    KSortCollationLevel,
                    collate );
                if  ( !ret )
                    {
                    ret = CompareByName( aFirst, aSecond );
                    }
                return ret;
                }
            }
        }

    ret = aFirst.Ext().CompareF( aSecond.Ext() );
    if  ( !ret )
        {
        ret = CompareByNameWithoutItemType( aFirst, aSecond );
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareMostRecentFirst
// Compares two CGflmGroupItem objects by date (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareMostRecentFirst(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    TInt ret( -CompareByItemType( aFirst, aSecond ) );
    if ( ret )
        {
        return ret;
        }

    TTime first( aFirst.Date() );
    TTime second( aSecond.Date() );

    if ( first > second )
        {
        return -1;
        }
    else if ( first < second )
        {
        return 1;
        }
    return CompareByNameWithoutItemType( aFirst, aSecond );
    }

// -----------------------------------------------------------------------------
// CGflmGroupItem::CompareLargestFirst
// Compares two CGflmGroupItem objects by size (ascending)
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CGflmGroupItem::CompareLargestFirst(
        const CGflmGroupItem& aFirst, const CGflmGroupItem& aSecond )
    {
    TInt ret( -CompareByItemType( aFirst, aSecond ) );
    if ( ret )
        {
        return ret;
        }

    TInt64 first( aFirst.Size() );
    TInt64 second( aSecond.Size() );

    if ( first > second )
        {
        return -1;
        }
    else if ( first < second )
        {
        return 1;
        }
    return CompareByNameWithoutItemType( aFirst, aSecond );
    }

//  End of File