/*

* Copyright (c) 2006 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:  MuiuDynamicSettingsDialog.cpp

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <eiktxlbx.h>               // CEikTextListBox

#include <badesca.h>                // CDesCArray

#include <eiktxlbm.h>               // CTextListBoxModel

#include <AknUtils.h>               // CAknTextUtils

#include <akntitle.h>               // CAknTitlePane

#include <AknQueryDialog.h>         // CAknQueryDialog

#include <aknsettingpage.h>         // CAknSettingPage

#include <aknradiobuttonsettingpage.h> // CAknRadioButtonSettingPage

#include <aknpasswordsettingpage.h> // CAknPasswordSettingPage

#include <akntextsettingpage.h>     // CAknTextSettingPage

#include <eikbtgpc.h>               // CEikButtonGroupContainer

#include <StringLoader.h>           // StringLoader

#include "MuiuDynamicSettingsDialog.h" // CMuiuDynamicSettingsDialog

#include "IMSWCheckBoxPage.h"   // CIMSSettingsWizardCheckBoxPage

#include <muiu_internal.rsg>

#include <ImumUtils.rsg>                 // R_IMAS_MSK_OPEN, should be temporary

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// Prevent any looping problems by defining maximum amount of editor openings

const TInt KMuiuMaxEditors = 100;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog()

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

//

CMuiuDynamicSettingsDialog::CMuiuDynamicSettingsDialog(

    CEikFormattedCellListBox& aListBox,

    CAknTitlePane& aTitlePane )

    :

    CMuiuDynamicSettingsArray(),

    iListBox( aListBox ),

    iTitlePane( aTitlePane ),

    iSettingValue( KErrNotFound )

    {

    }

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

// CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()

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

//

CMuiuDynamicSettingsDialog::~CMuiuDynamicSettingsDialog()

    {

    // Remove the scrollbar from listbox

    iListBox.SetScrollBarFrame( NULL, CEikListBox::EOwnedExternally );

    if ( iSoftkeys )

        {

        iSoftkeys->SetObserver( EFalse, EFalse, EFalse, *this );

        delete iSoftkeys;

        }

    iSoftkeys = NULL;

    delete iSettingPageResources;

    iSettingPageResources = NULL;

    if ( iSettingsLastItemIndex )

        {

        iSettingsLastItemIndex->Reset();

        }

    delete iSettingsLastItemIndex;

    iSettingsLastItemIndex = NULL;

    if ( iCheckboxArray )

        {

        iCheckboxArray->ResetAndDestroy();

        }

    if ( iSettingsPageArray )

        {

        iSettingsPageArray->Reset();

        }

    if ( iBackupArray )

        {

        iBackupArray->ResetAndDestroy();

        }

    delete iBackupArray;

    iBackupArray = NULL;

    delete iSettingsPageArray;

    iSettingsPageArray = NULL;

    delete iCheckboxArray;

    iCheckboxArray = NULL;

    delete iOldTitleText;

    iOldTitleText = NULL;

    delete iQueryDialog;

    iQueryDialog = NULL;

    delete iSettingPage;

    iSettingPage = NULL;

    delete iButtonArray;

    iButtonArray = NULL;

    delete iSettingText;

    iSettingText = NULL;

    delete iNewPassword;

    iNewPassword = NULL;

    delete iOldPassword;

    iOldPassword = NULL;

    iScrollBar = NULL;

    }

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

// CMuiuDynamicSettingsDialog::SettingsConstructL()

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

//

void CMuiuDynamicSettingsDialog::SettingsConstructL(

    CEikButtonGroupContainer& aSoftkeys,

    const TInt aResource,

    const TBool aUpdateMSK,

    const TBool aLockedSettings )

    {

    BaseConstructL( aResource, aLockedSettings );

    // Set as observer

    iListBox.SetListBoxObserver( this );

    iListBox.View()->SetListEmptyTextL( KNullDesC );

    // Get scrollbar

    iScrollBar = iListBox.CreateScrollBarFrameL( ETrue );

    iScrollBar->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    // Create array

    CTextListBoxModel* model = iListBox.Model();

    model->SetItemTextArray( this );

    model->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Set this dialog for button listening

    iSoftkeys = CIMSSoftkeyControl::NewL( aSoftkeys );

    iSoftkeys->SetObserver( ETrue, ETrue, ETrue, *this );

    iSoftkeys->SetMSKLabelling( aUpdateMSK );

    UpdateMskL();

    // Prepare setting page arrays

    iSettingPageResources = CIMSPageResourceControl::NewL();

    iSettingsLastItemIndex =

        new ( ELeave ) CMuiuDynSetIntArray( KMuiuDynArrayGranularity );

    // Add array to store the backup items

    iBackupArray = new ( ELeave ) CMuiuDynSetItemArray( KMuiuDynArrayGranularity );

    // Define setting pages in enumeration order

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_LISTBOX );

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_CHECKLISTBOX );

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_TEXT );

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_NUMBER );

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_SC_NUMBER );

    iSettingPageResources->CreateStackL( R_MUIU_SETTINGS_DIALOG_PASSWORD );

    iSettingPageResources->CreateStackL( NULL );

    }

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

// CMuiuDynamicSettingsDialog::HandleListBoxEventL()

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

//

void CMuiuDynamicSettingsDialog::HandleListBoxEventL(

    CEikListBox* /* aListBox */,

    TListBoxEvent aEventType )

    {

    switch ( aEventType )

        {

        // Note for TouchUi. When focused item is tapped, both

        // EEventItemClicked and EEventItemDoubleClicked events

        // are received. When unfocused item is tapped, EEventItemClicked

        // event is received. Double tap to focused item produces

        // the same events as a single tap.

        case EEventEnterKeyPressed:

        case EEventItemDoubleClicked:

        case EEventItemActioned:

            OpenSettingPageL();

            break;

        case EEventItemClicked:

        case EEventItemDraggingActioned:

            UpdateMskL();

            break;

        default:

            break;

        }

    }

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

