/*

* Copyright (c) 1997-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 <eikdialg.h>

#include <eikon.hrh>

#include <eikmover.h>

#include <eikcapc.h>

#include <eikcapca.h>

#include <eikcmbut.h>

#include <eikdialg.pan>

#include <eikform.pan>

#include <barsread.h>

#include <eikenv.h>

#include <AknDef.h>

#include <eikbtpan.h>

#include <eikbtgpc.h>

#include <eikcore.rsg>

#include <eikappui.h>

#include <eikdialg.h>

#include <eikdpsel.h>

#include "EIKDBCOB.H"

#include <eiklbbut.h>

#include <aknborders.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <eikdpage.h>

#include <eikmop.h>

#include <aknenv.h>

//<SKIN>

#include "eikdialogext.h"

#include <AknsListBoxBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <skinlayout.cdl.h>

#include <eikdpobs.h>

#include <aknedwindrawingmodifier.h>

#include <AknMediatorFacade.h>

#include <AknMediatorObserver.h>

#include <aknglobalpopupprioritycontroller.h>

#include <aknview.h>

#include <aknViewAppUi.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <AknTasHook.h> // for testability hooks

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <akntranseffect.h>

#endif

#include <AknQueryDialog.h>

#include <aknQueryControl.h>

#include "akncbacontentobserver.h"

TBool IsBlankScreenDisplayed();

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

// Returns ETrue if CBA is embedded to dialog.

// @return ETrue if cba is embedded.

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

//

TBool CbaEmbeddedInDialog( const TInt& aFlags )

    {

        !( aFlags & EEikDialogFlagFillScreen ) &&

    }

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

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

//

void InvalidateWindows( CCoeControl* aControl )

    {

    if ( aControl )

        {

        if ( aControl->OwnsWindow() )

            {

            ( (RWindow*) aControl->DrawableWindow() )->ClearRedrawStore();

            }

        for ( TInt i = aControl->CountComponentControls() - 1; i >= 0; --i )

            {

            InvalidateWindows( aControl->ComponentControl( i ) );

            }

        }

    }

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

// Finds out if this control belongs to the window group that is in focus.

// This information can be used to skip effects when the window group is

// not visible.

//

// @param aThis The control in question.

//

// @return ETrue if the window group is in focus, otherwise EFalse

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

//

TBool IsFocusedWindowGroup( CEikDialog* aThis )

    {

    RWindowTreeNode* node = aThis->DrawableWindow();

    // this code finds out if this control belongs to window group

    // that is in focus, there are some rare cases when the latest opened

    // popup goes behind another one (e.g. system lock query -> power key menu)

    // we don't want transition in that case

    RWsSession& wsSession = CEikonEnv::Static()->WsSession();

    TInt nodeWindowGroupId = node->WindowGroupId();

    TInt focusedWindowGroupId = wsSession.GetFocusWindowGroup();

    if ( nodeWindowGroupId == focusedWindowGroupId )

        {

        return aThis->IsFocused();

        }

    TInt count = wsSession.NumWindowGroups( 0 );

    // because there is not leave here,so no need to use CleanupStack.

    CArrayFixFlat<TInt>* wgIds = new CArrayFixFlat<TInt>( count );

    if ( wgIds )

        {

        // Get list of window group ids from WServ

        wsSession.WindowGroupList( 0, wgIds );

        // Select the first in the list (which will always be the forground app)

        // and we assume that there always will be at least one window group with zero priority

        TInt wgId = (*wgIds)[0];

        delete wgIds;

        if ( focusedWindowGroupId == wgId )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

GLDEF_C void Panic(TEikDialogPanic aPanic)

	{

	_LIT(KPanicCat,"EIKON-DIALOG");

	User::Panic(KPanicCat,aPanic);

	}

GLDEF_C void Panic(TEikFormPanic aPanic)

	{

	_LIT(KPanicCat,"EIKON-FORM");

	User::Panic(KPanicCat,aPanic);

	}

enum

    { // follow on from values in UIKON.HRH

    EEikDialogFlagSleeping	=0x20000,

	EEikDialogFlagBroughtForward=0x40000,

	// EEikDialogFlagNoBackgroundFade = 0x80000 in uikon.hrh,

	EEikDialogAttemptFadeWhenVisible=0x100000

    // 0x20000 is used by uikon.hrh

    };

// AknSecondaryDisplaySupportUtilities

#if ((defined(__COVER_DISPLAY) || defined(__VOICE_UI )))   

void IssueMediatorCommand(CEikDialog* aDialog)

    {

    CAknMediatorFacade* caps = AknMediatorFacade(aDialog);

    if (caps)

        {

        caps->IssueCommand();

        }

    }

void CancelMediatorCommand(CEikDialog* aDialog)

    {

    CAknMediatorFacade* caps = AknMediatorFacade(aDialog);

    if (caps)

        {

        caps->CancelCommand();

        }

    }

#else

void CancelMediatorCommand(CEikDialog*){}

void IssueMediatorCommand(CEikDialog*){}

#endif

EXPORT_C CEikDialog::CEikDialog()

    {

//	__DECLARE_NAME(_S("CEikDialog"));

//	No border in Avkon

	iBorder=TGulBorder(TGulBorder::ENone);

    SetMopParent(iEikonEnv->EikAppUi());

#if defined (__DEBUG__)

	RDebug::ProfileReset(PROFILE_POINT_EIKON_DIALOG_LOAD,1);

	RDebug::ProfileStart(PROFILE_POINT_EIKON_DIALOG_LOAD);

#endif

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    GfxTransEffect::Register(this,KGfxPopupDefaultControlUid);

#endif

    AKNTASHOOK_ADD( this, "CEikDialog" );

    }

EXPORT_C CEikDialog::~CEikDialog()

    {

    AKNTASHOOK_REMOVE();

    EnableContentObserver( EFalse );

    if ( GfxTransEffect::IsRegistered( this ) )

        {

        // ensure that this is not drawn since parts are destroyed

        MakeVisible( EFalse ); 

        CAknTransitionUtils::MakeVisibleSubComponents( this,

                                        CAknTransitionUtils::EForceInvisible );

        GfxTransEffect::Deregister(this); //Always deregister in destructor.

        }

    // remove from stack before deleting members, this way focus changed will behave correctly

	if (!(iDialogFlags&EEikDialogFlagModeless))

	    iEikonEnv->RemoveFromStack(this);

	FadeBehindPopup(EFalse);

	if (iDialogFlags&EEikDialogFlagBroughtForward)

		iEikonEnv->BringForwards(EFalse);

	AknGlobalPopupPriorityController::RemovePopupPriority(*this);

	delete iButtonCommandObserver;

	delete iTitleBar;

	delete iPageSelector;

	delete iButtonGroupContainer;

	delete iExtension ;

	iExtension = NULL;

	StopWaitingAsRequired();

    }

void CEikDialog::DynamicConstructL()

	{

    PreLayoutDynInitL();

    if ( iPageSelector && iPageSelector->IsForm() && Extension() )

        {

        Extension()->iPublicFlags.Set( CEikDialogExtension::EFullyConstructed );

        }

    EnableContentObserver( ETrue );

    Layout();

    PostLayoutDynInitL();

	}

/**

 * Prepares the dialog, constructing it from the resource with id aResourceId.

 *

 * The dialog is  added to the stack in here to avoid a possible reallocation

 * of the stack in RunLD,  the purpose is to be able to display note dialogs in OOM

 * situations.

 */

