/*

* Copyright (c) 2003-2005 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:  Class declaration for CGSListboxEntry & CGSItemTextArray.

*

*/

// INCLUDES

#include "gslistbox.h"

#include "gscommon.hrh"

#include <eiklbx.h>

#include <aknradiobuttonsettingpage.h>

// CONSTANTS

const TInt KGSListboxModelGranularity = 5;

_LIT(KGSEngineItemArrayPanic, "GSEngItemArray");

// Panic enum

enum TGSEngineItemArrayPanic

    {

    EGSEngineItemArrayPanicNoRadioSettingsPage = 0,

    };

/*================================================

*

*   class declaration for CGSListboxEntry

*

*================================================*/

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

// CGSListboxEntry::NewLC()

// Symbian OS two-phased constructor

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

EXPORT_C CGSListboxEntry* CGSListboxEntry::NewLC( TResourceReader& aReader )

    {

    CGSListboxEntry* self = new (ELeave) CGSListboxEntry;

    CleanupStack::PushL( self );

    self->ConstructL( aReader );

    return self;

    }

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

// CGSListboxEntry::NewLC()

// Symbian OS two-phased constructor

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

EXPORT_C CGSListboxEntry* CGSListboxEntry::NewLC( TInt aFeatureId )

    {

    CGSListboxEntry* self = new (ELeave) CGSListboxEntry;

    CleanupStack::PushL( self );

    self->iFeatureId = aFeatureId;

    return self;

    }

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

// CGSListboxEntry::NewLC()

// Symbian OS two-phased constructor

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

EXPORT_C CGSListboxEntry* CGSListboxEntry::NewLC(

    TUint32 aResId, CCoeEnv& aEnv, TInt aFeatureId )

    {

    CGSListboxEntry* self = new (ELeave) CGSListboxEntry;

    CleanupStack::PushL( self );

    self->ConstructL( aResId, aEnv, aFeatureId );

    return self;

    }

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

// CGSListboxEntry::ConstructL()

// Symbian OS 2nd phase constructor

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

void CGSListboxEntry::ConstructL(

    TUint32 aResId, CCoeEnv& aEnv, TInt aFeatureId )

    {

    // Create resource reader

    TResourceReader reader;

    aEnv.CreateResourceReaderLC( reader, aResId );

    // Just read, not actually needed anywhere

    reader.ReadInt16();

    // Take base settings from resources

    iCaption = reader.ReadHBufCL();

    iStaticTextLength = iCaption->Length();

    iFeatureId = aFeatureId + reader.ReadInt16();

    iType = reader.ReadInt8();

    CleanupStack::PopAndDestroy(); //reader

    }

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

// CGSListboxEntry::ConstructL()

// Symbian OS 2nd phase constructor

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

void CGSListboxEntry::ConstructL( TResourceReader& aReader )

    {

    iCaption = aReader.ReadHBufCL();

    iStaticTextLength = iCaption->Length();

    iFeatureId = aReader.ReadInt16();

    iType = aReader.ReadInt8();

    }

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

// CGSListboxEntry()

// c++ default constructor

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

CGSListboxEntry::CGSListboxEntry()

    {

    }

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

// ~CGSListboxEntry()

// destructor

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

EXPORT_C CGSListboxEntry::~CGSListboxEntry()

    {

    delete iCaption;

    }

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

// CGSListboxEntry::Feature()

// Provides feature for the selected entry

// @return feature

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

EXPORT_C TInt CGSListboxEntry::FeatureId() const

    {

    return iFeatureId;

    }

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

// CGSListboxEntry::Caption

// Provides caption for the selected entry

// @return caption

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

EXPORT_C const TDesC& CGSListboxEntry::Caption() const

    {

    return *iCaption;

    }

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

// CGSListboxEntry::Type

// Provides type for the selected entry

// @return type

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

EXPORT_C TInt CGSListboxEntry::Type() const

    {

    return iType;

    }

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

// CGSListboxEntry::SetDynamicTextL