// CMuiuDynamicSettingsDialog::OfferKeyEventL

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

//

TKeyResponse CMuiuDynamicSettingsDialog::OfferKeyEventL(

    const TKeyEvent& /* aKeyEvent */,

    TEventCode aType )

    {

    if ( aType == EEventKeyUp )

        {

        UpdateMskL();

        }

    return EKeyWasNotConsumed;

    }

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

// CMuiuDynamicSettingsDialog::SetTitlePaneTextL()

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

//

void CMuiuDynamicSettingsDialog::SetTitlePaneTextL(

    const TDesC& aText,

    const TBool aSaveCurrent )

    {

    HBufC* text = aText.Alloc();

    CleanupStack::PushL( text );

    if ( aSaveCurrent )

        {

        delete iOldTitleText;

        iOldTitleText = NULL;

        iOldTitleText = iTitlePane.Text()->Alloc();

        }

    iTitlePane.SetTextL( *text );

    CleanupStack::PopAndDestroy( text );

    text = NULL;

    }

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

// CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText()

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

//

void CMuiuDynamicSettingsDialog::SetPreviousTitlePaneText(

    const TBool aSaveCurrent )

    {

    TRAP_IGNORE( SetTitlePaneTextL( *iOldTitleText, aSaveCurrent ) );

    }

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

    Settingpage opening

    - Find out the item to be edited

    - Send start editing event with the item

    - Check the item type

    - Check the resources

    - If no resources available, ask them

    - Start editing

    - Send end editing event

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

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

// CMuiuDynamicSettingsDialog::OpenSettingPageL()

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(

    const TInt aIndex )

    {

    // To open setting page, check if the Setting Page index is provided,

    // if not get the current item index in array

    TInt index = ( aIndex == KErrNotFound ) ?

        iListBox.CurrentItemIndex() : aIndex;

    // Search for the item and open it

    return SettingPageOpenL( *GetItem( index ) );

    }

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

// CMuiuDynamicSettingsDialog::OpenSettingPageL()

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::OpenSettingPageL(

    CMuiuSettingBase& aBaseItem )

    {

    return SettingPageOpenL( aBaseItem );

    }

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

// CMuiuDynamicSettingsDialog::SettingPageOpenL()

//

// This function contains the main logic for the setting editor handling

// in the settings dialog. The setting editors are kept opening as long

// as the all the settings are gone through or the editor is dismissed.

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::SettingPageOpenL(

    CMuiuSettingBase& aBaseItem )

    {

    // Don't open the editor for read-only items

    if ( aBaseItem.iItemFlags.Flag( EMuiuDynItemReadOnly ) )

        {

        return EMuiuPageResultReadOnly;

        }

    else if( aBaseItem.iItemFlags.Flag( EMuiuDynItemLockableSetting ) &&

        iArrayFlags.Flag( EMuiuEMailLockedSettings ) )

        {

        return EMuiuPageResultPageLocked;

        }

    // Store current focused item for last item index array

    iCurrentItemIndex = iListBox.CurrentItemIndex();

    // Starting editing of the item, do not allow updating during editing

    iListBox.MakeVisible( EFalse );

    iArrayFlags.ClearFlag( EMuiuDynArrayAllowRefresh );

    // When starting to edit page, send event so that item can be prepared

    // for the editing. In case of error, editing won't start

    TMuiuPageEventResult eventResult = EventItemEditStartsL( aBaseItem );

    TMuiuPageResult result;

    if ( eventResult == EMuiuPageEventResultApproved )

        {

        // Create the array if it doesn't exist yet

        if ( !iSettingsPageArray )

            {

            iSettingsPageArray = new ( ELeave ) CMuiuDynSetItemArray(

                KMuiuDynArrayGranularity );

            }

        // Clear the array and add the editable item to array

        CleanBackupArray();

        iSettingsPageArray->Reset();

        SetCurrentSettingsPage( aBaseItem );

        result = SettingsPageOpenCheckL();

        do

            {

            if ( result == EMuiuPageResultEditing )

                {

                // Open the setting page

                result = SettingPageOpenEditorL();

                // Do open check. Note that the result can be modified!

                SettingsCheckNextEditorOpen( result );

                }

            // Finish the editing of the item

            SettingPageOpenFinishL();

            }

        while ( result == EMuiuPageResultEditing );

        }

    else if ( eventResult == EMuiuPageEventResultDisapproved )

        {

        result = EMuiuPageResultOk;

        }

    else

        {

        result = EMuiuPageResultEventCancel;

        }

    // Send item edit ends

    EventItemEditEndsL( aBaseItem );

    aBaseItem.iItemFlags.ClearFlag( EMuiuDynItemOneTimeForceViewOpen );

    iArrayFlags.SetFlag( EMuiuDynArrayAllowRefresh );

    iListBox.MakeVisible( ETrue );

    // Update the listbox

    Refresh();

    return result;

    }

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

