/*

* Copyright (c) 2005 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:  Implementation of the CWidgetUiDialogsProviderProxy class.

*

*/

// INCLUDE Files

// User includes

#include "WidgetUiDialogsProviderProxy.h"

#include "WidgetUiWindowManager.h"

#include "WidgetUiWindow.h"

#include "WidgetUiWindowView.h"

// System includes

#include <browserdialogsproviderobserver.h>

#include <browserdialogsprovider.h>

// CONSTANTS

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

// CWidgetUiDialogsProviderProxy::CWidgetUiDialogsProviderProxy

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

CWidgetUiDialogsProviderProxy::CWidgetUiDialogsProviderProxy(

						    CBrowserDialogsProvider& aDialogsProvider,

						    MBrowserDialogsProviderObserver* aDialogsObserver,

						    CWidgetUiWindow& aWidgetWindow )

    : iDialogsProvider( aDialogsProvider ),

      iDialogsObserver( aDialogsObserver ),

      iWidgetWindow( aWidgetWindow ),

      iCancelWaitingDialogs( EFalse )

	{

	}

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

// CWidgetUiDialogsProviderProxy::~CWidgetUiDialogsProviderProxy

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

CWidgetUiDialogsProviderProxy::~CWidgetUiDialogsProviderProxy()

	{

	}

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

//	CWidgetUiDialogsProviderProxy* CWidgetUiDialogsProviderProxy::NewL

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

CWidgetUiDialogsProviderProxy* CWidgetUiDialogsProviderProxy::NewL(

						    CBrowserDialogsProvider& aDialogsProvider,

						    MBrowserDialogsProviderObserver* aDialogsObserver,

						    CWidgetUiWindow& aWidgetWindow  )

	{

	CWidgetUiDialogsProviderProxy* self = new (ELeave)

	        CWidgetUiDialogsProviderProxy(   aDialogsProvider,

	                                        aDialogsObserver,

	                                        aWidgetWindow );

	CleanupStack::PushL( self );

	self->ConstructL( );

	CleanupStack::Pop( self );   // self

	return self;

	}

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

//  CWidgetUiDialogsProviderProxy::ConstructL

//

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

void CWidgetUiDialogsProviderProxy::ConstructL()

	{

	}

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

//  CWidgetUiDialogsProviderProxy::DialogNotifyErrorL

//

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

void CWidgetUiDialogsProviderProxy::DialogNotifyErrorL( TInt aErrCode )

	{

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

    	{

    	iDialogsProvider.DialogNotifyErrorL( aErrCode );

    	if ( iDialogsObserver )

    	    {

    	    iDialogsObserver->ReportDialogEventL(

                                MBrowserDialogsProviderObserver::ENotifyError,

        	                            aErrCode );

    	    }

        }

	}

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

//  CWidgetUiDialogsProviderProxy::DialogNotifyHttpErrorL

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

void CWidgetUiDialogsProviderProxy::DialogNotifyHttpErrorL(

								            TInt aErrCode, const TDesC& aUri )

	{

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

    	{

    	iDialogsProvider.DialogNotifyHttpErrorL( aErrCode, aUri );

    	if ( iDialogsObserver )

    	    {

    	    iDialogsObserver->ReportDialogEventL(

    	                    MBrowserDialogsProviderObserver::ENotifyHttpError,

                            NULL );

    	    }

    	}

	}

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

//  CWidgetUiDialogsProviderProxy::DialogFileSelectLC

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

TBool CWidgetUiDialogsProviderProxy::DialogFileSelectLC(

                                                    const TDesC& aStartPath,

													const TDesC& aRootPath,

													HBufC*& aSelectedFileName )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

    	{

    	retVal = iDialogsProvider.DialogFileSelectLC( aStartPath,

    	                                                    aRootPath,

    	                                                    aSelectedFileName );

    	}

	return retVal;

	}

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

//  CWidgetUiDialogsProviderProxy::DialogSelectOptionL

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

TBool CWidgetUiDialogsProviderProxy::DialogSelectOptionL(

								const TDesC& aTitle,

								TBrCtlSelectOptionType aBrCtlSelectOptionType,

								CArrayFix<TBrCtlSelectOptionData>& aOptions )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    retVal = iDialogsProvider.DialogSelectOptionL(

	                                                aTitle,

	                                                aBrCtlSelectOptionType,

	                                                aOptions );

	    }

	return retVal;

	}

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

// CWidgetUiDialogsProviderProxy::DialogUserAuthenticationLC

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

TBool CWidgetUiDialogsProviderProxy::DialogUserAuthenticationLC(

												const TDesC& aUrl,

												const TDesC& aRealm,

												const TDesC& aDefaultUserName,

												HBufC*& aReturnedUserName,

												HBufC*& aReturnedPasswd,

												TBool aBasicAuthentication )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

		// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    retVal = iDialogsProvider.DialogUserAuthenticationLC(

	                                                aUrl,

	                                                aRealm,

	                                                aDefaultUserName,

	                                                aReturnedUserName,

	                                                aReturnedPasswd,

	                                                aBasicAuthentication );

	    if ( iDialogsObserver )

	        {

            iDialogsObserver->ReportDialogEventL(

                        MBrowserDialogsProviderObserver::EUserAuthentication,

                        ( TInt ) retVal );

	        }

	    }

	return retVal;

	}

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

