/*

* Copyright (c) 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: This file implements class CIpsSetUiBaseArray.

*

*/

#include "emailtrace.h"

#include <e32base.h>            // Base symbian include

#include <gulutil.h>            // KColumnListSeparator

#include <eikenv.h>             // CEikonEnv

#include <eikrutil.h>           // EikResourceUtils

#include <AknUtils.h>           // AknTextUtils

#include <data_caging_path_literals.hrh>

#include <ipssossettings.rsg>

#include "ipssetutilsexception.h"

#include "ipssetutilsconsts.h"

#include "ipssetuifinder.h"

#include "ipssetuiitembase.h"   

#include "ipssetuiitemvalue.h"  

#include "ipssetuiitemtext.h"   

#include "ipssetuiitemlink.h"   

#include "ipssetuiitemextlink.h"

#include "ipssetuifinder.h"

#include "ipssetutilspageids.hrh"

#include "ipssetuibasearray.h"

// This is added at the end of the compulsory setting item string

_LIT( KIpsSetUiStrCompulsory, "\t*" );

// The number of characters that can be shown in the screen

const TInt KIpsSetUiVisibleTextLength = 30;

//

const TInt KIpsSetUiPasswordSecLength = 4;

_LIT( KCharsToReplace, "\r\n\t\x2028\x2029" );

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

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

// CIpsSetUiBaseArray::CIpsSetUiBaseArray()

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

//

CIpsSetUiBaseArray::CIpsSetUiBaseArray()

    :

    iFinder( NULL ),

    iItemArray( NULL ),

    iPasswordFill( 0x00 ),

    iActiveCount( 0 ),

    iError( KErrNone ),

    iEnv( CEikonEnv::Static() ) // faulty CS warning

    {

    FUNC_LOG;

    }

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

// CIpsSetUiBaseArray::~CIpsSetUiBaseArray()

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

//

CIpsSetUiBaseArray::~CIpsSetUiBaseArray()

    {

    FUNC_LOG;

    CleanArrayItems();

    if ( iResourceStack )

        {

        iResourceStack->Reset();

        delete iResourceStack;

        iResourceStack = NULL;

        }

    delete iItemArray;

    delete iTempText;

    delete iFinder;

    }

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

// CIpsSetUiBaseArray::BaseConstructL()

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

//

void CIpsSetUiBaseArray::BaseConstructL()

    {

    FUNC_LOG;

    // Prepare the arrays

    iItemArray = new ( ELeave ) CIpsSetUiBaseItemArray( KIpsSetUiArrayGranularity );

    iResourceStack = new ( ELeave ) RResourceStack( KIpsSetUiArrayGranularity );

    iFinder = CIpsSetUiFinder::NewL( *this );

    iArrayFlags.SetFlag( EIpsSetUiArrayAllowRefresh );

    // Prepare strings

    iTempText = HBufC::NewL( KIpsSetUiMaxSettingsTextLength );

    iPasswordFill = EikResourceUtils::ReadTInt16L( 

        R_IPS_SET_DIALOG_PASSWORD_FILL, iEnv );

    }

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

// CIpsSetUiBaseArray::BaseConstructL()

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

//

void CIpsSetUiBaseArray::BaseConstructL(

    const TInt aResourceId )

    {

    FUNC_LOG;

    // Initialize the members

    BaseConstructL();

    // If resource provided add it into the setting array

    LoadSettingArrayFromResourceL( aResourceId );

    UpdateActiveItemsCount();

    }

TInt CIpsSetUiBaseArray::GetLastResourceId( )

    {

    FUNC_LOG;

    TInt ret = KErrNotFound;

    if ( iResourceStack && iResourceStack->Count() > 0 )

        {

        ret = (*iResourceStack)[ iResourceStack->Count() -1 ];

        }

    return ret;

    }

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

// CIpsSetUiBaseArray::CleanArrayItems()

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

//

void CIpsSetUiBaseArray::CleanArrayItems()

    {

    FUNC_LOG;

    if ( iItemArray )

        {

        // Search through all items in the array

        for ( TInt index = iItemArray->Count() - 1 ; index >= 0; index-- )

            {

            // Only certain type of items can contain subarrays

            CIpsSetUiItem* base = ( *iItemArray )[index];

            delete base;

            base = NULL;

            }

        }

    }

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

// CIpsSetUiBaseArray::CreateCustomItemToArrayLC()

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

//

CIpsSetUiItem* CIpsSetUiBaseArray::CreateCustomItemToArrayLC(

    const TUid& /* aId */ )

    {

    FUNC_LOG;

    return NULL;

    }

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

// CIpsSetUiBaseArray::ListboxItemFillMultiLineLabel()

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

//