// CMuiuDynamicSettingsDialog::EventPrepareSubArrayL()

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

//

TInt CMuiuDynamicSettingsDialog::EventPrepareSubArrayL(

    CMuiuSettingBase& aBaseItem,

    const TBool aForward )

    {

    // Check direction in array

    if ( aForward )

        {

        // Store the index and set to beginning

        SetSettingsLastItemIndexL( iCurrentItemIndex );

        iListBox.SetCurrentItemIndex( 0 );

        }

    // When going backwards

    else

        {

        // Restore previous index

        iListBox.SetCurrentItemIndex( SettingsLastItemIndex() );

        }

    return EventSubArrayChangeL( aBaseItem );

    }

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

    Settingpage creation

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

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

// CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::SettingsPageOpenCheckL()

    {

    CMuiuSettingBase* base = CurrentSettingsPage();

    // Before starting to open the page, check that item type is not

    // menuarray. In case of menuarray, just open the next level

    if ( HandleStackForwardL( *base ) == EMuiuStackResultSubMenuOpen )

        {

        UpdateMskL();

        return EMuiuPageResultSubMenuOpen;

        }

    // Don't open read only items

    if ( base->iItemFlags.Flag( EMuiuDynItemReadOnly ) )

        {

        return EMuiuPageResultReadOnly;

        }

    // The page is ok is for edit

    return EMuiuPageResultEditing;

    }

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

// CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen()

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

//

void CMuiuDynamicSettingsDialog::SettingsCheckNextEditorOpen(

    TMuiuPageResult& aResult )

    {

    // The settings user have selected, must be available to user.

    // For this reason, items shall restored to main array only, when

    // returning from editors

    switch ( aResult )

        {

        // Handle approved

        case EMuiuPageResultOk:

            aResult = HandleEditorOk();

            break;

        // Handle the cancelled editor page

        case EMuiuPageResultCancelled:

            aResult = HandleEditorCancel();

            break;

        // Continue editing

        case EMuiuPageResultEditing:

            aResult = HandleEditorDisapproved();

            break;

        default:

            __ASSERT_DEBUG( EFalse, User::Panic(

                KMuiuDynSetDialogPanic, KErrUnknown ) );

            break;

        }

    }

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

// CMuiuDynamicSettingsDialog::HandleEditorCancel()

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorCancel()

    {

    // The editor was cancelled, so the first check needed to make

    // is deterimine, if the editor was first in the line.

    TMuiuPageResult result = EMuiuPageResultInvalidResult;

    TInt editorCount = iSettingsPageArray->Count();

    if ( editorCount == 1 )

        {

        // Restore all of the items

        RestoreFromBackup();

        result = EMuiuPageResultCancelled;

        }

    // More than one page in the array, just jump back to the previous

    // and remove the previous value

    else if ( editorCount > 0 )

        {

        RemoveLastBackupItem();

        iSettingsPageArray->Delete( editorCount-1 );

        result = EMuiuPageResultEditing;

        }

    // Array is empty, unexpected situation

    else

        {

        __ASSERT_DEBUG( EFalse, User::Panic(

            KMuiuDynSetDialogPanic, KErrNotFound ) );

        }

    return result;

    }

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

// CMuiuDynamicSettingsDialog::HandleEditorOk()

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

//

TMuiuPageResult CMuiuDynamicSettingsDialog::HandleEditorOk()

    {

    CMuiuSettingBase* nextItem = NULL;

    // Check if current selection contains subeditors

    if ( iSettingValue >= 0 )

        {

        nextItem = SettingFindEditor(