/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
*
*/


// Version : %version: 3 %




// INCLUDE FILES
#include <eikappui.h>
#include <akntextsettingpage.h>
#include <barsread.h>

#include <cmmanagerext.h>
#include <cmdestinationext.h>
#include <cmapplicationsettingsui.h>

#include "mediasettings.hrh"
#include "MPSettingsStreamingSettingItemList.h"
#include "MPSettingsUDPPortSettingItem.h"
#include "MPSettingsModelForROP.h"
#include "mpxlog.h"

// CONSTANTS
const TInt KMPSettProxyHostListItemId  = 4;
const TInt KMPSettProxyPortListItemId  = 5;
const TInt KMPSettProxyHostMaxLength   = 1000;

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

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::CMPSettingsStreamingSettingItemList
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMPSettingsStreamingSettingItemList::CMPSettingsStreamingSettingItemList(
        CMPSettingsModelForROP* aModel ) 
	: iModel( aModel), 
	  iProxyHostPtr(NULL, 0)
    {
    MPX_DEBUG1(_L("#MS# CMPSettingsStreamingSettingItemList::CMPSettingsStreamingSettingItemList()"));
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::ConstructFromResourceL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::ConstructFromResourceL(TInt aResourceId) 
    {
    MPX_DEBUG2(_L("#MS# CMPSettingsStreamingSettingItemList::ConstructFromResourceL(0x%X)"),aResourceId);
	TResourceReader reader;
	iCoeEnv->CreateResourceReaderLC(reader, aResourceId);
	ConstructFromResourceL(reader);
    CleanupStack::PopAndDestroy(); // reader
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::ConstructFromResourceL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::ConstructFromResourceL(TResourceReader& aReader) 
    {
    MPX_DEBUG1(_L("#MS# CMPSettingsStreamingSettingItemList::ConstructFromResourceL()"));
    LoadAllL();
    CAknSettingItemList::ConstructFromResourceL(aReader);
    SetItemVisibilityL();
    }
  
// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::~CMPSettingsStreamingSettingItemList
// Destructor
// -----------------------------------------------------------------------------
//
CMPSettingsStreamingSettingItemList::~CMPSettingsStreamingSettingItemList()
    {
    MPX_DEBUG1(_L("#MS# CMPSettingsStreamingSettingItemList::~CMPSettingsStreamingSettingItemList()"));
	
    delete iProxyHost;
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::EditItemL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::EditItemL(TInt aIndex, TBool aCalledFromMenu)
    {
    MPX_DEBUG3(_L("#MS# CMPSettingsStreamingSettingItemList::EditItemL(%d,%d)"),aIndex,aCalledFromMenu);
    CAknSettingItem* settingItem = SettingItemArray()->At(aIndex);
    TInt identifier = settingItem->Identifier();

    if ( identifier == EMPSettDefaultAPSettingId )
        {
        LaunchConnectionSelectionL();
        }
    else
        {
        // Call base call's method
        CAknSettingItemList::EditItemL(aIndex, aCalledFromMenu);
        }

    // Store setting value to settings model
    settingItem->StoreL();   
    StoreSettingL(identifier);

    // Hide/unhide Proxy port & Proxy host settings according to Proxy mode.
    if (identifier == EMPSettProxyModeSettingId ||
        identifier == EMPSettDefaultAPSettingId )
        {
        SetItemVisibilityL();
        }
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::CreateSettingItemL
// -----------------------------------------------------------------------------
//
CAknSettingItem* CMPSettingsStreamingSettingItemList::CreateSettingItemL(TInt aSettingId)
    {
    MPX_DEBUG2(_L("#MS# CMPSettingsStreamingSettingItemList::CreateSettingItemL(%d)"),aSettingId);
    __ASSERT_DEBUG(iProxyHost, User::Leave(KErrAbort));

    CAknSettingItem* settingItem  = NULL;

    switch ( aSettingId )
        {
        case EMPSettProxyModeSettingId:
            iSettingProxyItem = new(ELeave) CAknBinaryPopupSettingItem( aSettingId, 
                                                                        iProxyMode );
            settingItem = iSettingProxyItem; 
            break;
        
        case EMPSettProxyHostSettingId:
            {
            settingItem = new(ELeave) CAknTextSettingItem(aSettingId, iProxyHostPtr);
            settingItem->SetSettingPageFlags(CAknTextSettingPage::EZeroLengthAllowed);
            break;
            }
        
        case EMPSettProxyPortSettingId:
            settingItem = new(ELeave) CAknIntegerEdwinSettingItem(aSettingId, iProxyPort);
            break;            
        
        case EMPSettDefaultAPSettingId:        
            iSettingConnectionItem = new (ELeave) CAknTextSettingItem( aSettingId, 
                                                                       iSelectedApName );
            settingItem = iSettingConnectionItem;
            break;

        case EMPSettMinUDPPortSettingId:
            settingItem = new(ELeave) CMPSettingsUDPPortSettingItem( aSettingId, 
                                                                     iMinUDPPort, 
                                                                     iMaxUDPPort);
            break;            

        case EMPSettMaxUDPPortSettingId:
            settingItem = new(ELeave) CMPSettingsUDPPortSettingItem( aSettingId, 
                                                                     iMaxUDPPort,
                                                                     iMinUDPPort);
            break;            
            
        default:
            break;
        }

    return settingItem;   
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::SetItemVisibilityL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::SetItemVisibilityL()
    {
    MPX_DEBUG2(_L("#MS# CMPSettingsStreamingSettingItemList::SetItemVisibilityL() iProxyMode(%d)"),iProxyMode);
    SettingItemArray()->At(KMPSettProxyHostListItemId)->SetHidden( !iProxyMode );
    SettingItemArray()->At(KMPSettProxyPortListItemId)->SetHidden( !iProxyMode );

    HandleChangeInItemArrayOrVisibilityL();
    
    if ( ListBox() )
       {
       // Scrollbar update is required for the case when items are set hidden
       // while list is scrolled down.
       ListBox()->UpdateScrollBarsL();
       }
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::LoadAllL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::LoadAllL()
    {
    MPX_DEBUG1(_L("#MS# CMPSettingsStreamingSettingItemList::LoadAllL()"));
    iModel->LoadSettingsL(EConfigUser);
    LoadSettingL(EMPSettProxyModeSettingId);
    LoadSettingL(EMPSettProxyHostSettingId);
    LoadSettingL(EMPSettProxyPortSettingId);
    LoadSettingL(EMPSettDefaultAPSettingId);
    LoadSettingL(EMPSettMinUDPPortSettingId);
    LoadSettingL(EMPSettMaxUDPPortSettingId);
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::LoadSettingL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::LoadSettingL(TInt aSettingId)
    {
    MPX_DEBUG2(_L("#MS# CMPSettingsStreamingSettingItemList::LoadSettingL(%d)"),aSettingId);
    switch ( aSettingId )
        {
        case EMPSettDefaultAPSettingId:
            {
            iModel->GetDefaultAp( iDefaultAP );

            if ( iDefaultAP != 0 ) 
                {
                UpdateSelectedConnectionNameL();
                }
            }
            break;

        case EMPSettConnTimeoutSettingId:
            iModel->GetConnectionTimeout(iConnTimeout);
            break;

        case EMPSettServerTimeoutSettingId:
            iModel->GetServerTimeout(iSrvTimeout);
            break;

        case EMPSettMinUDPPortSettingId:
            iModel->GetMinUDPPort(iMinUDPPort);
            break;

        case EMPSettMaxUDPPortSettingId:
            iModel->GetMaxUDPPort(iMaxUDPPort);
            break;
        
        case EMPSettProxyModeSettingId:
            iModel->GetProxyMode(iProxyMode);
            break;
            
        case EMPSettProxyHostSettingId:
            {
            if (!iProxyHost)
                {
                iProxyHost = HBufC::NewL(KMPSettProxyHostMaxLength);
                iProxyHostPtr.Set(iProxyHost->Des());
                }

            iModel->GetProxyHostName(iProxyHostPtr);
            break;
            }
        case EMPSettProxyPortSettingId:
            iModel->GetProxyPort(iProxyPort);
            break;
            
        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::StoreSettingL
// -----------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::StoreSettingL(TInt aSettingId)
    {
    MPX_DEBUG2(_L("#MS# CMPSettingsStreamingSettingItemList::StoreSettingL(%d)"),aSettingId);
    switch (aSettingId)
        {
        case EMPSettDefaultAPSettingId:
            iModel->SetDefaultAp(iDefaultAP);
            break;
        case EMPSettConnTimeoutSettingId:
            iModel->SetConnectionTimeout(iConnTimeout);
            break;
        case EMPSettServerTimeoutSettingId:
            iModel->SetServerTimeout(iSrvTimeout);
            break;
        case EMPSettMinUDPPortSettingId:
            iModel->SetMinUDPPort(iMinUDPPort);
            break;
        case EMPSettMaxUDPPortSettingId:
            iModel->SetMaxUDPPort(iMaxUDPPort);
            break;
        case EMPSettProxyModeSettingId:
            iModel->SetProxyMode(iProxyMode);
            break;
        case EMPSettProxyHostSettingId:
            iModel->SetProxyHostNameL(*iProxyHost);
            break;
        case EMPSettProxyPortSettingId:
            iModel->SetProxyPort(iProxyPort);
            break;
        default:
            break;
        }

    iModel->StoreSettingsL();
    }

// --------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::LaunchConnectionSelectionL()
// --------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::LaunchConnectionSelectionL()
    {
    MPX_FUNC("#MS# CMPSettingsStreamingSettingItemList::LaunchConnectionSelectionL()");
    
    CCmApplicationSettingsUi* settingsUi = CCmApplicationSettingsUi::NewL();
    CleanupStack::PushL ( settingsUi );
    
    TCmSettingSelection selection;
    selection.iId = iDefaultAP;
    selection.iResult = CMManager::EConnectionMethod;
    
    TUint listItems = CMManager::EShowConnectionMethods;
    TBearerFilterArray filters;
    
    TBool retVal = settingsUi->RunApplicationSettingsL( selection, listItems, filters );
    if ( retVal )
        {
        TBool iapChanged = EFalse;
    
        switch ( selection.iResult )
            {
            case CMManager::EDestination:
                break;

            case CMManager::EAlwaysAsk:
                {
                iDefaultAP = 0; // Set AP to "None"
                }
                break;

            case CMManager::EConnectionMethod:
                {
                if ( selection.iId != iDefaultAP)
                    {
                    iDefaultAP = selection.iId;
                    iapChanged = ETrue;
                    }
                }
                break;

            default:
                break;
            }
        
        if ( iapChanged )
            {
            UpdateSelectedConnectionNameL( );
            
            if ( iSettingConnectionItem )
                {
                iSettingConnectionItem->LoadL ( );
                iSettingConnectionItem->UpdateListBoxTextL ( );
                }
    
            CheckProxyDisableL();
            
            DrawDeferred();
            }
        }
    CleanupStack::PopAndDestroy ( settingsUi );
    }

// --------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::CheckProxyDisableL()
// --------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::CheckProxyDisableL()
    {
    if ( iProxyMode && iSettingProxyItem )
        {
        iSettingProxyItem->EditItemL( EFalse );
        
        iSettingProxyItem->StoreL();
        StoreSettingL( EMPSettProxyModeSettingId );
    
        iSettingProxyItem->LoadL();
        iSettingProxyItem->UpdateListBoxTextL();
        }
    }

// --------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::UpdateSelectedConnectionNameL
// --------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::UpdateSelectedConnectionNameL()
    {
    MPX_FUNC("#MS# CMPSettingsStreamingSettingItemList::UpdateSelectedConnectionNameL()");
    
    RCmManagerExt cmManager;
    RCmConnectionMethodExt connMethod;

    CleanupClosePushL( cmManager );
    CleanupClosePushL( connMethod );
    
    cmManager.OpenL();

    // This leaves if conn method is not found.
    TRAPD( leave, connMethod = cmManager.ConnectionMethodL( iDefaultAP ) );
    if ( KErrNone == leave )
        {
        HBufC* tmpBuf = 
                cmManager.GetConnectionMethodInfoStringL( iDefaultAP, CMManager::ECmName);

        if( tmpBuf )
			{
			if ( tmpBuf->Length() < KMaxApNameLength )
            	{
	            iSelectedApName = *tmpBuf;
            	}
			delete tmpBuf;
			}	
        }

    CleanupStack::PopAndDestroy( &connMethod );
    CleanupStack::PopAndDestroy( &cmManager );
    }

// --------------------------------------------------------------------------
// CMPSettingsStreamingSettingItemList::HandleListBoxEventL()
// --------------------------------------------------------------------------
//
void CMPSettingsStreamingSettingItemList::HandleListBoxEventL(
    CEikListBox* aListBox,
    TListBoxEvent aListBoxEvent )
    {
    if ( ( aListBoxEvent == EEventEnterKeyPressed ) ||
         ( aListBoxEvent == EEventItemSingleClicked ) ||
         ( aListBoxEvent == EEventItemDoubleClicked ) )
        {
        CAknSettingItemList::HandleListBoxEventL( aListBox, aListBoxEvent );
        }
    }

//  End of File