void CIpsSetUiBaseArray::ListboxItemFillMultiLineLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText = static_cast<const CIpsSetUiItemLink*>( 

        &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

    }

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

// CIpsSetUiBaseArray::ListboxItemFillEditTextLabel()

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

//

void CIpsSetUiBaseArray::ListboxItemFillEditTextLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText.Copy( aBaseItem.Text().Left( KIpsSetUiVisibleTextLength ) );

    }

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

// CIpsSetUiBaseArray::ListboxItemFillEditValueLabel()

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

//

void CIpsSetUiBaseArray::ListboxItemFillEditValueLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    const TInt KNumberSize = 10;

    if ( aText.MaxLength() - aText.Length() >= KNumberSize )

        {

        aText.AppendNum( aBaseItem.Value() );

        }

    }

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

// CIpsSetUiBaseArray::ListboxItemFillEditTimeLabel()

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

//

void CIpsSetUiBaseArray::ListboxItemFillEditTimeLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText.Append( aBaseItem.Value() );

    aText.SetLength( KIpsSetUiVisibleTextLength );

    }

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

// CIpsSetUiBaseArray::ListboxUndefinedFillLabel()

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

//

void CIpsSetUiBaseArray::ListboxUndefinedFillLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText = static_cast<const CIpsSetUiItemLinkExt*>( 

        &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

    }

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

// CIpsSetUiBaseArray::ListboxRadioButtonFillArrayLabel()

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

//

void CIpsSetUiBaseArray::ListboxRadioButtonFillArrayLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText = static_cast<const CIpsSetUiItemLinkExt*>( 

        &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

    }

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

// CIpsSetUiBaseArray::ListboxCheckboxFillArrayLabel()

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

//

void CIpsSetUiBaseArray::ListboxCheckboxFillArrayLabel(

    const CIpsSetUiItem& aBaseItem,

    TIpsSetUtilsTextPlain& aText ) const

    {

    FUNC_LOG;

    aText = static_cast<const CIpsSetUiItemLinkExt*>( 

        &aBaseItem )->iItemSettingText->Left( KIpsSetUiVisibleTextLength );

    }

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

// CIpsSetUiBaseArray::ListboxItemLabelFillL()

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

//

TPtrC16 CIpsSetUiBaseArray::ListboxItemLabelFillL(

    CIpsSetUiItem& aBaseItem ) const

    {

    FUNC_LOG;

    // Get the type of the setting item

    TIpsSetUiSettingsType type = aBaseItem.iItemType;

    TIpsSetUtilsTextPlain tempSettingText;

    tempSettingText.Zero();

    switch ( type )

        {

        case EIpsSetUiItemMultiLine:

            ListboxItemFillMultiLineLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiUndefined:

            ListboxUndefinedFillLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiRadioButtonArray:

            ListboxRadioButtonFillArrayLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiCheckBoxArray:

            ListboxCheckboxFillArrayLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiItemText:

            ListboxItemFillEditTextLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiItemValue:

            ListboxItemFillEditValueLabel( aBaseItem, tempSettingText );

            break;

        case EIpsSetUiItemTime:

            ListboxItemFillEditTimeLabel( aBaseItem, tempSettingText );

            break;

        default:

            // Nothing to show, send empty text

            break;

        }

    // remove line feed from signature line's visible part

    if( aBaseItem.iItemId == TUid::Uid(EIpsSetUiMailboxSignature) || 

        aBaseItem.iItemId == TUid::Uid(EIpsSetUiMailboxMailboxName) )

        {

        AknTextUtils::ReplaceCharacters( tempSettingText, KCharsToReplace, ' ' );

        }

    // If the setting is marked as password, fill special character

    // instead of readable text

    TInt length = tempSettingText.Length();

    if ( length > 0 && aBaseItem.iItemFlags.Flag32( KIpsSetUiFlagPassword ) )

        {

        // Add special chars to all type characters in setting field

        TChar passFill = TChar( iPasswordFill );

        tempSettingText.Zero();

        tempSettingText.AppendFill( passFill, KIpsSetUiPasswordSecLength );

        }

    return tempSettingText;

    }

/******************************************************************************

    Item property editors

******************************************************************************/

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

// CIpsSetUiBaseArray::SetItemText()

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

//

void CIpsSetUiBaseArray::SetItemText(

    CIpsSetUiItem& aBaseItem,

    const TDesC& aText,

    const TBool aUpdate )

    {

    FUNC_LOG;

    switch ( aBaseItem.iItemType )

        {

        case EIpsSetUiItemValue:

            static_cast<CIpsSetUiItemValue*>( 

                &aBaseItem )->iItemSettingText->Copy( aText );

            break;

        case EIpsSetUiRadioButtonArray:

        case EIpsSetUiCheckBoxArray:

            static_cast<CIpsSetUiItemLinkExt*>( 

                &aBaseItem )->iItemSettingText->Copy( aText );

            break;

        default:

            aBaseItem.SetText( aText );

            break;

        }

    // Issue update when needed

    if ( aUpdate )

        {

        Refresh();

        }

    }

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