// Appends dynamic text to the static text read

// from the resource.

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

EXPORT_C void CGSListboxEntry::SetDynamicTextL( const TDesC& aText )

    {

    const TInt requiredLength = StaticTextLength() + aText.Length();

    //

    TPtr pCaption( iCaption->Des() );

    const TInt maxLength = pCaption.MaxLength();

    //

    if( requiredLength >= maxLength )

        {

        // Make enough room for static text + new dynamic text

        iCaption = iCaption->ReAllocL( requiredLength );

        }

    // Have to re-get a new modifiable descriptor for the HBufC* since the

    // memory address may have changed after the realloc.

    pCaption.Set( iCaption->Des() );

    // Set the length back to only the static part

    pCaption.SetLength( StaticTextLength() );

    pCaption.Append( aText );

    }

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

// CGSListboxEntry::SetDynamicTextDoublePaneL

// Appends dynamic text to the static text read

// from the resource.

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

EXPORT_C void CGSListboxEntry::SetDynamicTextDoublePaneL( const TDesC& aText )

  {

  const TInt requiredLength = StaticTextLength() + aText.Length();

  //

  TPtr pCaption( iCaption->Des() );

  const TInt maxLength = pCaption.MaxLength();

  const TInt textSize = aText.Length();

  TInt location;

  // Here if it is the NULL string then we track of the 

  // Default text size in iDynamicTextSize

  if ( textSize > 0 )

    {

    iDynamicTextSize = textSize;

    // this location is also preserved for the same purpose

    location = aText.Locate( aText[0] );  

    }

  else

    {

    location = KErrNotFound;

    }

  //

  if ( location == KErrNotFound )

    {

    // We take the value from the end of the string

    location = pCaption.LocateReverse('\t');

    // We then delete the string;

    // iDynamicTextSize is the size of the "Default" text i.e. 7

    // 1 is added bcos \tText\t\t for the last tab

    pCaption.Delete( location - ( iDynamicTextSize + 1 ), iDynamicTextSize );

    }

  else

    {

    if( requiredLength >= maxLength )

        {

        // Make enough room for static text + new dynamic text

        iCaption = iCaption->ReAllocL( requiredLength );

        }

    // Have to re-get a new modifiable descriptor for the HBufC* since the

    // memory address may have changed after the realloc.

    pCaption.Set( iCaption->Des() );

    location = pCaption.LocateReverse('\t'); 

    pCaption.Insert( ( location - 1 ), aText );  

    }

  }

//... HERE IT ENDS

/*================================================

*

*   class declaration for CGSItemTextArray

*

*================================================*/

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

// CGSItemTextArray::NewLC()

// Symbian OS two-phased constructor

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

EXPORT_C CGSItemTextArray* CGSItemTextArray::NewL( TUint32 aResId,

                                                   CCoeEnv& aEnv )

    {

    CGSItemTextArray* self =

        new (ELeave) CGSItemTextArray( );

    CleanupStack::PushL( self );

    self->ConstructL( aResId, aEnv );

    CleanupStack::Pop( self );

    return self;

    }

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

// CGSItemTextArray()

// constructor

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

CGSItemTextArray::CGSItemTextArray()

:    iAllEntries( KGSListboxModelGranularity ),

    iCurrentlyDisplayedEntries( KGSListboxModelGranularity )

    {

    }

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

// ~CGSItemTextArray()

// destructor

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

CGSItemTextArray::~CGSItemTextArray()

    {

    iCurrentlyDisplayedEntries.Close();

    iAllEntries.ResetAndDestroy();

    iAllEntries.Close();

    }

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

// CGSItemTextArray::ConstructL()

// Symbian OS two-phased constructor

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