//  CWidgetUiDialogsProviderProxy::DialogNoteL

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

void CWidgetUiDialogsProviderProxy::DialogNoteL( const TDesC& aMessage )

	{

	HandleDialogRequestL();

    // Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    iDialogsProvider.DialogNoteL( aMessage );

	    }

	}

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

//  CWidgetUiDialogsProviderProxy::DialogAlertL

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

void CWidgetUiDialogsProviderProxy::DialogAlertL( const TDesC& aTitle,

											        const TDesC& aMessage )

	{

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    iDialogsProvider.DialogAlertL( aTitle, aMessage );

	    }

	}

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

//  CWidgetUiDialogsProviderProxy::DialogConfirmL

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

TBool CWidgetUiDialogsProviderProxy::DialogConfirmL( const TDesC& aTitle,

												    const TDesC& aMessage,

												    const TDesC& aYesMessage,

												    const TDesC& aNoMessage )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

		// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    retVal = iDialogsProvider.DialogConfirmL( aTitle, aMessage,

	                                                aYesMessage, aNoMessage );

	    }

    return retVal;

	}

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

// CWidgetUiDialogsProviderProxy::DialogPromptLC

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

TBool CWidgetUiDialogsProviderProxy::DialogPromptLC( const TDesC& aTitle,

												const TDesC& aMessage,

												const TDesC& aDefaultInput,

												HBufC*& aReturnedInput )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    retVal = iDialogsProvider.DialogPromptLC( aTitle, aMessage,

                                            aDefaultInput, aReturnedInput );

	    }

    return retVal;

	}

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

//  CWidgetUiDialogsProviderProxy::DialogDownloadObjectL

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

TBool CWidgetUiDialogsProviderProxy::DialogDownloadObjectL(

										CBrCtlObjectInfo* aBrCtlObjectInfo )

	{

	HandleDialogRequestL();

	TBool retVal = iDialogsProvider.DialogDownloadObjectL( aBrCtlObjectInfo );

	return retVal;

	}

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

// CWidgetUiDialogsProviderProxy::DialogDisplayPageImagesL

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

void CWidgetUiDialogsProviderProxy::DialogDisplayPageImagesL(

							CArrayFixFlat<TBrCtlImageCarrier>& aPageImages )

	{

    HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    iDialogsProvider.DialogDisplayPageImagesL( aPageImages );

	    }

	}

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

//  CWidgetUiDialogsProviderProxy::CancelAll

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

//

void CWidgetUiDialogsProviderProxy::CancelAll()

	{

	// Dialogs should be flushed, but not displayed

    iCancelWaitingDialogs = ETrue;

    iDialogsProvider.CancelAll();

	}

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

//  CWidgetUiDialogsProviderProxy::DialogMimeFileSelectLC

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

TBool CWidgetUiDialogsProviderProxy::DialogMimeFileSelectLC(

													HBufC*& aSelectedFileName,

													const TDesC& aMimeType )

	{

	TBool retVal( EFalse );

	HandleDialogRequestL();

	// Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

    	{

    	retVal = iDialogsProvider.DialogMimeFileSelectLC( aSelectedFileName,

    	                                                  aMimeType );

    	}

	return retVal;

	}

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

//  CWidgetUiDialogsProviderProxy::ShowTooltipL

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

//

void CWidgetUiDialogsProviderProxy::ShowTooltipL(    const TDesC& aText,

                                                    TInt aDuration,

                                                    TInt aDelay )

    {

    HandleDialogRequestL();

    if ( !iCancelWaitingDialogs )

        {

        iDialogsProvider.ShowTooltipL(   aText, aDuration, aDelay );

        }

    }

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

//  CWidgetUiDialogsProviderProxy::UploadProgressNoteL

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

//

void CWidgetUiDialogsProviderProxy::UploadProgressNoteL(

                                TInt32 aTotalSize,

                                TInt32 aChunkSize,

                                TBool aIsLastChunk,

                                MBrowserDialogsProviderObserver* aObserver )

    {

    HandleDialogRequestL();

    // Forward dialog to DialogsProvider if it has not been cancelled

	if ( !iCancelWaitingDialogs )

	    {

	    iDialogsProvider.UploadProgressNoteL(   aTotalSize,

	                                            aChunkSize,

	                                            aIsLastChunk,

	                                            aObserver );

	    }

    }

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

//  CWidgetUiDialogsProviderProxy::HandleDialogRequestL()

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

//

void CWidgetUiDialogsProviderProxy::HandleDialogRequestL()

    {

    // Dialogs for background windows must be blocked

	// Also, if options menu is loaded,  then alert dialogs must be blocked

	iCancelWaitingDialogs = ( iWidgetWindow.WidgetMiniViewState() == EPublishStart

    						||(iWidgetWindow.WindowManager().View())->IsOptionsMenuActivated());

    if ( !iCancelWaitingDialogs)

        iCancelWaitingDialogs = ((iWidgetWindow.WindowManager().ActiveWindow())?

                    (iWidgetWindow.WindowManager().ActiveWindow() != &iWidgetWindow):

                    (ETrue));

    }

//  End of File