// CIpsSetUiBaseArray::ItemText()

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

//

const TDesC& CIpsSetUiBaseArray::ItemText(

    CIpsSetUiItem& aBaseItem )

    {

    FUNC_LOG;

    switch ( aBaseItem.iItemType )

        {

        case EIpsSetUiItemValue:

            return *static_cast<CIpsSetUiItemValue*>( 

                &aBaseItem )->iItemSettingText;

        case EIpsSetUiRadioButtonArray:

        case EIpsSetUiCheckBoxArray:

            return *static_cast<CIpsSetUiItemLinkExt*>( 

                &aBaseItem )->iItemSettingText;

        }

    return aBaseItem.Text();

    }

/******************************************************************************

    Base class function definitions

******************************************************************************/

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

// CIpsSetUiBaseArray::SearchDoError()

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

//

TBool CIpsSetUiBaseArray::SearchDoError()

    {

    FUNC_LOG;

    return ETrue;

    }

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

// CIpsSetUiBaseArray::SearchDoContinuationCheck()

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

//

TBool CIpsSetUiBaseArray::SearchDoContinuationCheck(

    const CIpsSetUiItem& /* aItem */,

    const TInt /* aIndex */ )

    {

    FUNC_LOG;

    return ETrue;

    }

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

// CIpsSetUiBaseArray::SearchDoItemCheck()

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

//

TBool CIpsSetUiBaseArray::SearchDoItemCheck(

    CIpsSetUiItem& /* aItem */ )

    {

    FUNC_LOG;

    return ETrue;

    }

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

// CIpsSetUiBaseArray::MdcaCount()

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

//

TInt CIpsSetUiBaseArray::MdcaCount() const

    {

    FUNC_LOG;

    return iActiveCount;

    }

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

// CIpsSetUiBaseArray::MdcaPoint()

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

//

TPtrC16 CIpsSetUiBaseArray::MdcaPoint( TInt aIndex ) const

    {

    FUNC_LOG;

    // First search the currently active resource to array and check

    // the given index is in the current array

    IPS_ASSERT_DEBUG( aIndex < StackCountItems(), KErrOverflow, EBaseArray );

    // Temp text ptr

    TPtr tempText = iTempText->Des();

    // Do a sanity check for index and return null text if out of range

    if ( !iFinder || aIndex < 0 || aIndex >= StackCountItems())

        {       

        tempText.Zero();

        tempText.Append(KNullDesC);        

        return tempText;

        }

    // Search for item from the active array

    CIpsSetUiItem* setting = iFinder->FinderArray()->At( aIndex ).iItem;  // faulty CS warning

    IPS_ASSERT_DEBUG( setting , KErrNotFound, EBaseArray );

    // Prepare strings

    // Send custom event and if not used, prepare default

    if ( !EventCustomMdcaPoint( setting->iItemId, tempText ) )

        {

        // Initialize string

        tempText.Zero();

        tempText.Append( KIpsSetUiStrSpace );

        tempText.Append( KColumnListSeparator );

        tempText.Append( *setting->iItemLabel );

        // Submenus doesn't contain other information

        if ( !ItemSubArrayCheck( *setting ) )

            {

            tempText.Append( KColumnListSeparator );

            tempText.Append( KColumnListSeparator );

            TIpsSetUtilsTextPlain tempSettingText;

            // Try to add the text

            TRAP_IGNORE( tempSettingText =

                ListboxItemLabelFillL( *setting ) );

            // Fill the setting text with string

            if ( tempSettingText.Length() )

                {

                tempText.Append( tempSettingText );

                }

            else

                {

                tempText.Append( KIpsSetUiStrSpace );

                }

            // Add the special string after compulsory fields

            if ( setting->iItemFlags.Flag32( KIpsSetUiFlagCompulsory ) )

                {

                tempText.Append( KIpsSetUiStrCompulsory );

                }

            // Do the number conversion, if allowed

            if ( setting->iItemFlags.Flag32( KIpsSetUiFlagLangSpecificNumConv ) )

                {

                AknTextUtils::DisplayTextLanguageSpecificNumberConversion(

                    tempText );

                }

            }

        }

    setting = NULL;

    return tempText;

    }

/******************************************************************************

    Resource loading functions

******************************************************************************/

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

// CIpsSetUiBaseArray::LoadDynamicSettingItemL()

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

//

void CIpsSetUiBaseArray::LoadDynamicSettingItemL(

    TResourceReader& aReader,