EXPORT_C void CEikDialog::PrepareLC(TInt aResourceId)

    {

    CleanupStack::PushL(this);

	BaseConstructL();

    StaticConstructL(aResourceId);

	if (!(iDialogFlags&EEikDialogFlagModeless))

		{

		AknGlobalPopupPriorityController::AddPopupToControlStackL(*this,ECoeStackPriorityDialog,ECoeStackFlagRefusesAllKeys);

		}

    }

/**

 * Reads the dialog resources into the dialog, constructing it from the specified resource.

 * The function is only to help loading dialog resources and 

 * extracting dialog data.

 *

 * Code is same as in PrepareLC() but iEikonEnv->EikAppUi()->AddToStackL() is omitted

 */

EXPORT_C void CEikDialog::ReadResourceLC(TInt aResourceId)

    {

    CleanupStack::PushL(this);

	BaseConstructL();

    StaticConstructL(aResourceId);

    }

/**

 * Prepares and runs the dialog and returns the id of the button used to dismiss

 * it. The dialog is constructed from the resource with id aResourceId and is destroyed

 * on exit.

 */

EXPORT_C TInt CEikDialog::ExecuteLD(TInt aResourceId)

    {

	PrepareLC(aResourceId);

	return(RunLD());

    }

void CEikDialog::BaseConstructL()

	{

    CreateWindowL();

	Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));

	EnableDragEvents();

	Window().SetPointerGrab(ETrue);

    iContext=this;

    Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));

	iButtonCommandObserver=CEikDialogButtonCommandObserver::NewL(*this);

    if (!iExtension)

        {

	    iExtension = CEikDialogExtension::NewL( *this ) ;        

        }

	}

