FCL/sf/mw/classicui: comparison uifw/EikStd/dlgsrc/EIKDIALG.CPP

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 #include <avkon.rsg>
 #include <avkon.hrh>
 #include <eikdpage.h>
 #include <eikmop.h>
 #include <aknenv.h>
+#include <touchfeedback.h>
 //<SKIN>
 #include "eikdialogext.h"
 #include <AknsListBoxBackgroundControlContext.h>
 #include <AknsDrawUtils.h>
 #include <AknUtils.h>
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 #include <akntranseffect.h>
 #endif
 #include <AknQueryDialog.h>
 #include <aknQueryControl.h>
+#include <aknitemactionmenuregister.h>
+#include <layoutmetadata.cdl.h>
 #include "akncbacontentobserver.h"
+#include "akntrace.h"
 TBool IsBlankScreenDisplayed();
 // -----------------------------------------------------------------------------
 // @return ETrue if cba is embedded.
 // -----------------------------------------------------------------------------
 //
 TBool CbaEmbeddedInDialog( const TInt& aFlags )
 {
-return AknLayoutUtils::PenEnabled() &&
+return !( aFlags & EEikDialogFlagFillAppClientRect ) &&
-!( aFlags & EEikDialogFlagFillAppClientRect ) &&
 !( aFlags & EEikDialogFlagFillScreen ) &&
-!( aFlags & EEikDialogFlagVirtualInput );
+!( aFlags & EEikDialogFlagVirtualInput ) &&
+!( aFlags & EEikDialogFlagNoEmbeddedSoftkeys );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // @return ETrue if the window group is in focus, otherwise EFalse
 // -----------------------------------------------------------------------------
 //
 TBool IsFocusedWindowGroup( CEikDialog* aThis )
 {
+	_AKNTRACE_FUNC_ENTER;
 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
 delete wgIds;
 if ( focusedWindowGroupId == wgId )
 {
+_AKNTRACE( "return ETrue;");
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 }
+_AKNTRACE( "return EFalse;");
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 GLDEF_C void Panic(TEikDialogPanic aPanic)
 	{
 #endif
 EXPORT_C CEikDialog::CEikDialog()
 {
+	_AKNTRACE_FUNC_ENTER;
 //	__DECLARE_NAME(_S("CEikDialog"));
 //	No border in Avkon
 	iBorder=TGulBorder(TGulBorder::ENone);
 SetMopParent(iEikonEnv->EikAppUi());
 #if defined (__DEBUG__)
 #endif
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 GfxTransEffect::Register(this,KGfxPopupDefaultControlUid);
 #endif
 AKNTASHOOK_ADD( this, "CEikDialog" );
+	_AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C CEikDialog::~CEikDialog()
 {
+	_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
+AknItemActionMenuRegister::RemoveConstructingMenuBarOwner( this );
 EnableContentObserver( EFalse );
 if ( GfxTransEffect::IsRegistered( this ) )
 {
 	delete iPageSelector;
 	delete iButtonGroupContainer;
 	delete iExtension ;
 	iExtension = NULL;
 	StopWaitingAsRequired();
+	_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialog::DynamicConstructL()
 	{
+	_AKNTRACE_FUNC_ENTER;
 PreLayoutDynInitL();
 if ( iPageSelector && iPageSelector->IsForm() && Extension() )
 {
 Extension()->iPublicFlags.Set( CEikDialogExtension::EFullyConstructed );
 }
 EnableContentObserver( ETrue );
+// Extension member variable iDeleteEmbeddedCba is used to track whether
+// dialog's implementation of CCoeControl::SizeChanged gets called. If it
+// isn't then embedded softkeys won't work.
+CEikDialogExtension* extension = Extension();
+TBool checkCba = extension && iButtonGroupContainer
+&& CbaEmbeddedInDialog( iDialogFlags );
+if ( checkCba )
+{
+extension->iDeleteEmbeddedCba = ETrue;
+}
 Layout();
+// At this point CBA's rect should be correctly set. If it isn't, then
+// assume that dialog didn't properly call CEikDialog::SizeChanged thus
+// embedded softkeys won't work.
+// In that case softkeys are deleted and re-created as a window-owning
+// component in "legacy" way.
+if (checkCba && extension->iButtonGroupResourceId != 0 &&
+(extension->iDeleteEmbeddedCba || Size().iWidth <= 0))
+{
+delete iButtonGroupContainer;
+iButtonGroupContainer = NULL;
+iButtonGroupContainer = CEikButtonGroupContainer::NewL(
+CEikButtonGroupContainer::ECba,
+CEikButtonGroupContainer::EHorizontal,
+iButtonCommandObserver,
+extension->iButtonGroupResourceId,
+0 );
+iDialogFlags |= EEikDialogFlagNoEmbeddedSoftkeys;
+}
 PostLayoutDynInitL();
+_AKNTRACE_FUNC_EXIT;
 	}
 /**
 * Prepares the dialog, constructing it from the resource with id aResourceId.
 *
 * 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)
 {
+	_AKNTRACE_FUNC_ENTER;
 CleanupStack::PushL(this);
 	BaseConstructL();
 StaticConstructL(aResourceId);
 	if (!(iDialogFlags&EEikDialogFlagModeless))
 		{
 		AknGlobalPopupPriorityController::AddPopupToControlStackL(*this,ECoeStackPriorityDialog,ECoeStackFlagRefusesAllKeys);
 		}
+	_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Reads the dialog resources into the dialog, constructing it from the specified resource.
 * The function is only to help loading dialog resources and
 * it. The dialog is constructed from the resource with id aResourceId and is destroyed
 * on exit.
 */
 EXPORT_C TInt CEikDialog::ExecuteLD(TInt aResourceId)
 {
+	_AKNTRACE_FUNC_ENTER;
 	PrepareLC(aResourceId);
+	_AKNTRACE_FUNC_EXIT;
 	return(RunLD());
 }
 void CEikDialog::BaseConstructL()
 	{
+	_AKNTRACE_FUNC_ENTER;
 CreateWindowL();
 	Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));
 	EnableDragEvents();
 	Window().SetPointerGrab(ETrue);
 iContext=this;
 	iButtonCommandObserver=CEikDialogButtonCommandObserver::NewL(*this);
 if (!iExtension)
 {
 	    iExtension = CEikDialogExtension::NewL( *this ) ;
 }
+_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::StaticConstructL(TInt aResourceId)
 {
+	_AKNTRACE_FUNC_ENTER;
+AknItemActionMenuRegister::SetConstructingMenuBarOwnerL( this );
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
 ConstructFromResourceL(reader);
 	CleanupStack::PopAndDestroy();
 {
 Window().SetBackgroundColor(~0);
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * 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
 void CEikDialog::CommonConstructSleepingDialogL(TInt aResourceId)
 	//
 	// code common to both ConstructSleepingDialogL & ConstructSleepingAlertDialogL
 	//
 	{
+	_AKNTRACE_FUNC_ENTER;
 	iDialogFlags|=EEikDialogFlagSleeping;
 	BaseConstructL();
 	StaticConstructL(aResourceId);
 	MakeVisible(EFalse);
 	if (iButtonGroupContainer)
 		{
 		// non visible CBA's do not recieve keys
 		iButtonGroupContainer->MakeVisible(EFalse);
 		}
+_AKNTRACE_FUNC_EXIT;
 	}
 TInt CEikDialog::WaitAsRequired()
 {
+	_AKNTRACE_FUNC_ENTER;
 TInt exitConfirmed=0;
 #if defined (__DEBUG__)
 	RDebug::ProfileEnd(PROFILE_POINT_EIKON_DIALOG_LOAD);
 	TProfile profile;
 	RDebug::ProfileResult(&profile,PROFILE_POINT_EIKON_DIALOG_LOAD,1);
 if (iDialogFlags&EEikDialogFlagWait)
 {
 		iExitConfirmed=(&exitConfirmed);
 iWait.Start();
 }
+_AKNTRACE_FUNC_EXIT;
 	return(exitConfirmed);
 }
 void CEikDialog::StopWaitingAsRequired()
 	{
 * 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
+	_AKNTRACE_FUNC_ENTER;
 	if (IsVisible())
 		ExitSleepingDialog(); // eg for rousing an already roused Alert dialog
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 			static_cast<CEikCba*>(cba)->SetSkinBackgroundId( KAknsIIDQsnBgAreaControlPopup );
 			cba->MakeVisible(ETrue);
 			cba->DrawNow();
 			}
 		}
+	_AKNTRACE_FUNC_EXIT;
 return(WaitAsRequired());
 	}
 /**
 * Exits a sleeping dialog without deleteing it.
 */
 EXPORT_C void CEikDialog::ExitSleepingDialog()
 	{
+	_AKNTRACE_FUNC_ENTER;
 	FadeBehindPopup(EFalse);
 EnableContentObserver( EFalse );
 	if(GfxTransEffect::IsRegistered(this) && IsVisible()
 {
 	    iExtension->iSleepDialogExitBeginCalled = EFalse;
 	    }
 #endif
 CancelMediatorCommand(this);
+	_AKNTRACE_FUNC_EXIT;
 	}
 /**
 * Returns the id of the control in the line with focus.
 */
 /**
 * Constructs the dialog from resources using the resource reader aReader.
 */
 EXPORT_C void CEikDialog::ConstructFromResourceL(TResourceReader& aReader)
 {
+	_AKNTRACE_FUNC_ENTER;
 iDialogFlags |=aReader.ReadInt32();
 #ifdef RD_SCALABLE_UI_V2
 if ( AknLayoutUtils::PenEnabled() )
 {
 		}
 	else
 		ASSERT(aReader.ReadInt16()==0);
 	SetBorderStyle();  // Moved to the end of construction to allow access to individual lines.
+	_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::SetBorderStyle()
 	{
 	if (!((iDialogFlags&EEikDialogFlagFillAppClientRect) ||
 		}
 	}
 void CEikDialog::CreatePageSelectorL()
 	{
+	_AKNTRACE_FUNC_ENTER;
 	iPageSelector=CEikDialogPageSelector::NewL(*this,this);
 	iPageSelector->SetObserver(this);
 	RegisterDialgWithPageSelector(); // Added JIn
+	_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::CreatePageSelectorL(TInt aResourceId)
 	{
+	_AKNTRACE_FUNC_ENTER;
 	if (aResourceId)
 		{
 		TResourceReader reader;
 		iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
 		iPageSelector=CEikDialogPageSelector::NewL(*this,reader,this);
 		CleanupStack::PopAndDestroy();
 		if (iDialogFlags&EEikDialogFlagDensePacking)
 			iPageSelector->SetAllPagesDensePacked(ETrue);
 		RegisterDialgWithPageSelector(); // Added JIn
 		}
+	_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::CreateButtonGroupContainerL(TInt aResourceId)
 	{
 	// Avkon simplification: Always use CBA; always set buttons
 // Flags:
 // buttons are keen on drawing even if not actually visible yet,
 	// don't activate them in case of sleeping dialog
 // yet so extra drawings are suppressed until dialog is really
 	// roused to screen
+	_AKNTRACE_FUNC_ENTER;
 TUint flags = ( iDialogFlags & EEikDialogFlagSleeping ) ?
 ( CEikButtonGroupContainer::EAddToStack |
 CEikButtonGroupContainer::EDelayActivation ) :
 CEikButtonGroupContainer::EAddToStack;
 CEikButtonGroupContainer::ECba,
 CEikButtonGroupContainer::EHorizontal,
 iButtonCommandObserver, aResourceId, *this, flags );
 EnableContentObserver( ETrue );
+if ( Extension() )
+{
+Extension()->iButtonGroupResourceId = aResourceId;
+}
 	AknGlobalPopupPriorityController::AddSubPopupL(*this, *iButtonGroupContainer->ButtonGroup()->AsControl());
 	AknGlobalPopupPriorityController::AddPopupToControlStackL(*iButtonGroupContainer->ButtonGroup()->AsControl(), ECoeStackPriorityCba, ECoeStackFlagRefusesFocus);
+	_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::CreateTitleBarL()
 	{
 	iTitleBar=new(ELeave) CEikMover;
 * The parameter is ignored if the FlagFillAppClientRect is set.
 * Otherwise it it centred and given the size asked for
 */
 EXPORT_C void CEikDialog::SetSizeAndPosition(const TSize& aSize)
 {
+	_AKNTRACE_FUNC_ENTER;
 	if (iDialogFlags&EEikDialogFlagFillAppClientRect)
 	    {
+TRect destRect = iEikonEnv->EikAppUi()->ClientRect();
+// if this is a view app then ask client rect from the currently active view
+TVwsViewId uid;
+if ( iAvkonAppUi->GetActiveViewId( uid ) == KErrNone )
+{
+if ( uid.iAppUid != uid.iViewUid )
+{
+CAknView* view = iAvkonViewAppUi->View( uid.iViewUid );
+if ( view )
+{
+destRect = view->ClientRect();
+}
+}
+}
+if ( !Layout_Meta_Data::IsLandscapeOrientation() && iButtonGroupContainer != NULL )
+{
+TRect controlPane;
+AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EControlPane, controlPane );
+if ( destRect.iBr.iY > controlPane.iTl.iY )
+{
+destRect.iBr.iY = controlPane.iTl.iY;
+}
+}
+SetRect( destRect );
+}
+	else
+{
+SetRect( TRect( AknPopupUtils::Position( aSize, this ), aSize ) );
+}
+	_AKNTRACE_FUNC_EXIT;
+}
+/**
+* Returns the border style for this dialog.
+*/
+EXPORT_C TInt CEikDialog::BorderStyle()
+	{
+#ifndef RD_NO_DIALOG_BORDERS
+	return AknBorderId::EAknBorderNotePopup;
+#else
+return TGulBorder::ENone;
+#endif
+	}
+/**
+* Returns the minimum size of the area that the contents of the dialog should occupy.
+*/
+EXPORT_C TSize CEikDialog::MinimumSize()
+{
+	_AKNTRACE_FUNC_ENTER;
+	if (iDialogFlags&EEikDialogFlagFillScreen)
+{
+TAknWindowLineLayout windowLineLayoutScreen = AknLayoutScalable_Avkon::Screen().LayoutLine();
+TRect rectZero = TRect(0,0,0,0);
+TAknLayoutRect layoutRect;
+layoutRect.LayoutRect( rectZero, windowLineLayoutScreen );
+TRect rectScreen( layoutRect.Rect() );
+		return rectScreen.Size();
+}
+	else if (iDialogFlags&EEikDialogFlagFillAppClientRect)
+{
 // if this is a view app then ask client rect from the currently active view
 TVwsViewId uid;
 if ( iAvkonAppUi->GetActiveViewId( uid ) == KErrNone )
 {
 if ( uid.iAppUid != uid.iViewUid )
 else
 {
 SetRect(iEikonEnv->EikAppUi()->ClientRect());
 }
 }
 else
 {
 SetRect( iEikonEnv->EikAppUi()->ClientRect() );
 }
-	    }
-	else
-{
-SetRect( TRect( AknPopupUtils::Position( aSize, this ), aSize ) );
-}
-}
-/**
-* Returns the border style for this dialog.
-*/
-EXPORT_C TInt CEikDialog::BorderStyle()
-	{
-#ifndef RD_NO_DIALOG_BORDERS
-	return AknBorderId::EAknBorderNotePopup;
-#else
-return TGulBorder::ENone;
-#endif
-	}
-/**
-* Returns the minimum size of the area that the contents of the dialog should occupy.
-*/
-EXPORT_C TSize CEikDialog::MinimumSize()
-{
-	if (iDialogFlags&EEikDialogFlagFillScreen)
-{
-TAknWindowLineLayout windowLineLayoutScreen = AknLayoutScalable_Avkon::Screen().LayoutLine();
-TRect rectZero = TRect(0,0,0,0);
-TAknLayoutRect layoutRect;
-layoutRect.LayoutRect( rectZero, windowLineLayoutScreen );
-TRect rectScreen( layoutRect.Rect() );
-		return rectScreen.Size();
-}
-	else if (iDialogFlags&EEikDialogFlagFillAppClientRect)
-{
-// if this is a view app then ask client rect from the currently active view
-TVwsViewId uid;
-if ( iAvkonAppUi->GetActiveViewId( uid ) == KErrNone )
-{
-if ( uid.iAppUid != uid.iViewUid )
-{
-CAknView* view = iAvkonViewAppUi->View(uid.iViewUid);
-if (view)
-{
-SetRect(view->ClientRect());
-}
-else
-{
-SetRect(iEikonEnv->EikAppUi()->ClientRect());
-}
-}
-else
-{
-SetRect(iEikonEnv->EikAppUi()->ClientRect());
-}
-}
-else
-{
-SetRect( iEikonEnv->EikAppUi()->ClientRect() );
-}
 }
 	TSize pageSelectorSize(iPageSelector->MinimumSize());
+	_AKNTRACE_FUNC_EXIT;
 	return pageSelectorSize;
 }
 /**
 * Returns the preferred size of the dialog given that it must fit in a maximum size of aMaxSize.
 *
 * @since ER5U
 */
 EXPORT_C TSize CEikDialog::PreferredSize(const TSize& aMaxSize) const
 	{
+_AKNTRACE_FUNC_ENTER;
 	if (iDialogFlags&EEikDialogFlagFillScreen)
 		return iEikonEnv->ScreenDevice()->SizeInPixels();
 	else if (iDialogFlags&EEikDialogFlagFillAppClientRect)
 	    {
 if ( uid.iAppUid != uid.iViewUid )
 {
 CAknView* view = iAvkonViewAppUi->View(uid.iViewUid);
 if (view)
 {
+_AKNTRACE_FUNC_EXIT;
 return view->ClientRect().Size();
 }
 else
 {
+_AKNTRACE_FUNC_EXIT;
 return iEikonEnv->EikAppUi()->ClientRect().Size();
 }
 }
 else
 {
+_AKNTRACE_FUNC_EXIT;
 return iEikonEnv->EikAppUi()->ClientRect().Size();
 }
 }
 else
 {
+_AKNTRACE_FUNC_EXIT;
 return iEikonEnv->EikAppUi()->ClientRect().Size();
 }
 	    }
 preferredSize += TSize( 0, cbaRect.Rect().Height() );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 	return preferredSize;
 	}
 /**
 * Lays out the dialog's components when the size of the dialog is changed.
 * For Avkon, the DPSEL always stays the same size as the CEikDialog minus an optional title
 * bar.
 */
 EXPORT_C void CEikDialog::SizeChanged()
 {
+	_AKNTRACE_FUNC_ENTER;
 	__ASSERT_DEBUG( iButtonGroupContainer->Location() == CEikButtonGroupContainer::EExternal,
 		Panic( EEikDialogPanicIllegalOption ) );
 	TInt excludeCbaHeight = -1;
 {
 // Otherway softkeys are located out of dialog rect
 cba->SetRect( TRect(0, 0, 0, 0 ) );
 }
 }
-		}
+if ( Extension() )
+{
+Extension()->iDeleteEmbeddedCba = EFalse;
+}
+}
 	if (iTitleBar)
 		{
 		TRect nullRect(0,0,0,0);
 		iTitleBar->SetRect( nullRect );
 		}
 		currentPage->SetFormFlag( CEikDialogPage::EFormResizeOptimisationFlag,  EFalse ) ;
 	// <SKIN>
 	iExtension->iBgContext->SetParentPos( PositionRelativeToScreen() ) ;
 	iExtension->iBgContext->SetRect( Rect() ) ;
+	_AKNTRACE_FUNC_EXIT;
 	}
 /**
 * Sets the title text for the dialog to aText.
 */
 * Makes the dialog line containing the control identified by aControlId visible, i.e. sets it
 * to draw itself, if aVisible is ETrue.
 */
 EXPORT_C void CEikDialog::MakeLineVisible(TInt aControlId,TBool aVisible)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikCaptionedControl* line=Line(aControlId);
 	CCoeControl* control=line->iControl;
 	if (control->IsVisible()==aVisible)
 		return;
 control->MakeVisible(aVisible);
 line->CheckDimmedDisplayState();
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Makes the whole dialog line containing the control identified by aControlId visible, i.e. sets it
 * to draw itself, if aVisible is ETrue.
 */
 EXPORT_C void CEikDialog::MakeWholeLineVisible(TInt aControlId,TBool aVisible)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikCaptionedControl* line=Line(aControlId);
 	if (line->IsVisible()==aVisible)
 		return;
 	CCoeControl* control=line->iControl;
 if (line->iCaption)
 		line->iCaption->MakeVisible(aVisible);
 	if (line->iTrailer)
 		line->iTrailer->MakeVisible(aVisible);
 control->MakeVisible(aVisible);
 	line->MakeVisible(aVisible);
+	_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Lays out the dialog, setting it to take its preferred size and position
 * for the screen.
 *
 * @since ER5U
 */
 EXPORT_C void CEikDialog::Layout()
 	{
+_AKNTRACE_FUNC_ENTER;
 TAknWindowLineLayout windowLineLayoutScreen = AknLayoutScalable_Avkon::Screen().LayoutLine();
 TRect rectZero = TRect(0,0,0,0);
 TAknLayoutRect layoutRect;
 layoutRect.LayoutRect( rectZero, windowLineLayoutScreen );
 TRect rectScreen( layoutRect.Rect() );
 	TSize maxSize = rectScreen.Size();
+_AKNTRACE( "size = %d x %d", iSize.iWidth, iSize.iHeight );
 	SetSizeAndPosition(PreferredSize( maxSize ));
+_AKNTRACE( "size = %d x %d", iSize.iWidth, iSize.iHeight );
+_AKNTRACE_FUNC_EXIT;
 	}
 /**
 * Deletes the dialog line with the control identified by aControlId.
 */
 	{
 	CEikCaptionedControl* line=Line(aControlId);
 	if (line)
 		{
 		line->SetCaptionL(aText);
-		line->DrawNow();
+		line->DrawDeferred();
 		}
 	}
 /**
 * Sets the caption of the control identified by aControlId by reading the caption
 *
 * @since ER5U
 */
 EXPORT_C void CEikDialog::SetEditableL( TBool aEditable )
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "CEikDialog::SetEditableL()  aEditable: [%d]", aEditable );
 if ( !iExtension->iFlags[CEikDialogExtension::EEditableStateInitialised] ||
 iIsEditable != aEditable )
 {
 iExtension->iFlags.Set(CEikDialogExtension::EEditableStateInitialised);
 iIsEditable = aEditable ;
 // tell each of the pages on the dialog about the editable state...
 iPageSelector->SetEditableL( aEditable );
 DrawNow();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Returns the Editable state.  This exists to support forms
 *
 * @since ER5U
 */
 EXPORT_C TBool CEikDialog::IsEditable() const
 	{
+	_AKNTRACE( "CEikDialog::IsEditable(): [%d]", iIsEditable );;
 	return ( iIsEditable ) ;
 	}
 /**
 * Returns the line index of the control aControl or KErrNotFound if the control
 * Runs the dialog and returns the id of the button used to dismiss it.
 * The dialog is destroyed on exit.
 */
 EXPORT_C TInt CEikDialog::RunLD()
 	{
+	_AKNTRACE_FUNC_ENTER;
 // Moved BringForwards in the beginning to enable 1-frame animations.
 	iEikonEnv->BringForwards(ETrue); // before call to EnableBackup()
 	AknGlobalPopupPriorityController::ShowPopup(*this, ETrue);
 	iDialogFlags|=EEikDialogFlagBroughtForward;
 		CAknTransitionUtils::SetAllParents(this);
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 		GfxTransEffect::NotifyExternalState(EInternalHandleSequence, (const TDesC8*)this);
 #endif
 		GfxTransEffect::Begin(this, KGfxControlAppearAction);
+MTouchFeedback* feedback = NULL;
+if( AknLayoutUtils::PenEnabled() )
+{
+feedback = static_cast<MTouchFeedback*>( ExtensionInterface( KExIfTactileFeedbackUid ) );
+}
+if( feedback )
+{
+if( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
+{
+feedback->InstantFeedback( this, ETouchFeedbackIncreasingPopUp,
+ETouchFeedbackVibra, TPointerEvent() );
+}
+else
+{
+feedback->InstantFeedback( this, ETouchFeedbackPopUp,
+ETouchFeedbackVibra, TPointerEvent() );
+}
+}
 		GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);
 		TRect demarcation;
 		CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, demarcation);
 		GfxTransEffect::SetDemarcation(this, demarcation);
 }
 	// Claim pointer grab and send the pointer up event to the
 	// control that otherwise would be receiving the drag events.
 	Window().ClaimPointerGrab(ETrue);
+	_AKNTRACE_FUNC_EXIT;
 return(WaitAsRequired());
 	}
 EXPORT_C void CEikDialog::Draw(const TRect& /*aRect*/) const
 {
+	_AKNTRACE_FUNC_ENTER;
 TRect rect=Rect();
 CWindowGc& gc=SystemGc(); //No reason to demote the gc, CWindowGc is more usable.
 if ( iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout )
 {
 {
 AknsDrawUtils::DrawFrame( skin, gc, outerRect, innerRect,
 KAknsIIDQsnFrPopup,KAknsIIDQsnFrPopupCenter);
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C void CEikDialog::HandlePointerEventL(const TPointerEvent& aPointerEvent)
 {
 CEikBorderedControl::HandlePointerEventL(aPointerEvent);
 return NULL;
 }
 TKeyResponse CEikDialog::TryAnimateButtonAndExitL(TInt aKeycode)
 	{
+	_AKNTRACE_FUNC_ENTER;
 	TInt buttonId=EEikBidCancel;
 	switch (aKeycode)
 		{
 	case EKeyEnter:
 	case EKeyOK:
 	CEikButtonGroupContainer& buttonGroupContainer = ButtonGroupContainer();
 	CCoeControl* button = buttonGroupContainer.ControlOrNull(buttonId);
 	if (button)
 		{
-		if (button->IsDimmed() || !button->IsVisible())
+TBool animateCommand = ( !button->IsDimmed() && button->IsVisible() );
-			return EKeyWasNotConsumed;
-		buttonGroupContainer.AnimateCommand(buttonId);
+if ( !animateCommand && buttonId != EEikBidCancel )
+{
+			_AKNTRACE_FUNC_EXIT;
+return EKeyWasNotConsumed;
+}
+else if ( animateCommand )
+{
+buttonGroupContainer.AnimateCommand( buttonId );
+}
 		}
 	if (button || buttonId==EEikBidCancel || buttonId==EEikBidOk)
 		{
 		TryExitL(buttonId);
+		_AKNTRACE_FUNC_EXIT;
 		return EKeyWasConsumed;
 		}
+	_AKNTRACE_FUNC_EXIT;
 	return EKeyWasNotConsumed;
 	}
 /**
 * Prepares for a transistion in focus in the dialog. By default, calls the currently
 * Handles the key event aKeyEvent with code aType. Returns EKeyWasConsumed if the control
 * takes action on the key event or EKeyWasNotConsumed otherwise.
 */
 EXPORT_C TKeyResponse CEikDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
 {
+	_AKNTRACE_FUNC_ENTER;
 	// Hide the tool tip (if there is one!)
 	if ( ( iPageSelector->NumPages() == 1 ) && ( CurrentLine() ) && ( CurrentLine()->ToolTipText( ) ) )
 		{
 		switch ( aKeyEvent.iScanCode )
 			}
 		}
 if (!(iDialogFlags&EEikDialogFlagDontEatUpDownEvents) && aKeyEvent.iScanCode != EStdKeyYes)
 	{
 	if (aType!=EEventKey)
-	    return(EKeyWasConsumed);
+		{
+		_AKNTRACE_FUNC_EXIT;
+	    return(EKeyWasConsumed);
+		}
 	}
 	TInt code=aKeyEvent.iCode;
 	const TUint modifiers = aKeyEvent.iModifiers;
 	TKeyResponse response;
 	if (iDialogFlags&EEikDialogFlagAllKeysToButtons || ((modifiers & EAllStdModifiers) == EModifierCtrl) )
 		{
 		response = iButtonGroupContainer->OfferKeyEventL(aKeyEvent,aType);
 		if(response==EKeyWasConsumed)
-			return EKeyWasConsumed;
+			{
+			_AKNTRACE_FUNC_EXIT;
+			return EKeyWasConsumed;
+			}
 		}
 	//
 switch (code)
 case EKeyEscape:
 		if (modifiers&EModifierShift)
 			iPageSelector->OfferKeyEventL(aKeyEvent, aType);
 // Add to remove repeated keypress return event of OK key
 		if (aKeyEvent.iRepeats&&EKeyOK==code)
-			return EKeyWasConsumed;
+			{
+			_AKNTRACE_FUNC_EXIT;
+			return EKeyWasConsumed;
+			}
 		if ((!(modifiers&EModifierCtrl) || modifiers&EModifierPureKeycode) &&
 			!(iDialogFlags&EEikDialogFlagModeless))
 			TryAnimateButtonAndExitL(code);
 break;
 	case EKeyTab:
 default:
 		iPageSelector->OfferKeyEventL(aKeyEvent, aType);
 		break;
 	KeyToFocus:
 		if(iPageSelector->OfferHotKeysKeyEventL(aKeyEvent,aType)==EKeyWasConsumed)
-			return EKeyWasConsumed;
+			{
+		    _AKNTRACE_FUNC_EXIT;
-		}
+			return EKeyWasConsumed;
+			}
+		}
+_AKNTRACE_FUNC_EXIT;
 	return (aKeyEvent.iScanCode == EStdKeyYes ? EKeyWasNotConsumed:EKeyWasConsumed);
 }
 /**
 * Hands focus to current dialog line.
 */
 EXPORT_C void CEikDialog::FocusChanged(TDrawNow aDrawNow)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikBorderedControl::FocusChanged( aDrawNow );
 TInt controlID = IdOfFocusControl();
 if (controlID)
 {
 Line(controlID)->SetFocus(IsFocused(), aDrawNow);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Tries to initiate user exit of the dialog when the button identified
 * by aButtonId is pressed, if this button should exit the dialog. See OkToExitL to
 * If the EEikDialogFlagNotifyEsc flag is not set and the dialog has been cancelled it
 * immediately deletes itself.
 */
 EXPORT_C void CEikDialog::TryExitL(TInt aButtonId)
 {
-if ( iDialogFlags & EEikDialogFlagNoUserExit )
+_AKNTRACE("CEikDialog::TryExitL iDialogFlags = %d, buttonId = %d", iDialogFlags, aButtonId);
-{
+if (iDialogFlags & EEikDialogFlagNoUserExit)
-		return;
+{
+return;
 }
 // use delayed exit if pointer event handling is in progress
-if ( Extension()->iPublicFlags.IsSet( CEikDialogExtension::EDelayedExit ) )
+if (Extension()->iPublicFlags.IsSet(CEikDialogExtension::EDelayedExit))
 {
 Extension()->iButtonId = aButtonId;
 Extension()->StartDelayedExit();
+_AKNTRACE("CEikDialog::TryExitL return with delayedExit");
 return;
 }
-TBool effectTriggered = EFalse;
 TBool effectButton = aButtonId == EEikBidCancel
 || aButtonId == EAknSoftkeyExit
 || aButtonId == EAknSoftkeyBack
 || aButtonId == EAknSoftkeyNo;
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 effectButton =    effectButton
-					  || aButtonId == EAknSoftkeyClose
+|| aButtonId == EAknSoftkeyClose
-|| aButtonId == EAknSoftkeyDone;
+|| aButtonId == EAknSoftkeyDone
+|| aButtonId == EAknSoftkeyOk;
 #endif
-CAknAppUi* aknAppUi = static_cast<CAknAppUi*>( iEikonEnv->EikAppUi() );
-if ( GfxTransEffect::IsRegistered( this ) && IsVisible() && effectButton
+TBool effectTriggered = EFalse;
+CAknAppUi* aknAppUi = static_cast<CAknAppUi*>(iEikonEnv->EikAppUi());
+MTouchFeedback* feedback = NULL;
+if(AknLayoutUtils::PenEnabled())
+{
+feedback = static_cast<MTouchFeedback*>(ExtensionInterface(KExIfTactileFeedbackUid));
+}
+if (!(iDialogFlags & EEikDialogFlagDelayEffects)
+&& IsFocusedWindowGroup( this )
+&& GfxTransEffect::IsRegistered(this) && IsVisible() && effectButton
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
-&& !(iDialogFlags&EEikDialogFlagSleeping)
+&& !(iDialogFlags & EEikDialogFlagSleeping)
 #endif
-&& ( !aknAppUi->IsFullScreenApp() || aknAppUi->IsForeground() )
+&& (!aknAppUi->IsFullScreenApp() || aknAppUi->IsForeground())
 && !IsBlankScreenDisplayed()
 )
 {
 CAknTransitionUtils::SetAllParents(this);
 GfxTransEffect::Begin(this, KGfxControlDisappearAction);
+if(feedback)
+{
+if(CAknTransitionUtils::TransitionsEnabled(AknTransEffect::EComponentTransitionsOff))
+{
+feedback->InstantFeedback(this, ETouchFeedbackDecreasingPopUp,
+ETouchFeedbackVibra, TPointerEvent());
+}
+else
+{
+feedback->InstantFeedback(this, ETouchFeedbackPopUp,
+ETouchFeedbackVibra, TPointerEvent());
+}
+}
 GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);
 TRect demarcation;
-CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup,
+CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, demarcation);
-demarcation);
 GfxTransEffect::SetDemarcation(this, demarcation);
 effectTriggered = ETrue;
 }
-if (aButtonId!=EEikBidCancel)
+if (aButtonId != EEikBidCancel)
+{
 PrepareForFocusTransitionL();
-else if (!(iDialogFlags&EEikDialogFlagNotifyEsc))
+}
-		goto finished;
+else if (!(iDialogFlags & EEikDialogFlagNotifyEsc))
-	if (!OkToExitL(aButtonId))
+{
-{
+goto finished;
-if ( effectTriggered )
+}
-{
-GfxTransEffect::NotifyExternalState( ECaptureComponentsAbort,
+if (!OkToExitL(aButtonId))
-( const TDesC8* ) this );
+{
-GfxTransEffect::Abort( this );
+if (effectTriggered)
-}
+{
-			return;
+GfxTransEffect::NotifyExternalState(ECaptureComponentsAbort, (const TDesC8*)this);
-}
+GfxTransEffect::Abort(this);
+}
-	if (aButtonId!=EEikBidCancel)
-		GetAutoValues();
+// Draw again in cast any content change in OkToExitL
+DrawDeferred();
+_AKNTRACE("CEikDialog::TryExitL return with OkToExitL false");
+return;
+}
+if (aButtonId != EEikBidCancel)
+{
+GetAutoValues();
+}
 finished:
 if (iExitConfirmed)
-		*iExitConfirmed=((MappedCommandId( aButtonId ) ==EEikBidCancel)? 0: aButtonId);
+{
+*iExitConfirmed = MappedCommandId(aButtonId) == EEikBidCancel ? 0 : aButtonId;
+}
 // Remove content observer in order to prevent unnecessary layout
 // calculations in dialog shutdown.
-EnableContentObserver( EFalse );
+EnableContentObserver(EFalse);
-	if (iDialogFlags&EEikDialogFlagSleeping)
+if (iDialogFlags & EEikDialogFlagSleeping)
-		ExitSleepingDialog();
+{
-	else
+ExitSleepingDialog();
-		{
+}
+else
+{
 // Remove content observer in order to prevent unnecessary layout
 // calculations in dialog shutdown.
-EnableContentObserver( EFalse );
+EnableContentObserver(EFalse);
-if ( effectTriggered )
+// The dialog is asked to postpone the effect after OkToExitL.
-						{
+if ((iDialogFlags & EEikDialogFlagDelayEffects) && !effectTriggered)
-		MakeVisible(EFalse);
+{
-CAknTransitionUtils::MakeVisibleSubComponents( this,
+if (GfxTransEffect::IsRegistered(this) && IsVisible() && effectButton
-CAknTransitionUtils::EForceInvisible );
+&& (!aknAppUi->IsFullScreenApp() || aknAppUi->IsForeground())
+&& !IsBlankScreenDisplayed()
-		GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);
+)
-		GfxTransEffect::End(this);
+{
-		}
+TRect demarcation;
-	else
+CAknTransitionUtils::SetAllParents(this);
-			    {
+GfxTransEffect::Begin(this, KGfxControlDisappearAction);
-		MakeVisible(EFalse);
-CAknTransitionUtils::MakeVisibleSubComponents( this,
+if(feedback)
-CAknTransitionUtils::EForceInvisible );
+{
-		GfxTransEffect::NotifyExternalState( ECaptureComponentsAbort,
+if(CAknTransitionUtils::TransitionsEnabled(AknTransEffect::EComponentTransitionsOff))
-( const TDesC8* ) this );
+{
-		    	GfxTransEffect::Abort(this);
+feedback->InstantFeedback(this, ETouchFeedbackDecreasingPopUp,
-			}
+ETouchFeedbackVibra, TPointerEvent());
-	    delete(this);
+}
-		}
+else
+{
+feedback->InstantFeedback(this, ETouchFeedbackPopUp,
+ETouchFeedbackVibra , TPointerEvent());
+}
+}
+GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);
+CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, demarcation);
+GfxTransEffect::SetDemarcation(this, demarcation);
+effectTriggered = ETrue;
+}
+}
+if (effectTriggered)
+{
+MakeVisible(EFalse);
+CAknTransitionUtils::MakeVisibleSubComponents(this, CAknTransitionUtils::EForceInvisible);
+GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);
+GfxTransEffect::End(this);
+}
+else
+{
+// Why we need abort the effect here ??
+MakeVisible(EFalse);
+CAknTransitionUtils::MakeVisibleSubComponents(this, CAknTransitionUtils::EForceInvisible);
+GfxTransEffect::NotifyExternalState(ECaptureComponentsAbort, (const TDesC8*)this);
+GfxTransEffect::Abort(this);
+}
+delete(this);
+}
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Returns the input capabilites of the dialog. By default, the dialog is
 * capable of handling all text input.
 * dialog by default. Reimplementations of this method must
 * activate a page before doing anything else.
 */
 EXPORT_C void CEikDialog::SetInitialCurrentLine()
 {
+	_AKNTRACE_FUNC_ENTER;
 	if ( !iExtension->iInitialMade )
 	    {
 	    TRAP_IGNORE(iPageSelector->ActivateFirstPageL());
 	    }
 	if( !iIsEditable )
 	    {
 	    iPageSelector->SetInitialFocus();
 	    }
+	_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Handles a dialog button press for the button with id aButtonId.
 * The cancel button press is not passed to the handler unless EEikDialogFlagNotifyEsc
 *
 * @since ER5U
 */
 EXPORT_C void CEikDialog::HandleResourceChange(TInt aType)
 {
+	_AKNTRACE_FUNC_ENTER;
 if(aType==KEikDynamicLayoutVariantSwitch)
 {
 if (IsVisible())
 			DoResourceChangeLayout();
 else if (iExtension)
 	iExtension->iFlags.Set(CEikDialogExtension::ELayoutChangeWhileInvisible);
-CCoeControl::HandleResourceChange(aType);
+TBool isForm = ( iPageSelector && iPageSelector->IsForm() );
+if ( !isForm )
+{
+CCoeControl::HandleResourceChange( aType );
+}
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 else
 	{
 	CCoeControl::HandleResourceChange(aType);
 }
-if( !CAknEnv::Static()->TransparencyEnabled() && aType==KEikColorResourceChange)
+_AKNTRACE_FUNC_EXIT;
-{
-Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));
-}
 }
 void CEikDialog::DoResourceChangeLayout()
 	{
 // Layout must be forced through - bypass optimisations
 // Must work through all pages
+	_AKNTRACE_FUNC_ENTER;
+Layout();
-Layout();
+TBool isForm = ( iPageSelector && iPageSelector->IsForm() );
-SizeChanged();
-TInt lastPage =  ( iPageSelector->PageContainer()->NumPages() - 1 );
+if ( !isForm )
-TInt pageIndex = 0;
+{
-CEikDialogPage* page;
+SizeChanged();
+		}
-while ( pageIndex++ <= lastPage )
-{
+if( iPageSelector )
-page = iPageSelector->PageContainer()->Page( pageIndex );
+	{
-page->HandleResourceChange( KEikDynamicLayoutVariantSwitch );
+		TInt lastPage =  ( iPageSelector->PageContainer()->NumPages() - 1 );
+		TInt pageIndex = 0;
+		CEikDialogPage* page( NULL );
+		while ( pageIndex++ <= lastPage )
+			{
+			page = iPageSelector->PageContainer()->Page( pageIndex );
+			page->HandleResourceChange( KEikDynamicLayoutVariantSwitch );
+			}
 }
 	if (iExtension)
 		iExtension->iFlags.Clear(CEikDialogExtension::ELayoutChangeWhileInvisible);
+	_AKNTRACE_FUNC_EXIT;
 	}
 /**
 * Returns a pointer to the dialog's internal button command observer. This is required when creating a
 * new button group container for the dialog.
 EXPORT_C void CEikDialog::CEikDialog_Reserved_2()
 	{}
 EXPORT_C void CEikDialog::MakeVisible(TBool aVisible)
 	{
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "CEikDialog::MakeVisible(): [%d]", aVisible );
 	if (iExtension && iExtension->iFlags[CEikDialogExtension::ELayoutChangeWhileInvisible])
 		DoResourceChangeLayout();
 	// only for popup dialogs
 	if ( aVisible )
 AknGlobalPopupPriorityController::FadeBehindPopup(*this, iPopupFader, *this, aVisible);
 	    }
 }
 	CEikBorderedControl::MakeVisible(aVisible);
+	_AKNTRACE_FUNC_EXIT;
 	}
 void CEikDialog::FadeBehindPopup(TBool aFade)
 	{
 	// record the requested fade state
 	CEikCaptionedControl* control = NULL;
 	do
 		{
 		control = dlgPage->LineOnPageOrNull(i++);
 		if (control)
-			aControls.Append(control);
+			{
-		}
+			if ( KErrNone != aControls.Append(control) )
-		while (control != NULL);
+				{
+				return;
+				}
+			}
+		}
+	while (control != NULL);
 	}
 EXPORT_C TInt CEikDialog::DialogFlags()
 	{
 	return iDialogFlags;
 		}
 	}
 EXPORT_C void CEikDialog::UpdatePageL(TBool aRedraw)
 	{
+	_AKNTRACE_FUNC_ENTER;
 	if (Rect().Height())
 		{
 		if (iPageSelector)
 			if (iPageSelector->IsForm())
 				if (iPageSelector->PageContainer())
 						TryChangeFocusToL(CurrentLine()->iId);
 					if (aRedraw)
 						DrawDeferred();
 					}
 		}
+	_AKNTRACE_FUNC_EXIT;
 	}
 EXPORT_C TInt CEikDialog::GetNumberOfLinesOnPage(TInt aPageIndex) const
 	{
+	_AKNTRACE_FUNC_ENTER;
 	if (iPageSelector)
 		{
 		CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
 		if (pageContainer)
 			{
 			CEikDialogPage* page = pageContainer->Page(aPageIndex);
 			if (page)
-				return page->NumberOfLines();
+				{
+				_AKNTRACE( "CEikDialog::GetNumberOfLinesOnPage(): [%d]", page->NumberOfLines() );
+				_AKNTRACE_FUNC_EXIT;
+				return page->NumberOfLines();
+				}
 			}
 		}
+	_AKNTRACE( "CEikDialog::GetNumberOfLinesOnPage(): 0");
+	_AKNTRACE_FUNC_EXIT;
 	return 0;
 	}
 EXPORT_C TInt CEikDialog::GetNumberOfPages() const
 	{
+	_AKNTRACE_FUNC_ENTER;
 	if (iPageSelector)
 		{
 		CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
 		if (pageContainer)
-			return pageContainer->NumPages();
+			{
-		}
+		    _AKNTRACE( "CEikDialog::GetNumberOfPages(): [%d]", pageContainer->NumPages() );
+		    _AKNTRACE_FUNC_EXIT;
+		    return pageContainer->NumPages();
+			}
+		}
+	_AKNTRACE( "CEikDialog::GetNumberOfPages(): return 0;" );
+	_AKNTRACE_FUNC_EXIT;
 	return 0;
 }
 //--------------------------------------------------------------------------------
 // CEikDialog::HandleDialogPageEventL(TInt aEventID)
 {
 // Check that dialog is constructed and actually with embedded
 // softkeys
 if ( iExtension && CbaEmbeddedInDialog( iDialogFlags ) )
 {
-TSize dialogSize( Rect().Size() );
+TRect oldDialogRect( Rect() );
+TSize dialogSize( oldDialogRect.Size() );
 CEikCba* cba = static_cast<CEikCba*>(
 iButtonGroupContainer->ButtonGroup() );
 TBool cbaVisible( cba->IsVisible() && !cba->IsEmpty() );
 TRect screenRect;
 else
 {
 dialogSize.iHeight -= cbaRect.Rect().Height();
 }
-SetRect( TRect(
+TRect newDialogRect( AknPopupUtils::Position( dialogSize, cbaVisible ),
-AknPopupUtils::Position( dialogSize, this ), dialogSize ) );
+dialogSize );
+SetRect( newDialogRect );
+if ( oldDialogRect != newDialogRect )
+{
+DrawDeferred();
+}
 }
 }
 TInt CEikDialog::HandleEmbeddedSoftkeyStateChangeCallBack( TAny* aAny )
 // Checking if the blank screen is being displayed.
 // If so, the blank screen will cover everything.
 const TInt KWgPriorityOfBlankScreen = 10000; // copied from akncapserverentry.cpp
 TBool IsBlankScreenDisplayed()
 {
+	_AKNTRACE_FUNC_ENTER;
 TBool isBlankScreenDisplayed(EFalse);
 RWsSession& wsSession = CEikonEnv::Static()->WsSession();
 CArrayFixFlat<TInt> *wgIds = new CArrayFixFlat<TInt>(2);
 if (wgIds != NULL)
 {
 if (KErrNone == wsSession.WindowGroupList(wgIds) && wgIds->Count() > 0)
 {
 TInt priority = wsSession.GetWindowGroupOrdinalPriority(wgIds->At(0));
-RDebug::Printf("IsBlankScreenDisplayed():priority:%d",priority);
+_AKNTRACE( "IsBlankScreenDisplayed():priority: [%d]", priority );
 if (priority == KWgPriorityOfBlankScreen)
 {
 isBlankScreenDisplayed = ETrue;
 }
 }
 }
 delete wgIds;
-RDebug::Printf("IsBlankScreenDisplayed():isBlankScreenDisplayed:%d",isBlankScreenDisplayed);
+_AKNTRACE( "IsBlankScreenDisplayed():isBlankScreenDisplayed: [%d]", isBlankScreenDisplayed );
+_AKNTRACE_FUNC_EXIT;
 return isBlankScreenDisplayed;
 }

branch	RCL_3
changeset 56	d48ab3b357f1
parent 55	aecbbf00d063
child 59	978afdc0236f