void CGSItemTextArray::ConstructL( TUint32 aResId, CCoeEnv& aEnv )

    {

    TResourceReader reader;

    aEnv.CreateResourceReaderLC( reader, aResId );

    //

    const TInt count = reader.ReadInt16();

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

        {

        CGSListboxEntry* entry = CGSListboxEntry::NewLC( reader );

        User::LeaveIfError( iAllEntries.Append( entry ) );

        // Always visible items are added here and never removed

        if    ( entry->Type() == EGSListBoxItemTypeIsAlwaysVisible )

            {

            User::LeaveIfError( iCurrentlyDisplayedEntries.Append( entry ) );

            }

        //

        CleanupStack::Pop( entry );

        }

    CleanupStack::PopAndDestroy(); //reader

    }

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

// CGSItemTextArray::ConstructL()

// Symbian OS two-phased constructor

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

void CGSItemTextArray::ConstructL(

    TUint32 aResId, CCoeEnv& aEnv, TInt aCount )

    {

    // Create entries and append them to entrylist.

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

        {

        CGSListboxEntry* entry = CGSListboxEntry::NewLC( aResId, aEnv, i );

        User::LeaveIfError( iAllEntries.Append( entry ) );

        CleanupStack::Pop( entry );

        }

    }

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

// CGSItemTextArray::MdcaCount()

// from MDesCArray

// @return count

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

EXPORT_C TInt CGSItemTextArray::MdcaCount() const

    {

    const TInt count = iCurrentlyDisplayedEntries.Count();

    return count;

    }

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

// CGSItemTextArray::MdcaPoint()

// from MDesCArray

// @return item text

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

EXPORT_C TPtrC CGSItemTextArray::MdcaPoint( TInt aIndex ) const

    {

    const TPtrC ret( iCurrentlyDisplayedEntries[aIndex]->Caption() );

    return ret;

    }

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

// CGSItemTextArray::SetDynamicTextL()

// Appends dynamic text to a selected listbox item

//

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

EXPORT_C void CGSItemTextArray::SetDynamicTextL( TInt aFeatureId,

                                              const TDesC& aAdditionalText )

    {

    TIdentityRelation<CGSListboxEntry> relation(CompareEntries);

    //

    CGSListboxEntry* entryToSearchFor = CGSListboxEntry::NewLC( aFeatureId );

    const TInt index = iAllEntries.Find( entryToSearchFor, relation );

    CleanupStack::PopAndDestroy( entryToSearchFor );

    User::LeaveIfError( index );

    //

    CGSListboxEntry* entry = iAllEntries[index];

    entry->SetDynamicTextL( aAdditionalText );

    }

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

// CGSItemTextArray::SetDynamicTextDoublePaneL()

// Appends dynamic text to a selected listbox item

//

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

EXPORT_C void CGSItemTextArray::SetDynamicTextDoublePaneL( TInt aFeatureId,

                        const TDesC& aAdditionalText )

  {

  TIdentityRelation<CGSListboxEntry> relation(CompareEntries);

  //

  CGSListboxEntry* entryToSearchFor = CGSListboxEntry::NewLC( aFeatureId );

  const TInt index = iAllEntries.Find( entryToSearchFor, relation );

  CleanupStack::PopAndDestroy( entryToSearchFor );

  User::LeaveIfError( index );

  //

  CGSListboxEntry* entry = iAllEntries[index];

  entry->SetDynamicTextDoublePaneL( aAdditionalText );

  }

//*****ENDS HERE

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

// CGSItemTextArray::SetItemVisibilityL()

// Indicates whether an item is to be shown/hidden

//

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