void CEikDialog::StaticConstructL(TInt aResourceId)

    {

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader,aResourceId);

    ConstructFromResourceL(reader);

	CleanupStack::PopAndDestroy();

    if ( CAknEnv::Static()->TransparencyEnabled() )

        {

        if ( !(iDialogFlags & EEikDialogFlagFillAppClientRect ||

           iDialogFlags & EEikDialogFlagFillScreen ) )

            {

            Window().SetRequiredDisplayMode( EColor16MA );

            TInt err = Window().SetTransparencyAlphaChannel();

            if ( err == KErrNone )

                {

                Window().SetBackgroundColor(~0);

                }

            }

        }

    }

/**

 * Constructs a sleeping dialog from the resources identified by aResourceId.

 * A sleeping dialog is one which can be displayed at any time since its memorey

 * resources are pre-allocated.

 */

EXPORT_C void CEikDialog::ConstructSleepingDialogL(TInt aResourceId)

	{

	CommonConstructSleepingDialogL(aResourceId);

    AknGlobalPopupPriorityController::AddPopupToControlStackL(*this,ECoeStackPriorityDialog,ECoeStackFlagRefusesAllKeys|ECoeStackFlagRefusesFocus|ECoeStackFlagSharable);

	}

/**

 * Constructs a sleeping dialog from the resources identified by aResourceId

 * at a high priority on the control stack.

 */

EXPORT_C void CEikDialog::ConstructSleepingAlertDialogL(TInt aResourceId)

	{

 	CommonConstructSleepingDialogL(aResourceId);

    AknGlobalPopupPriorityController::AddPopupToControlStackL(*this,ECoeStackPriorityAlert,ECoeStackFlagRefusesAllKeys|ECoeStackFlagRefusesFocus|ECoeStackFlagSharable);

	}

void CEikDialog::CommonConstructSleepingDialogL(TInt aResourceId)

	//

	// code common to both ConstructSleepingDialogL & ConstructSleepingAlertDialogL

	//

	{

	iDialogFlags|=EEikDialogFlagSleeping;

	BaseConstructL();

	StaticConstructL(aResourceId);

	MakeVisible(EFalse);

	if (iButtonGroupContainer)

		{

		// non visible CBA's do not recieve keys

		iButtonGroupContainer->MakeVisible(EFalse);

		}

	}

TInt CEikDialog::WaitAsRequired()

    {

    TInt exitConfirmed=0;

#if defined (__DEBUG__)

	RDebug::ProfileEnd(PROFILE_POINT_EIKON_DIALOG_LOAD);

	TProfile profile;

	RDebug::ProfileResult(&profile,PROFILE_POINT_EIKON_DIALOG_LOAD,1);

	TBuf<60> tmp;

	_LIT(KMsg,"Time to load dialog: %d milliseconds");

	tmp.Format(KMsg,profile.iTime/1000);

	iEikonEnv->VerboseInfoMsg(tmp);

#endif

    if (iDialogFlags&EEikDialogFlagWait)

        {

		iExitConfirmed=(&exitConfirmed);

        iWait.Start();

        }

	return(exitConfirmed);

    }

