/*
* Copyright (c) 2010 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:  Utility class to hold a single item for Adaptive Grid.
*               Used to provide quickly to client applications (Phonebook)
*               The Adaptive Grid for the full list of contacts, which is
*               the one that is displayed when the Find Box is empty.
*/


// INCLUDE FILES
#include "CPcsDebug.h"
#include "CPcsAdaptiveGridItem.h"
#include "CPcsAdaptiveGrid.h"



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

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::NewL
// Two Phase Construction
// ----------------------------------------------------------------------------
CPcsAdaptiveGrid* CPcsAdaptiveGrid::NewL( )
{
    return new ( ELeave ) CPcsAdaptiveGrid();
} 

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::CPcsAdaptiveGrid
// Constructor
// ----------------------------------------------------------------------------
CPcsAdaptiveGrid::CPcsAdaptiveGrid( )
{
    iAdaptiveGrid.ResetAndDestroy();
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::~CPcsAdaptiveGrid
// Destructor
// ----------------------------------------------------------------------------
CPcsAdaptiveGrid::~CPcsAdaptiveGrid( )
{
    iAdaptiveGrid.ResetAndDestroy();
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::Count
// 
// ----------------------------------------------------------------------------
TInt CPcsAdaptiveGrid::Count( )
{
    return iAdaptiveGrid.Count();
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::GetAdaptiveGridItemIndex
// 
// ----------------------------------------------------------------------------
TInt CPcsAdaptiveGrid::GetAdaptiveGridItemIndex( const TChar& aChar )
{
    TChar aUpperChar = User::UpperCase( aChar );

    TInt retValue = KErrNotFound;

    // The Grid items are sorted alphabetically, anyway the number of items in the
    // array is small so we do linear search
    for ( TInt i=0; i < iAdaptiveGrid.Count(); i++ )
        {
        if ( iAdaptiveGrid[i]->Character( ) == aUpperChar )
            {
            retValue = i;
            break;
            }
        }

    return retValue;
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::GetAdaptiveGridItemPtr
// 
// ----------------------------------------------------------------------------
CPcsAdaptiveGridItem* CPcsAdaptiveGrid::GetAdaptiveGridItemPtr( const TChar& aChar )
{
    CPcsAdaptiveGridItem* retValue = NULL;

    TInt gridItemIndex = GetAdaptiveGridItemIndex( aChar );
    
    if ( gridItemIndex != KErrNotFound )
        {
        retValue = iAdaptiveGrid[gridItemIndex];
        }

    return retValue;
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::IncrementRefCounter
// 
// ----------------------------------------------------------------------------
void CPcsAdaptiveGrid::IncrementRefCounterL( const TChar& aChar, const TUint aSelector )
{
    CPcsAdaptiveGridItem* gridItem = GetAdaptiveGridItemPtr( aChar );
    
    if ( gridItem == NULL )
        {
        TLinearOrder<CPcsAdaptiveGridItem> rule( CPcsAdaptiveGridItem::CompareByCharacter );

        CPcsAdaptiveGridItem* newGridItem = CPcsAdaptiveGridItem::NewL( aChar );
        newGridItem->IncrementRefCounter( aSelector );
        iAdaptiveGrid.InsertInOrder(newGridItem, rule);
        }
    else
        {
        gridItem->IncrementRefCounter( aSelector );
        }

    PRINT2 ( _L("CPcsAdaptiveGrid::IncrementRefCounterL: Char='%c', Selector=%d"),
             (TUint) aChar, aSelector );
    // PrintAdatptiveGrid( );
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::DecrementRefCounter
// 
// ----------------------------------------------------------------------------
void CPcsAdaptiveGrid::DecrementRefCounter( const TChar& aChar, const TUint aSelector )
{
    TInt gridItemIndex = GetAdaptiveGridItemIndex( aChar );

    if ( gridItemIndex != KErrNotFound )
        {
        CPcsAdaptiveGridItem* gridItem = iAdaptiveGrid[gridItemIndex];
 
        gridItem->DecrementRefCounter( aSelector );
        
        // Remove the Grid item, if there is no reference to it anymore
        if ( gridItem->AreRefCountersZero( ) )
            {
            iAdaptiveGrid.Remove( gridItemIndex );
            delete gridItem;
            }
        }   

    PRINT2 ( _L("CPcsAdaptiveGrid::DecrementRefCounter: Char='%c', Selector=%d"),
             (TUint) aChar, aSelector );
    // PrintAdatptiveGrid( );
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::GetAdaptiveGrid
// 
// ----------------------------------------------------------------------------
void CPcsAdaptiveGrid::GetAdaptiveGrid( const TBool aCompanyName, TDes& aGrid )
{
    aGrid.Zero();
    TInt gridCharCount = 0;
    for ( TInt i=0; i < iAdaptiveGrid.Count(); i++ )
        {
        if ( iAdaptiveGrid[i]->IsRefCounterNonZero( aCompanyName ) )
            {
            aGrid.Append( iAdaptiveGrid[i]->Character() );
            gridCharCount++;
            if ( gridCharCount == KPsAdaptiveGridStringMaxLen )
                {
                break;
                }
            }
        }
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::PrintAdatptiveGrid
// 
// ----------------------------------------------------------------------------
void CPcsAdaptiveGrid::PrintAdatptiveGrid( )
{
    PRINT ( _L("CPcsAdaptiveGrid::PrintAdatptiveGrid: ----------------------------------------") );
    PRINT1 ( _L("CPcsAdaptiveGrid::PrintAdatptiveGrid: Adaptive Grid (%d items)"), iAdaptiveGrid.Count() );
    PRINT ( _L("CPcsAdaptiveGrid::PrintAdatptiveGrid: ----------------------------------------") );

    for ( TInt i=0; i < iAdaptiveGrid.Count(); i++ )
        {
        CPcsAdaptiveGridItem* gridItem = iAdaptiveGrid[i];

        PRINT5 ( _L("CPcsAdaptiveGrid::PrintAdatptiveGrid: Grid[%d].Character=%c, RefCounters[%d,%d,%d]"),
                 i, (TUint) iAdaptiveGrid[i]->Character(),
                 iAdaptiveGrid[i]->GetRefCounter(CPcsAdaptiveGridItem::EFirstNameLastName),
                 iAdaptiveGrid[i]->GetRefCounter(CPcsAdaptiveGridItem::EUnnamedCompanyName),
                 iAdaptiveGrid[i]->GetRefCounter(CPcsAdaptiveGridItem::ECompanyName) );
        }

    PRINT ( _L("CPcsAdaptiveGrid::PrintAdatptiveGrid: ----------------------------------------") );
}

// ----------------------------------------------------------------------------
// CPcsAdaptiveGrid::Reset
// 
// ----------------------------------------------------------------------------
void CPcsAdaptiveGrid::Reset()
    {
    iAdaptiveGrid.ResetAndDestroy();
    }

// End of file