EXPORT_C void CGSItemTextArray::SetItemVisibilityL( TInt aFeatureId,

                                                 TVisibility aVisibility )

    {

    TIdentityRelation<CGSListboxEntry> relation( CompareEntries );

    CGSListboxEntry* entryToSearchFor = CGSListboxEntry::NewLC( aFeatureId );

    //

    if    ( aVisibility == EInvisible )

        {

        const TInt index = iCurrentlyDisplayedEntries.Find( entryToSearchFor,

                                                      relation );

        if    ( index != KErrNotFound )

            {

            // Remove the item from the currently visible items array

            iCurrentlyDisplayedEntries.Remove( index );

            }

        }

    else if ( aVisibility == EVisible )

        {

        // Check its not already visible

        const TInt alreadyVisibleIndex = iCurrentlyDisplayedEntries.Find(

                                             entryToSearchFor, relation );

        if    ( alreadyVisibleIndex == KErrNotFound )

            {

            const TInt index = iAllEntries.Find( entryToSearchFor, relation );

            User::LeaveIfError( index );

            // This is the entry we are going to make visible

            CGSListboxEntry* entry = iAllEntries[index];

            // Now insert it at the correct location.

            TBool foundInsertionPoint = EFalse;

            const TInt currentEntriesCount = iCurrentlyDisplayedEntries.Count();

            for( TInt allEntriesIndex=index-1; allEntriesIndex>=0 &&

                !foundInsertionPoint; allEntriesIndex-- )

                {

                // We are going to try and insert the new entry after the entry

                // specified as the previous item in the 'all entries' array,

                // in the iCurrentlyDisplayedEntries array.

                const TInt featureIdOfPreviousItem =

                           iAllEntries[allEntriesIndex]->FeatureId();

                for( TInt currentEntriesIndex=0; !foundInsertionPoint &&

                    currentEntriesIndex<currentEntriesCount;

                    currentEntriesIndex++ )

                    {

                    CGSListboxEntry* visibleEntry = iCurrentlyDisplayedEntries[

                                                           currentEntriesIndex];

                    if    ( visibleEntry->FeatureId() == featureIdOfPreviousItem )

                        {

                        foundInsertionPoint = ETrue;

                        // Insert after this item

                        User::LeaveIfError( iCurrentlyDisplayedEntries.Insert(

                                            entry, currentEntriesIndex+1 ) );

                        }

                    }

                }

            if    (!foundInsertionPoint)

                {

                // Just insert the item at the top of the list

                User::LeaveIfError(

                    iCurrentlyDisplayedEntries.Insert( entry, 0 ) );

                }

            }

        }

    CleanupStack::PopAndDestroy( entryToSearchFor );

    }

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

// CGSItemTextArray::CurrentFeature()

// Obtains feature id for a selected listbox item (feature)

// @return feature id

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

EXPORT_C TInt CGSItemTextArray::CurrentFeature() const

    {

    return KErrNotFound;

    }

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

// CGSItemTextArray::IndexForFeatureId()

//

// @return index

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

EXPORT_C TInt CGSItemTextArray::IndexForFeatureIdL(TInt aFeatureId) const

    {

    TIdentityRelation<CGSListboxEntry> relation( CompareEntries );

    CGSListboxEntry* entryToSearchFor = CGSListboxEntry::NewLC( aFeatureId );

    //

    const TInt index = iCurrentlyDisplayedEntries.Find( entryToSearchFor,

                                                        relation );

    CleanupStack::PopAndDestroy( entryToSearchFor );

    //

    return index;

    }

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

// CGSItemTextArray::FeatureIdByIndexL()

//

// @return index

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

EXPORT_C TInt CGSItemTextArray::FeatureIdByIndex(TInt aIndex) const

    {

    TInt featureId = KErrNotFound;

    //

    const TInt currentEntriesCount = iCurrentlyDisplayedEntries.Count();

    if  (aIndex >= 0 && aIndex < currentEntriesCount)

        {

        featureId = iCurrentlyDisplayedEntries[ aIndex ]->FeatureId();

        }

    //

    return featureId;

    }

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

// CGSItemTextArray::FeatureById()

//

// @return feature

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

EXPORT_C const CGSListboxEntry* CGSItemTextArray::FeatureByIdL(

                                                  TInt aFeatureId ) const

    {

    const CGSListboxEntry* locatedEntry = NULL;

    //

    TIdentityRelation<CGSListboxEntry> relation( CompareEntries );

    CGSListboxEntry* entryToSearchFor = CGSListboxEntry::NewLC( aFeatureId );

    //