void CEikDialog::StopWaitingAsRequired()

	{

	CAknEnv::StopSchedulerWaitWithBusyMessage(iWait);

	}

/**

 * Rouses a sleeping dialog by dynamically constructing it and then 

 * bringing it to the front.

 */

EXPORT_C TInt CEikDialog::RouseSleepingDialog()

	{ // none of following ...L calls to Leave

	if (IsVisible())

		ExitSleepingDialog(); // eg for rousing an already roused Alert dialog

    #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    //make sure that "this" is registered

    if( !GfxTransEffect::IsRegistered( this ) )

        {

        if ( iExtension->iRegisteredContext != KNullUid )

            {

            GfxTransEffect::Register( this, iExtension->iRegisteredContext );

            }

        else

            {

            GfxTransEffect::Register( this, KGfxPopupDefaultControlUid );

            }

        }

    #endif

    //if registered then do not animate bitmaps until after transition is complete

    if( GfxTransEffect::IsRegistered( this ) ) 

        {

        CAknTransitionUtils::SetData(EDontAnimateBitmaps, (TAny*)this);

        }

	ResetLineMinimumSizes();

	iEikonEnv->BringForwards(ETrue); // before the call to EnableBackup()

  	DrawableWindow()->SetOrdinalPosition(0);

	if (iButtonGroupContainer && iButtonGroupContainer->Location() == CEikButtonGroupContainer::EExternal)

	  	iButtonGroupContainer->ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0);	

	AknGlobalPopupPriorityController::ShowPopup(*this, ETrue);

	iDialogFlags|=EEikDialogFlagBroughtForward;

	TRAPD(err, DynamicConstructL());

	if (err)

        {

        if( GfxTransEffect::IsRegistered( this ) ) 

            {

            CAknTransitionUtils::RemoveData( EDontAnimateBitmaps );

            }

        iEikonEnv->HandleError(err); // non mem allocating note shown

        return KErrNone; // Error handled, no need to show another note, 

        } //we will not delete dialog as there might be enough memory to show it in next try  

	if (~iDialogFlags&EEikDialogFlagNoBackup)

		DrawableWindow()->EnableBackup();

	FadeBehindPopup(ETrue);

	AknGlobalPopupPriorityController::RouseSleepingPopup(*this,ETrue);

	if (iCoeEnv->LastEvent().Type()==EEventPointer)

		ClaimPointerGrab(ETrue); // send pointer up to any dragged component

    SetInitialCurrentLine();

	TInt slidingMode = ESlidingDisabled;                 

	if ( (iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout) &&

	     (slidingMode != ESlidingDisabled) &&

	     IsVisible() )

	    {

        SlideDialog();	    

	    }

	TRAP(err, ActivateL());

	if (err)

		Panic(EEikDialogLeaveInSleepingDialog);

    IssueMediatorCommand(this);

    if( GfxTransEffect::IsRegistered(this) && !IsVisible() &&

        IsFocusedWindowGroup( this ) && !IsBlankScreenDisplayed() )

		{

        MakeVisible( EFalse );

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort );

        CAknTransitionUtils::MakeVisibleSubComponents( this,

                                        CAknTransitionUtils::EForceInvisible );

		CAknTransitionUtils::SetAllParents(this);

        InvalidateWindows( this );

		GfxTransEffect::Begin(this, KGfxControlAppearAction);

		GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);

		TRect demarcation;

		CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, 

		                                    demarcation);

		GfxTransEffect::SetDemarcation(this, demarcation);

        MakeVisible(ETrue);

        CAknTransitionUtils::MakeVisibleSubComponents( this,

                                        CAknTransitionUtils::EForceVisible );

		GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);

		GfxTransEffect::End(this);

		}

	else

		{

		MakeVisible(ETrue);

		}

	if( GfxTransEffect::IsRegistered(this) )

		{

		CAknTransitionUtils::RemoveData(EDontAnimateBitmaps); 

		}