diff -r 000000000000 -r dfb7c4ff071f datacommsserver/networkcontroller/src/CNetConDlgProcessor.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/networkcontroller/src/CNetConDlgProcessor.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,278 @@
+// Copyright (c) 2004-2009 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:
+//
+
+#include "CNetConDlgProcessor.h"
+#include <comms-infras/dialogprocessor.h>
+#include "CNetworkController.h"
+#include "MNetConDialogProcAccess.h"
+#include "NetConPanic.h"
+
+
+/*
+Template adapter class:
+Implement MNetConDialogProcAccess by forwarding all calls to 'Implementor' class
+Also can optionally 'own' the instance of the implementor (i.e. deletes it on destruction)
+*/
+template<typename Implementor>
+class CMDialogProcessorImpl : public CBase, public MNetConDialogProcAccess
+	{
+protected:
+	typedef Implementor TImplementation; //< Type of the implementor
+
+public:
+	/**
+	   Construct an MDialogProcessorImpl object.
+
+	   @param aPimpl  Points to implementation object
+	   @param aOwnImpl If ETrue, then the aPimpl will be destroyed when *this is destroyed.
+	   @return Instance of CMDialogProcessorImpl
+	*/
+	static CMDialogProcessorImpl* NewL( TImplementation* aPimpl, TBool aOwnImpl )
+		{
+		CMDialogProcessorImpl* self = new (ELeave) CMDialogProcessorImpl( aPimpl, aOwnImpl );
+		return self;
+		}
+
+	/**
+	   Forward the CancelEverything request to the implementation
+	*/
+	virtual void CancelEverything()
+		{
+		GetImpl()->CancelEverything();
+		}
+	/**
+	   Forward the SelectConnection request to the implementation
+	*/
+	virtual void SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs)
+		{
+		GetImpl()->SelectConnection( aObserver, aPrefs );
+		}
+	/**
+	   Forward the SelectConnection request to the implementation
+	*/
+	virtual void SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, TInt aLastError )
+		{
+		GetImpl()->SelectConnection( aObserver, aPrefs, aLastError );
+		}
+	/**
+	   Forward the SelectModemAndLocation request to the implementation
+	*/
+	virtual void SelectModemAndLocation(MDialogProcessorObserver& aObserver)
+		{
+		GetImpl()->SelectModemAndLocation( aObserver );
+		}
+	/**
+	   Forward the WarnNewConnection request to the implementation
+	*/
+	virtual void WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, const TDesC* aNewIapName, const TIspConnectionNames* aNewConnectionNames, TInt aLastError )
+		{
+		GetImpl()->WarnNewConnection( aObserver, aPrefs, aNewIapName, aNewConnectionNames, aLastError );
+		}
+	/**
+	   Forward the Reconnect request to the implementation
+	*/
+	virtual void Reconnect(MDialogProcessorObserver& aObserver )
+		{
+		GetImpl()->Reconnect( aObserver );
+		}
+
+	/**
+	   Destroy this object.
+	*/
+	virtual ~CMDialogProcessorImpl()
+		{
+		if( iOwnImpl )
+			{
+			delete iPimpl;		// We own it, so get rid of it
+			}
+		iPimpl = 0;
+		}
+protected:
+	/**
+	   Constructor. Unexciting in the extreme.
+	   @param aPimpl pointer to implementation
+	   @param aOwnImpl If ETrue, transfers ownership of the implementation to this wrapper
+	*/
+	CMDialogProcessorImpl( TImplementation *aPimpl, TBool aOwnImpl )
+		:iPimpl(aPimpl), iOwnImpl(aOwnImpl)
+		{
+		__ASSERT_DEBUG( iPimpl, NetConPanic(NetworkController::ETelBearerBadState));
+		}
+
+private:
+	/**
+	   Return the implementation pointer
+	*/
+	inline TImplementation* GetImpl() const
+		{
+		__ASSERT_DEBUG( iPimpl, NetConPanic(NetworkController::ETelBearerBadState));
+		return iPimpl;
+		}
+private:
+	TImplementation* iPimpl;	//< Pointer to class that implements the interface in a non-virtual fashion
+	TBool iOwnImpl;				//< ETrue if the destructor should delete iPimpl
+	};
+
+
+
+/**
+   Implement MNetConDialogProcAccess destructor
+*/
+MNetConDialogProcAccess::~MNetConDialogProcAccess()
+	{
+	}
+
+/**
+  Construct a CNetConDlgProcessor using the default CDialogProcessor implementation
+
+  @return a pointer to the newly created CNetConDlgProcessor
+*/
+CNetConDlgProcessor* CNetConDlgProcessor::NewL()
+	{
+	// To do this, we have to wrap a CDialogProcessor up so it looks like a MNetConDialogProcAccess.
+	// so use the CMDialogProcessorImpl wrapper class
+
+	// First, construct the CDialogProcessor itself...
+	CDialogProcessor* processor = CDialogProcessor::NewL();
+	CleanupStack::PushL( processor );
+
+	// Now costruct the MNetConDialogProcAccess wrapper for it
+	CMDialogProcessorImpl<CDialogProcessor>* impl = CMDialogProcessorImpl<CDialogProcessor>::NewL( processor, ETrue );
+
+	// impl now owns aProcess, so get it back from the cleanup stack
+	CleanupStack::Pop( processor );
+
+	// and save impl...
+	CleanupStack::PushL( impl );
+
+	// Construct the CNetConDlgProcessor itself
+	CNetConDlgProcessor* self = new (ELeave) CNetConDlgProcessor( impl );
+
+	// and cleanup the cleanup
+	CleanupStack::Pop( impl );
+	return self;
+	}
+
+/**
+  Construct a CNetConDlgProcessor using a supplied MNetConDialogProcAccess implementation
+
+  @param aImpl The supplied implementation
+  @param aOwnImpl True if the CNetConDlgProcessor takes ownership of aImpl
+
+  @return a pointer to the newly created CNetConDlgProcessor
+*/
+CNetConDlgProcessor* CNetConDlgProcessor::NewL( MNetConDialogProcAccess* aImpl, TBool aOwnImpl )
+	{
+	// Note: We can probably get away without the CMDialogProcessorImpl wrapper in the case where aOwnImpl is true
+	// Construct a wrapper for the implementation
+	CMDialogProcessorImpl<MNetConDialogProcAccess>* impl = CMDialogProcessorImpl<MNetConDialogProcAccess>::NewL( aImpl, aOwnImpl );
+	CleanupStack::PushL( impl );
+	// Transfer ownership of the wrapper to the dialog processor itself
+	CNetConDlgProcessor* self = new (ELeave) CNetConDlgProcessor( impl );
+	CleanupStack::Pop( impl );
+	return self;
+	}
+
+CNetConDlgProcessor::~CNetConDlgProcessor()
+	{
+	delete iDialogProc;
+	}
+
+/**
+   Constructor
+
+   @param aImpl  Pointer to dialog processor implementation
+*/
+CNetConDlgProcessor::CNetConDlgProcessor( MNetConDialogProcAccess* aImpl )
+	:iDialogProc( aImpl )
+	{
+	ASSERT( aImpl );
+	}
+
+/**
+   Retrieve the implementation pointer
+*/
+MNetConDialogProcAccess* CNetConDlgProcessor::GetImpl() const
+	{
+	__ASSERT_DEBUG( iDialogProc, NetConPanic(NetworkController::ETelBearerBadState));
+	return iDialogProc;
+	}
+
+
+/**
+   Cancel all outstanding dialog processor requests
+*/
+void CNetConDlgProcessor::CancelEverything()
+	{
+	GetImpl()->CancelEverything();
+	}
+
+/**
+   Display a dialog to the user asking them to select an IAP to connect to
+
+   @param aObserver the object to receive notification when the dialog box completes
+   @param aPrefs the connection preferences used to select this IAP
+*/
+void CNetConDlgProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs)
+	{
+	GetImpl()->SelectConnection( aObserver, aPrefs );
+	}
+
+/**
+   Display a dialog to the user asking them to select an IAP to connect to
+
+   @param aObserver the object to receive notification when the dialog box completes
+   @param aPrefs the connection preferences used to select this IAP
+   @param aLastError if this is not the 1st connection attempt this is the error of the last attempt
+*/
+void CNetConDlgProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, TInt aLastError )
+	{
+	GetImpl()->SelectConnection( aObserver, aPrefs, aLastError );
+	}
+
+/**
+   Display a dialog to the user asking the user to select a modem and location entry from CommDb
+
+   @param aObserver the object to receive notification when the dialog box completes
+*/
+void CNetConDlgProcessor::SelectModemAndLocation(MDialogProcessorObserver& aObserver)
+	{
+	GetImpl()->SelectModemAndLocation( aObserver );
+	}
+
+/**
+   Display a dialog to the user warning that a new connection is about to be attempted to the specified IAP
+
+   @param aObserver the object to receive notification when the dialog box completes
+   @param aPrefs the connection preferences used to select this IAP
+   @param aNewIapName the name of the IAP used for the connection.
+   @param aNewConnectionNames this parameter is no-longer used.
+   @param aLastError if this is not the 1st connection attempt this is the error of the last attempt
+*/
+void CNetConDlgProcessor::WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, const TDesC* aNewIapName, const TIspConnectionNames* aNewConnectionNames, TInt aLastError )
+	{
+	GetImpl()->WarnNewConnection( aObserver, aPrefs, aNewIapName, aNewConnectionNames, aLastError );
+	}
+
+/**
+   Display a dialog to the user asking whether to reconnect a failed connection
+
+   @param aObserver the object to receive notification when the dialog box completes
+*/
+void CNetConDlgProcessor::Reconnect(MDialogProcessorObserver& aObserver )
+	{
+	GetImpl()->Reconnect( aObserver );
+	}
+