--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/EikStd/dlgsrc/EIKDIALG.CPP Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,3146 @@
+/*
+* 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 )
+ {
+ return AknLayoutUtils::PenEnabled() &&
+ !( aFlags & EEikDialogFlagFillAppClientRect ) &&
+ !( aFlags & EEikDialogFlagFillScreen ) &&
+ !( aFlags & EEikDialogFlagVirtualInput );
+ }
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+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);
+ }
+
+ if (iButtonGroupContainer)
+ {
+ if (iButtonGroupContainer->Location() == CEikButtonGroupContainer::EExternal)
+ {
+ // Bring CBA to foreground and make visible
+ // CBA used to be set to high control stack priority here,
+ // but that resulted in bugs whereby a sleeping dialog which was behind another dialog
+ // always had a higher CBA - just make sure they have the highest cba priority
+ CCoeControl* cba = iButtonGroupContainer->ButtonGroup()->AsControl();
+ AknGlobalPopupPriorityController::AddPopupToControlStackL(*cba,ECoeStackPriorityCba,ECoeStackFlagRefusesFocus);
+ static_cast<CEikCba*>(cba)->SetSkinBackgroundId( KAknsIIDQsnBgAreaControlPopup );
+ cba->MakeVisible(ETrue);
+ cba->DrawNow();
+ }
+ }
+
+ return(WaitAsRequired());
+ }
+
+/**
+ * Exits a sleeping dialog without deleteing it.
+ */
+EXPORT_C void CEikDialog::ExitSleepingDialog()
+ {
+ FadeBehindPopup(EFalse);
+
+ EnableContentObserver( EFalse );
+
+ if(GfxTransEffect::IsRegistered(this) && IsVisible()
+
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ && !iExtension->iSleepDialogExitBeginCalled
+#endif
+ && IsFocusedWindowGroup( this )
+ && !IsBlankScreenDisplayed()
+ )
+ {
+ CAknTransitionUtils::SetAllParents(this);
+ GfxTransEffect::Begin(this, KGfxControlDisappearAction);
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ iExtension->iSleepDialogExitBeginCalled = ETrue;
+#endif
+ GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);
+
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ TUid t;
+ GfxTransEffect::NotifyExternalState(EGetRegistrationType, (const TDesC8*)&t);
+ iExtension->iRegisteredContext = t;
+#endif
+
+ TRect demarcation;
+ CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup,
+ demarcation);
+ GfxTransEffect::SetDemarcation(this, demarcation);
+
+ MakeVisible(EFalse);
+ CAknTransitionUtils::MakeVisibleSubComponents( this,
+ CAknTransitionUtils::EForceInvisible );
+
+ GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);
+ GfxTransEffect::End(this);
+ }
+ else
+ {
+ MakeVisible(EFalse);
+ }
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ GfxTransEffect::Deregister( this );
+#endif
+
+ if (iButtonGroupContainer)
+ {
+ iButtonGroupContainer->MakeVisible(EFalse);
+ }
+ AknGlobalPopupPriorityController::RouseSleepingPopup(*this,EFalse);
+ if (iDialogFlags&EEikDialogFlagBroughtForward)
+ {
+ iEikonEnv->BringForwards(EFalse);
+ AknGlobalPopupPriorityController::ShowPopup(*this, EFalse);
+ iDialogFlags&=(~EEikDialogFlagBroughtForward);
+ }
+ StopWaitingAsRequired();
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ if( iExtension )
+ {
+ iExtension->iSleepDialogExitBeginCalled = EFalse;
+ }
+#endif
+ CancelMediatorCommand(this);
+ }
+
+/**
+ * Returns the id of the control in the line with focus.
+ */
+EXPORT_C TInt CEikDialog::IdOfFocusControl() const
+ {
+ return iPageSelector->FocusedLineId();
+ }
+
+/**
+ * Recalculates the minimum sizes of the lines on the active page.
+ */
+EXPORT_C void CEikDialog::ResetLineMinimumSizes()
+ {
+ iPageSelector->ResetLineMinimumSizes(); // !! what about MP dialogs?
+ }
+
+/**
+ * Constructs the dialog from resources using the resource reader aReader.
+ */
+EXPORT_C void CEikDialog::ConstructFromResourceL(TResourceReader& aReader)
+ {
+ iDialogFlags |=aReader.ReadInt32();
+
+#ifdef RD_SCALABLE_UI_V2
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ if ( iDialogFlags & EEikDialogFlagVirtualInput )
+ {
+ Extension()->iPublicFlags.Set( CEikDialogExtension::EUseVirtualInput );
+ }
+ }
+#endif
+
+ CreateTitleBarL();
+ iTitleBar->ConstructFromResourceL(aReader);
+ TInt PageSelectorResourceId=aReader.ReadInt32();
+ TInt ButtonGroupContainerResourceId=aReader.ReadInt32();
+ CreateButtonGroupContainerL(ButtonGroupContainerResourceId);
+ CreatePageSelectorL(PageSelectorResourceId);
+ if (!iPageSelector)
+ {
+ CreatePageSelectorL();
+ iPageSelector->AddPageL(0,KNullDesC,aReader);
+ if (iDialogFlags&EEikDialogFlagDensePacking)
+ iPageSelector->SetAllPagesDensePacked(ETrue);
+ }
+ else
+ ASSERT(aReader.ReadInt16()==0);
+
+ SetBorderStyle(); // Moved to the end of construction to allow access to individual lines.
+ }
+
+void CEikDialog::SetBorderStyle()
+ {
+ if (!((iDialogFlags&EEikDialogFlagFillAppClientRect) ||
+ (iDialogFlags&EEikDialogFlagFillScreen) ))
+ {
+ // One additional check... (if NoBorder requested then no action to default to no border (see constructor))
+ if ( !( iDialogFlags & EEikDialogFlagNoBorder ) )
+ iBorder=TGulBorder(BorderStyle()); // AKNLAF TGulBorder::EThickDeepRaisedWithOutline
+ // SERIES60 specific request: If no border and no shadow then position the controls without spacing.
+ if ( (iDialogFlags & EEikDialogFlagNoBorder) && (iDialogFlags & EEikDialogFlagNoShadow) )
+ {
+ }
+ }
+ }
+
+void CEikDialog::CreatePageSelectorL()
+ {
+ iPageSelector=CEikDialogPageSelector::NewL(*this,this);
+ iPageSelector->SetObserver(this);
+ RegisterDialgWithPageSelector(); // Added JIn
+ }
+
+void CEikDialog::CreatePageSelectorL(TInt aResourceId)
+ {
+ if (aResourceId)
+ {
+ TResourceReader reader;
+ iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
+ iPageSelector=CEikDialogPageSelector::NewL(*this,reader,this);
+ iPageSelector->SetObserver(this);
+ CleanupStack::PopAndDestroy();
+ if (iDialogFlags&EEikDialogFlagDensePacking)
+ iPageSelector->SetAllPagesDensePacked(ETrue);
+ RegisterDialgWithPageSelector(); // Added JIn
+ }
+ }
+
+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
+
+ TUint flags = ( iDialogFlags & EEikDialogFlagSleeping ) ?
+ ( CEikButtonGroupContainer::EAddToStack |
+ CEikButtonGroupContainer::EDelayActivation ) :
+ CEikButtonGroupContainer::EAddToStack;
+
+ // Softkeys are embedded if dialog doesn't fill application client
+ // rect/whole screen and dialog is not Query Input.
+ // Shortly: softkeys are embedded only to "normal" dialogs
+ TBool isEmbedded = CbaEmbeddedInDialog( iDialogFlags );
+ if ( isEmbedded )
+ {
+ flags |= CEikButtonGroupContainer::EIsEmbedded;
+ flags |= CEikButtonGroupContainer::EDelayActivation;
+ }
+
+ iButtonGroupContainer = CEikButtonGroupContainer::NewL(
+ CEikButtonGroupContainer::ECba,
+ CEikButtonGroupContainer::EHorizontal,
+ iButtonCommandObserver, aResourceId, *this, flags );
+
+ EnableContentObserver( ETrue );
+
+ AknGlobalPopupPriorityController::AddSubPopupL(*this, *iButtonGroupContainer->ButtonGroup()->AsControl());
+ AknGlobalPopupPriorityController::AddPopupToControlStackL(*iButtonGroupContainer->ButtonGroup()->AsControl(), ECoeStackPriorityCba, ECoeStackFlagRefusesFocus);
+ }
+
+void CEikDialog::CreateTitleBarL()
+ {
+ iTitleBar=new(ELeave) CEikMover;
+ iTitleBar->SetContainerWindowL(*this);
+ }
+
+/**
+ * Initializes the dialog's controls before the dialog is sized and layed out. Empty by default.
+ */
+EXPORT_C void CEikDialog::PreLayoutDynInitL()
+ {
+ }
+
+/**
+ * Initializes the dialog's controls after the dialog has been sized but before it has been activated.
+ * Empty by default.
+ */
+EXPORT_C void CEikDialog::PostLayoutDynInitL()
+ {
+ }
+
+/**
+ * Sets the size and position of the dialog given the size hint aSize.
+ *
+ * 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)
+ {
+ 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() );
+ }
+ }
+ 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());
+
+ 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
+ {
+ if (iDialogFlags&EEikDialogFlagFillScreen)
+ return iEikonEnv->ScreenDevice()->SizeInPixels();
+ 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)
+ {
+ return view->ClientRect().Size();
+ }
+ else
+ {
+ return iEikonEnv->EikAppUi()->ClientRect().Size();
+ }
+ }
+ else
+ {
+ return iEikonEnv->EikAppUi()->ClientRect().Size();
+ }
+ }
+ else
+ {
+ return iEikonEnv->EikAppUi()->ClientRect().Size();
+ }
+ }
+
+
+ // Calculate max size available to page selector, taking into account the border.
+ TSize maxSize(aMaxSize);
+
+ // Take off border
+ maxSize-=iBorder.SizeDelta();
+
+ const TSize pageSelectorSize(iPageSelector->PreferredSize(maxSize));
+
+ TSize preferredSize(0,0);
+ // Don't allow pageSelector to expand width
+ preferredSize.iWidth=Min(pageSelectorSize.iWidth,maxSize.iWidth);
+ // Take its height
+ preferredSize.iHeight=pageSelectorSize.iHeight;
+
+ // Add border back on
+ preferredSize+=iBorder.SizeDelta();
+
+ if ( CbaEmbeddedInDialog( iDialogFlags) )
+ {
+ // If dialog doesn't fill application client rect/whole screen,
+ // dialog is not Query Input and soft keys have some text,
+ // preferred dialog size is extended so that softkey buttons
+ // can be added on bottom of the dialog rect
+
+ // Preferred size is passed to all dialogs in call to function
+ // SetSizeAndPosition( const TSize& aSize ).
+ // It should be used in all derived dialogs.
+
+ CEikCba* cba = static_cast<CEikCba*>(
+ iButtonGroupContainer->ButtonGroup() );
+
+ if ( cba->IsVisible() && !cba->IsEmpty() )
+ {
+ TRect screen;
+ AknLayoutUtils::LayoutMetricsRect(
+ AknLayoutUtils::EScreen, screen );
+
+ TAknLayoutRect cbaRect;
+ cbaRect.LayoutRect( screen,
+ AknLayoutScalable_Avkon::popup_sk_window( 0 ).LayoutLine() );
+
+ preferredSize += TSize( 0, cbaRect.Rect().Height() );
+ }
+ }
+
+ return preferredSize;
+ }
+
+/**
+ * Lays out the dialog's components when the size of the dialog is changed.
+ * Position of DpSel is always at (0,0) relative to dialog.
+ * For Avkon, the DPSEL always stays the same size as the CEikDialog minus an optional title
+ * bar.
+ */
+EXPORT_C void CEikDialog::SizeChanged()
+ {
+ __ASSERT_DEBUG( iButtonGroupContainer->Location() == CEikButtonGroupContainer::EExternal,
+ Panic( EEikDialogPanicIllegalOption ) );
+
+ TInt excludeCbaHeight = -1;
+
+ if (iButtonGroupContainer)
+ {
+ TAknWindowLineLayout windowLineLayoutScreen = AknLayoutScalable_Avkon::Screen().LayoutLine();
+ TRect rectZero = TRect(0,0,0,0);
+ TAknLayoutRect layoutRect;
+ layoutRect.LayoutRect( rectZero, windowLineLayoutScreen );
+ TRect rectScreen( layoutRect.Rect() );
+
+ iButtonGroupContainer->SetBoundingRect(rectScreen);
+
+ if ( iExtension && iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout )
+ {
+ CCoeControl* cba = iButtonGroupContainer->ButtonGroup()->AsControl();
+ static_cast<CEikCba*>(cba)->SetSkinBackgroundId( KAknsIIDQsnBgAreaControlPopup );
+ }
+
+ if ( CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ CEikCba* cba = static_cast<CEikCba*>(
+ iButtonGroupContainer->ButtonGroup() );
+
+ // If dialog doesn't fill application client rect/whole screen,
+ // dialog is not Query Input and soft keys have some text,
+ // softkeys are located on bottom of the dialog rect
+
+ if ( cba->IsVisible() && !cba->IsEmpty() )
+ {
+ TRect screen;
+ AknLayoutUtils::LayoutMetricsRect(
+ AknLayoutUtils::EScreen, screen );
+
+ TAknLayoutRect cbaRect;
+ cbaRect.LayoutRect( screen,
+ AknLayoutScalable_Avkon::popup_sk_window(
+ 0 ).LayoutLine() );
+
+ TRect rect( Rect() );
+ cba->SetRect( TRect(
+ rect.iTl.iX ,
+ rect.iBr.iY - cbaRect.Rect().Height(),
+ rect.iBr.iX ,
+ rect.iBr.iY ) );
+
+ excludeCbaHeight = cbaRect.Rect().Height();
+ }
+ else
+ {
+ // Otherway softkeys are located out of dialog rect
+ cba->SetRect( TRect(0, 0, 0, 0 ) );
+ }
+ }
+ }
+ if (iTitleBar)
+ {
+ TRect nullRect(0,0,0,0);
+ iTitleBar->SetRect( nullRect );
+ }
+
+ // This calculation left in even though border should be ENone
+ TRect rect ( iBorder.InnerRect( Rect() ) );
+
+ if ( excludeCbaHeight != -1 )
+ {
+ rect.iBr.iY = Min( rect.iBr.iY, Rect().iBr.iY - excludeCbaHeight );
+ }
+
+ TInt activePageNum = ActivePageId();
+ CEikDialogPage* currentPage = NULL ;
+ if ( activePageNum >= 0 )
+ { // prevent unnecessary resizing of form components
+ currentPage = iPageSelector->PageContainer()->Page( activePageNum ) ;
+ currentPage->SetFormFlag( CEikDialogPage::EFormResizeOptimisationFlag, ETrue ) ;
+ }
+ iPageSelector->SetRect(rect);
+
+ if ( activePageNum >= 0 ) // disable optimisation flag
+ currentPage->SetFormFlag( CEikDialogPage::EFormResizeOptimisationFlag, EFalse ) ;
+
+ // <SKIN>
+ iExtension->iBgContext->SetParentPos( PositionRelativeToScreen() ) ;
+ iExtension->iBgContext->SetRect( Rect() ) ;
+ }
+
+/**
+ * Sets the title text for the dialog to aText.
+ */
+EXPORT_C void CEikDialog::SetTitleL(const TDesC& aText )
+ {
+ iTitleBar->SetTextL(aText);
+ }
+
+/**
+ * Sets the title text for the dialog by reading it from the resource with id aResourceId.
+ */
+EXPORT_C void CEikDialog::SetTitleL(TInt aResourceId )
+ {
+ HBufC* tmpBuf=iCoeEnv->AllocReadResourceLC(aResourceId);
+ SetTitleL(tmpBuf->Des());
+ CleanupStack::PopAndDestroy(); // tmpBuf
+ }
+
+/**
+ * Dims and inactivates the dialog line containing the control identified by aControlId if
+ * aDimmed is ETrue. Does not cause a redraw.
+ */
+EXPORT_C void CEikDialog::SetLineDimmedNow(TInt aControlId,TBool aDimmed)
+ {
+ CEikCaptionedControl* line=Line(aControlId);
+ CCoeControl* control=line->iControl;
+ if (control->IsDimmed()==aDimmed)
+ return;
+ control->SetDimmed(aDimmed);
+ line->CheckDimmedDisplayState();
+ control->DrawNow();
+ }
+
+/**
+ * Sets the dialog line containing the control identified by aControlId to a non-focusing state
+ * so that it will never be given keyboard focus.
+ */
+EXPORT_C void CEikDialog::SetLineNonFocusing(TInt aControlId)
+ {
+ CEikCaptionedControl* line=Line(aControlId);
+ line->SetNonFocusing();
+ line->iControl->SetNonFocusing();
+ }
+
+/**
+ * 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)
+ {
+ CEikCaptionedControl* line=Line(aControlId);
+ CCoeControl* control=line->iControl;
+ if (control->IsVisible()==aVisible)
+ return;
+ control->MakeVisible(aVisible);
+ line->CheckDimmedDisplayState();
+ }
+
+/**
+ * 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)
+ {
+ 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);
+ }
+
+/**
+ * Lays out the dialog, setting it to take its preferred size and position
+ * for the screen.
+ *
+ * TODO (RSD) I have noticed this routine and I suspect that it is responsible for one of
+ * the sizechanged cascades in Form. This should use best current information to layout
+ * the dialog, but I have not investigated too much
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::Layout()
+ {
+ 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();
+
+ SetSizeAndPosition(PreferredSize( maxSize ));
+ }
+
+/**
+ * Deletes the dialog line with the control identified by aControlId.
+ */
+EXPORT_C void CEikDialog::DeleteLine(TInt aControlId, TBool aRedraw)
+ {
+ iPageSelector->DeleteLine(aControlId, aRedraw);
+ }
+
+/**
+ * Inserts a line in the dialog on the page identified by aPageId at the line index aIndex
+ * and constructed from the resource specified by aResourceId.
+ */
+EXPORT_C void CEikDialog::InsertLineL(TInt aIndex,TInt aResourceId,TInt aPageId)
+ {
+ iPageSelector->InsertLineL(aIndex,aPageId,aResourceId);
+ }
+
+/**
+ * Sets the page identified by aPageId to be densely packed if aDensePacking is ETrue.
+ * The spacing between the dialog's lines is then reduced.
+ * TODO (RSD) This seems to be rather un-avkonlike. Perhaps should be stubbed out.
+ */
+EXPORT_C void CEikDialog::SetPageDensePacking(TInt aPageId,TBool aDensePacking)
+ {
+ iPageSelector->SetPageDensePacked(aPageId,aDensePacking);
+ }
+
+/**
+ * Dynamically constructs a dialog with flags aFlags, buttons constructed from
+ * the resource aButtonsId, and with a single activated empty page with id 0. The
+ * dialog is therefore ready to dynamically add lines to.
+ */
+EXPORT_C void CEikDialog::ConstructAutoDialogLC(TInt aFlags,TInt aButtonsId)
+ {
+ CleanupStack::PushL(this);
+ BaseConstructL();
+ iDialogFlags=aFlags;
+ CreateTitleBarL();
+ CreateButtonGroupContainerL(aButtonsId);
+ CreatePageSelectorL();
+ iPageSelector->AddPageL(0,KNullDesC);
+ SetBorderStyle(); // Moved to the end of construction to allow access to individual lines.
+ }
+
+/**
+ * @deprecated
+ */
+EXPORT_C void CEikDialog::DeclareItemAuto(TInt aControlId,TInt aControlType,TAny* aReturnValue)
+ {
+ CEikCaptionedControl* line=Line(aControlId);
+ if (line->iControlType!=aControlType)
+ Panic(EEikDialogPanicWrongAutoType);
+ line->iReturnValue=aReturnValue;
+ }
+
+/**
+ * Creates a control line in the dialog.on the active page with caption text aCaption.
+ * The line can thereafter be accessed through the identifier aControlId.
+ * A control of type aControlType is created by the Eikon control factory
+ * and the return value of the line set to aReturnValue.
+ * If the value of aControlType is not known to the Eikon control factory then
+ * the construction of the control must be handled by CreateCustomControlL.
+ */
+EXPORT_C CCoeControl* CEikDialog::CreateLineByTypeL(const TDesC& aCaption,TInt aControlId,TInt aControlType,TAny* aReturnValue)
+ {
+ return iPageSelector->CreateLineByTypeL(aCaption,aControlId,aControlType,aReturnValue);
+ }
+
+/**
+ * Overloaded member which creates a control line in the dialog on the page specified by aPageId.
+ *
+ * @since ER5U
+ */
+EXPORT_C CCoeControl* CEikDialog::CreateLineByTypeL(const TDesC& aCaption,TInt aPageId,TInt aControlId,TInt aControlType,TAny* aReturnValue)
+ {
+ return iPageSelector->CreateLineByTypeL(aCaption,aPageId,aControlId,aControlType,aReturnValue);
+ }
+
+/**
+ * Creates a custom control of type aControlType. Returns the control information for the custom control
+ * which is created. Called when creating a line on the dialog page if the Eikon control factory does not
+ * recognise the type aControlType.
+ *
+ * This method panics by default. It must be reimplemented if it is to be called.
+ *
+ * The parent of a custom control should be the line which contains it - not the dialog itself -
+ * but the line is not accessible at this stage. If necessary, the line should be set as the parent in
+ * PreLayoutDynInitL
+ */
+EXPORT_C SEikControlInfo CEikDialog::CreateCustomControlL(TInt /*aControlType*/)
+ {
+ Panic(EEikDialogPanicNoSuchControl);
+ return SEikControlInfo();
+ }
+
+EXPORT_C MEikDialogPageObserver::TFormControlTypes CEikDialog::ConvertCustomControlTypeToBaseControlType(TInt /*aControlType*/) const
+ {
+/**
+ * For Forms only:
+ * This should be overrridden with mappings between the base control types that
+ * form knows how to layout (described in eikdpobs.h)
+ */
+ return MEikDialogPageObserver::EUnknownType;
+ }
+/**
+ * Sets the caption of the control identified by aControlId to the descriptor aText.
+ */
+EXPORT_C void CEikDialog::SetControlCaptionL(TInt aControlId,const TDesC& aText)
+ {
+ CEikCaptionedControl* line=Line(aControlId);
+ if (line)
+ {
+ line->SetCaptionL(aText);
+ line->DrawNow();
+ }
+ }
+
+/**
+ * Sets the caption of the control identified by aControlId by reading the caption
+ * text from the resource specified by aResourceId.
+ */
+EXPORT_C void CEikDialog::SetControlCaptionL(TInt aControlId,TInt aResourceId)
+ {
+ HBufC* captionBuf=iCoeEnv->AllocReadResourceLC(aResourceId);
+ SetControlCaptionL(aControlId,captionBuf->Des());
+ CleanupStack::PopAndDestroy();
+ }
+
+/**
+ * Returns a pointer to the caption of the control identified by aControlId.
+ * Does not imply transfer of ownership.
+ */
+EXPORT_C CEikLabel* CEikDialog::ControlCaption(TInt aControlId) const
+ {
+ return iPageSelector->Line(aControlId)->iCaption;
+ }
+
+/**
+ * Returns a pointer to the first control found to be identified by aControlId.
+ * Panics if the control id is invalid. Does not imply transfer of ownership.
+ */
+EXPORT_C CCoeControl* CEikDialog::Control(TInt aControlId) const
+ {
+ CEikCaptionedControl* line=iPageSelector->Line(aControlId);
+ CCoeControl* control=line->iControl;
+ ASSERT(control);
+ return control;
+ }
+
+/**
+ * Returns a pointer to the control identified by aControlId or NULL
+ * if the control id is invalid. Does not imply transfer of ownership.
+ */
+EXPORT_C CCoeControl* CEikDialog::ControlOrNull(TInt aControlId) const
+ {
+ if (!iPageSelector)
+ return NULL;
+ CEikCaptionedControl* line=iPageSelector->LineOrNull(aControlId);
+ if (line)
+ return line->iControl;
+
+ return NULL;
+ }
+
+/**
+ * Returns a reference to the button group container supplying the command
+ * buttons for the dialog.
+ *
+ * @since ER5U
+ */
+EXPORT_C CEikButtonGroupContainer& CEikDialog::ButtonGroupContainer() const
+ {
+ ASSERT(iButtonGroupContainer);
+ return *iButtonGroupContainer;
+ }
+
+/**
+ * Swaps the the button group container with a new container aContainer. The dialog takes ownership
+ * of the new container. Returns a pointer to the old button group container and transfers ownership.
+ *
+ * @since ER5U
+ */
+EXPORT_C CEikButtonGroupContainer* CEikDialog::SwapButtonGroupContainer(CEikButtonGroupContainer* aContainer)
+ {
+ ASSERT(iButtonGroupContainer);
+ ASSERT(aContainer);
+
+ CEikButtonGroupContainer* oldContainer=iButtonGroupContainer;
+ iButtonGroupContainer=aContainer;
+ return oldContainer;
+ }
+
+/**
+ * Returns a reference to the dialog title bar.
+ *
+ * @since ER5U
+ */
+EXPORT_C CEikMover& CEikDialog::Title() const
+ {
+ return *iTitleBar;
+ }
+
+/**
+ * Returns the id of the dialog's active page.
+ *
+ * @since ER5U
+ */
+EXPORT_C TInt CEikDialog::ActivePageId() const
+ {
+ return iPageSelector->ActivePageId();
+ }
+
+/**
+ * Activates the first page on the dialog. At least one page must be activated
+ * before the dialog can be used.
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::ActivateFirstPageL() const
+ {
+ iPageSelector->ActivateFirstPageL();
+ }
+
+
+/**
+ * Sets the Editable state. This exists to support forms
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::SetEditableL( TBool 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();
+ }
+ }
+
+/**
+ * Returns the Editable state. This exists to support forms
+ *
+ * @since ER5U
+ */
+EXPORT_C TBool CEikDialog::IsEditable() const
+ {
+ return ( iIsEditable ) ;
+ }
+
+/**
+ * Returns the line index of the control aControl or KErrNotFound if the control
+ * is not on the active page.
+ */
+EXPORT_C TInt CEikDialog::FindLineIndex(const CCoeControl& aControl) const
+ {
+ return iPageSelector->FindLineIndex(aControl);
+ }
+
+/**
+ * Returns a pointer to the line containing the control identified by aControlId.
+ * Does not imply transfer of ownership.
+ */
+EXPORT_C CEikCaptionedControl* CEikDialog::Line(TInt aControlId) const
+ {
+ return iPageSelector->Line(aControlId);
+ }
+
+/**
+ * Returns a pointer to the current line.
+ * Does not imply transfer of ownership.
+ */
+EXPORT_C CEikCaptionedControl* CEikDialog::CurrentLine() const
+ {
+ return iPageSelector->CurrentLine();
+ }
+
+/**
+ * Rotates the focus by aDelta steps. Each line is a step, as are dialog tabs..
+ */
+EXPORT_C TBool CEikDialog::RotateFocusByL(TInt aDelta)
+ {
+ return iPageSelector->RotateFocusByL(aDelta);
+ }
+
+/**
+ * Returns the index of the dialog's active page. Pages are indexed from 0 in the
+ * order that they are added.
+ *
+ * @since ER5U
+ */
+EXPORT_C TInt CEikDialog::ActivePageIndex() const
+ {
+ return iPageSelector->ActivePageIndex();
+ }
+
+/**
+ * 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()
+ {
+ // Moved BringForwards in the beginning to enable 1-frame animations.
+ iEikonEnv->BringForwards(ETrue); // before call to EnableBackup()
+ AknGlobalPopupPriorityController::ShowPopup(*this, ETrue);
+ iDialogFlags|=EEikDialogFlagBroughtForward;
+
+ // This makes sure that forms, ie. dialogs that fill up the whole
+ // application rect, and therefore look like views,
+ // not have popup transition effects.
+ if ( iDialogFlags & EEikDialogFlagFillAppClientRect ||
+ iDialogFlags & EEikDialogFlagFillScreen ||
+ (AknLayoutUtils::PenEnabled() && ( iDialogFlags & EEikDialogFlagVirtualInput ) )
+ )
+ {
+ GfxTransEffect::Deregister( this );
+ }
+
+ // Need to fade here or background will not be faded during transition
+ if(GfxTransEffect::IsRegistered(this) && IsVisible())
+ {
+ CAknTransitionUtils::SetData(EDontAnimateBitmaps, (TAny*)this);
+ }
+
+ DynamicConstructL();
+ if (!(iDialogFlags&EEikDialogFlagModeless))
+ {
+ if ( !(iDialogFlags&EEikDialogFlagFillAppClientRect) )
+ {
+ // Modal partial screen dialogs (like queries) capture pointer events.
+ SetGloballyCapturing( ETrue );
+ SetPointerCapture(ETrue);
+ }
+ SetFocus(EFalse);
+ AknGlobalPopupPriorityController::AddPopupToControlStackL(*this, ECoeStackPriorityDialog);
+ }
+
+ if (~iDialogFlags&EEikDialogFlagNoBackup)
+ {
+ DrawableWindow()->EnableBackup();
+ }
+
+ TBool wgFocused = IsFocusedWindowGroup( this );
+ if ( !GfxTransEffect::IsRegistered( this ) || !IsVisible() || !wgFocused )
+ {
+ // Call this when there won't be any effect in order to work exactly
+ // like it would if there were no transition effects
+ FadeBehindPopup(ETrue);
+ }
+
+ // Get the foreground information _before_ calling ActivateL because something
+ // unwanted could be flushed to the screen (IsForeground causes a window server
+ // flush)
+ CAknAppUi* aknAppUi = static_cast<CAknAppUi*>( CEikonEnv::Static()->EikAppUi() );
+ TBool threadIsFg = aknAppUi->IsForeground();
+
+ iExtension->iInitialMade = ETrue;
+ iPageSelector->ActivateFirstPageL();
+ ActivateL();
+
+ if ( iButtonGroupContainer && CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ iButtonGroupContainer->ActivateL();
+ }
+
+ SetInitialCurrentLine();
+ iExtension->iInitialMade = EFalse;
+
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ TInt slidingMode = AknsDrawUtils::SlidingMode(skin);
+
+ if ( (iExtension && iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout) &&
+ (slidingMode != ESlidingDisabled) &&
+ IsVisible() )
+ {
+ SlideDialog();
+ }
+
+ IssueMediatorCommand(this);
+
+ CleanupStack::Pop();
+
+ if ( GfxTransEffect::IsRegistered( this ) && IsVisible() && wgFocused &&
+ Size().iWidth > 0 && Size().iHeight > 0 && threadIsFg && !IsBlankScreenDisplayed())
+ {
+ MakeVisible(EFalse); //make sure it is invisible when calling begin
+ CAknTransitionUtils::MakeVisibleSubComponents( this,
+ CAknTransitionUtils::EAppearInvisible );
+
+ InvalidateWindows( this );
+
+ CAknTransitionUtils::SetAllParents(this);
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ GfxTransEffect::NotifyExternalState(EInternalHandleSequence, (const TDesC8*)this);
+#endif
+ 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::EAppearVisible );
+
+ GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);
+ GfxTransEffect::End(this);
+ }
+ else
+ {
+ FadeBehindPopup(ETrue);
+ }
+
+ if( GfxTransEffect::IsRegistered( this ) && IsVisible() )
+ {
+ CAknTransitionUtils::RemoveData(EDontAnimateBitmaps);
+ }
+
+ // Claim pointer grab and send the pointer up event to the
+ // control that otherwise would be receiving the drag events.
+ Window().ClaimPointerGrab(ETrue);
+
+ return(WaitAsRequired());
+ }
+
+
+EXPORT_C void CEikDialog::Draw(const TRect& /*aRect*/) const
+ {
+ TRect rect=Rect();
+ CWindowGc& gc=SystemGc(); //No reason to demote the gc, CWindowGc is more usable.
+
+ if ( iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout )
+ {
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ TRect windowRect = Rect();
+
+ TAknLayoutRect topLeft;
+ topLeft.LayoutRect(windowRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_2());
+
+ TAknLayoutRect bottomRight;
+ bottomRight.LayoutRect(windowRect, SkinLayout::Popup_windows_skin_placing__frame_general__Line_5());
+
+ TRect outerRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);
+ TRect innerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);
+
+ CFbsBitmap* cbaExtension = 0;
+ cbaExtension = AknsUtils::GetCachedBitmap( skin, KAknsIIDQsnBgSlicePopup );
+
+
+ if ( cbaExtension )
+ {
+ TAknWindowLineLayout lineLayoutPopupBgSlice = SkinLayout::Popup_windows_skin_placing__background_slice__Line_2();
+ TAknLayoutRect layoutRect;
+ layoutRect.LayoutRect( windowRect, lineLayoutPopupBgSlice );
+ TRect rectPopupBgSlice( layoutRect.Rect() );
+
+ AknIconUtils::SetSize( cbaExtension, TSize( rectPopupBgSlice.Width(), rectPopupBgSlice.Height() ) );
+
+ gc.BitBlt(TPoint(rect.iTl.iX, rect.iBr.iY - cbaExtension->SizeInPixels().iHeight), cbaExtension);
+ }
+
+ if ( CAknEnv::Static()->TransparencyEnabled() )
+ {
+ TRect rect( outerRect );
+ TRegionFix<16> drawFrameClipReg;
+ TBool drawFrame = EFalse;
+
+ // Add CBA area to drawing region
+ if ( iButtonGroupContainer && CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ CEikCba* cba = static_cast<CEikCba*>(
+ iButtonGroupContainer->ButtonGroup() );
+
+ if ( cba )
+ {
+ drawFrame = ETrue;
+
+ drawFrameClipReg.AddRect(
+ TRect( cba->Position(), cba->Rect().Size() ) );
+
+ rect.iBr.iY = Min( rect.iBr.iY,
+ Rect().iBr.iY - cba->Rect().Height() );
+ }
+ }
+
+ // Add area outside page selector area to drawing region.
+ if ( iPageSelector && rect != iPageSelector->Rect() )
+ {
+ drawFrame = ETrue;
+ drawFrameClipReg.AddRect( rect );
+
+ if ( iExtension->iPublicFlags[ CEikDialogExtension::EClipChildControlRect ] )
+ {
+ drawFrameClipReg.SubRect( iPageSelector->Rect() );
+ }
+ }
+
+ // Draw background
+ if ( drawFrame )
+ {
+ gc.SetClippingRegion( drawFrameClipReg );
+
+ AknsDrawUtils::DrawFrame( skin, gc, outerRect, innerRect,
+ KAknsIIDQsnFrPopup,KAknsIIDQsnFrPopupCenter);
+
+ gc.CancelClippingRegion();
+ }
+ }
+ else
+ {
+ AknsDrawUtils::DrawFrame( skin, gc, outerRect, innerRect,
+ KAknsIIDQsnFrPopup,KAknsIIDQsnFrPopupCenter);
+ }
+ }
+ }
+
+EXPORT_C void CEikDialog::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+ {
+ CEikBorderedControl::HandlePointerEventL(aPointerEvent);
+ }
+
+EXPORT_C void* CEikDialog::ExtensionInterface( TUid /*aInterface*/ )
+ {
+ return NULL;
+ }
+
+TKeyResponse CEikDialog::TryAnimateButtonAndExitL(TInt aKeycode)
+ {
+ TInt buttonId=EEikBidCancel;
+ switch (aKeycode)
+ {
+ case EKeyEnter:
+ case EKeyOK:
+ buttonId=EEikBidOk;
+ break;
+ case EKeySpace:
+ buttonId=EEikBidSpace;
+ break;
+ case EKeyTab:
+ buttonId=EEikBidTab;
+ break;
+ case EKeyBackspace:
+ buttonId=EEikBidDelete;
+ break;
+ }
+
+ CEikButtonGroupContainer& buttonGroupContainer = ButtonGroupContainer();
+ CCoeControl* button = buttonGroupContainer.ControlOrNull(buttonId);
+
+ if (button)
+ {
+ if (button->IsDimmed() || !button->IsVisible())
+ return EKeyWasNotConsumed;
+ buttonGroupContainer.AnimateCommand(buttonId);
+ }
+
+ if (button || buttonId==EEikBidCancel || buttonId==EEikBidOk)
+ {
+ TryExitL(buttonId);
+ return EKeyWasConsumed;
+ }
+
+ return EKeyWasNotConsumed;
+ }
+
+/**
+ * Prepares for a transistion in focus in the dialog. By default, calls the currently
+ * focused control to prepare fo loss of focus.
+ */
+EXPORT_C void CEikDialog::PrepareForFocusTransitionL()
+ {
+ CEikCaptionedControl* currentLine=CurrentLine();
+ if (currentLine)
+ currentLine->iControl->PrepareForFocusLossL();
+ }
+
+/**
+ * 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)
+ {
+
+
+ // Hide the tool tip (if there is one!)
+ if ( ( iPageSelector->NumPages() == 1 ) && ( CurrentLine() ) && ( CurrentLine()->ToolTipText( ) ) )
+ {
+ switch ( aKeyEvent.iScanCode )
+ {
+ case EStdKeyEscape :
+ default :
+ break ;
+ }
+ }
+ if (!(iDialogFlags&EEikDialogFlagDontEatUpDownEvents) && aKeyEvent.iScanCode != EStdKeyYes)
+ {
+ if (aType!=EEventKey)
+ return(EKeyWasConsumed);
+ }
+
+ TInt code=aKeyEvent.iCode;
+ const TUint modifiers = aKeyEvent.iModifiers;
+ TKeyResponse response;
+
+ // Pass the key event to the button group container first (if required)
+
+ if (iDialogFlags&EEikDialogFlagAllKeysToButtons || ((modifiers & EAllStdModifiers) == EModifierCtrl) )
+ {
+ response = iButtonGroupContainer->OfferKeyEventL(aKeyEvent,aType);
+ if(response==EKeyWasConsumed)
+ return EKeyWasConsumed;
+ }
+
+ //
+
+ switch (code)
+ {
+ case EKeyEnter:
+ case EKeyOK:
+ // the next one tries to disable selection_key when
+ // left softkey has no command in it.
+ if (iButtonGroupContainer && iButtonGroupContainer->ButtonGroup())
+ if (iButtonGroupContainer->ButtonGroup()->CommandId(0) == 0)
+ goto KeyToFocus;
+
+ if(iPageSelector->TakesEnterKey() || (modifiers&EModifierCtrl && !(modifiers&EModifierPureKeycode)) )
+ goto KeyToFocus; // else fall through
+ break;
+ 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;
+ if ((!(modifiers&EModifierCtrl) || modifiers&EModifierPureKeycode) &&
+ !(iDialogFlags&EEikDialogFlagModeless))
+ TryAnimateButtonAndExitL(code);
+ break;
+ case EKeyTab:
+ if (aKeyEvent.iModifiers&EModifierCtrl)
+ {
+ response = iPageSelector->OfferKeyEventL(aKeyEvent, aType);
+ if (response==EKeyWasConsumed)
+ break;
+ }
+ // drop through
+ case EKeySpace:
+ case EKeyBackspace:
+ if (TryAnimateButtonAndExitL(code)==EKeyWasConsumed)
+ break;
+ default:
+ iPageSelector->OfferKeyEventL(aKeyEvent, aType);
+ break;
+ KeyToFocus:
+ if(iPageSelector->OfferHotKeysKeyEventL(aKeyEvent,aType)==EKeyWasConsumed)
+ return EKeyWasConsumed;
+
+ }
+
+ return (aKeyEvent.iScanCode == EStdKeyYes ? EKeyWasNotConsumed:EKeyWasConsumed);
+ }
+
+/**
+* Hands focus to current dialog line.
+*/
+EXPORT_C void CEikDialog::FocusChanged(TDrawNow aDrawNow)
+ {
+ CEikBorderedControl::FocusChanged( aDrawNow );
+
+ TInt controlID = IdOfFocusControl();
+ if (controlID)
+ {
+ Line(controlID)->SetFocus(IsFocused(), aDrawNow);
+ }
+ }
+
+/**
+ * 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
+ * determine which buttons can exit the dialog.
+ *
+ * This will fail if user exit is prevented by the EEikDialogFlagNoUserExit flag.
+ * 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 )
+ {
+ return;
+ }
+
+ // use delayed exit if pointer event handling is in progress
+ if ( Extension()->iPublicFlags.IsSet( CEikDialogExtension::EDelayedExit ) )
+ {
+ Extension()->iButtonId = aButtonId;
+ Extension()->StartDelayedExit();
+ 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 == EAknSoftkeyDone;
+#endif
+ CAknAppUi* aknAppUi = static_cast<CAknAppUi*>( iEikonEnv->EikAppUi() );
+ if ( GfxTransEffect::IsRegistered( this ) && IsVisible() && effectButton
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ && !(iDialogFlags&EEikDialogFlagSleeping)
+#endif
+ && ( !aknAppUi->IsFullScreenApp() || aknAppUi->IsForeground() )
+ && !IsBlankScreenDisplayed()
+ )
+ {
+ CAknTransitionUtils::SetAllParents(this);
+ GfxTransEffect::Begin(this, KGfxControlDisappearAction);
+ GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)this);
+
+ TRect demarcation;
+ CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup,
+ demarcation);
+ GfxTransEffect::SetDemarcation(this, demarcation);
+ effectTriggered = ETrue;
+ }
+
+ if (aButtonId!=EEikBidCancel)
+ PrepareForFocusTransitionL();
+ else if (!(iDialogFlags&EEikDialogFlagNotifyEsc))
+ goto finished;
+ if (!OkToExitL(aButtonId))
+ {
+ if ( effectTriggered )
+ {
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsAbort,
+ ( const TDesC8* ) this );
+ GfxTransEffect::Abort( this );
+ }
+ return;
+ }
+
+ if (aButtonId!=EEikBidCancel)
+ GetAutoValues();
+finished:
+ if (iExitConfirmed)
+ *iExitConfirmed=((MappedCommandId( aButtonId ) ==EEikBidCancel)? 0: aButtonId);
+
+ // Remove content observer in order to prevent unnecessary layout
+ // calculations in dialog shutdown.
+ EnableContentObserver( EFalse );
+
+ if (iDialogFlags&EEikDialogFlagSleeping)
+ ExitSleepingDialog();
+ else
+ {
+ // Remove content observer in order to prevent unnecessary layout
+ // calculations in dialog shutdown.
+ EnableContentObserver( EFalse );
+
+ if ( effectTriggered )
+ {
+ MakeVisible(EFalse);
+ CAknTransitionUtils::MakeVisibleSubComponents( this,
+ CAknTransitionUtils::EForceInvisible );
+
+ GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)this);
+ GfxTransEffect::End(this);
+ }
+ else
+ {
+ MakeVisible(EFalse);
+ CAknTransitionUtils::MakeVisibleSubComponents( this,
+ CAknTransitionUtils::EForceInvisible );
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsAbort,
+ ( const TDesC8* ) this );
+ GfxTransEffect::Abort(this);
+ }
+ delete(this);
+ }
+ }
+
+/**
+ * Returns the input capabilites of the dialog. By default, the dialog is
+ * capable of handling all text input.
+ *
+ * @since ER5U
+ */
+EXPORT_C TCoeInputCapabilities CEikDialog::InputCapabilities() const
+ {
+ return TCoeInputCapabilities(TCoeInputCapabilities::ENavigation);
+ }
+
+void CEikDialog::GetAutoValues()
+ {
+ iPageSelector->GetAutoValues();
+ }
+
+/**
+ * Tries to change focus to the line identified by aLineId. Fails if the line id is not
+ * valid. Calls PrepareForFocusTransitionL before focus is given to the line.
+ */
+EXPORT_C void CEikDialog::TryChangeFocusToL(TInt aLineId)
+ {
+ iPageSelector->FocusLineL(aLineId);
+ }
+
+/** * Returns the number of control components.
+ * In Avkon returns 2 as the button group container is not internal
+ */
+EXPORT_C TInt CEikDialog::CountComponentControls() const
+ {
+ if ( CbaEmbeddedInDialog( iDialogFlags ) && iButtonGroupContainer
+ && iButtonGroupContainer->ButtonGroup() )
+ {
+ // Count Buttongroup
+ return 3;
+ }
+
+ return 2; // Title bar and page selector.
+ }
+
+/**
+ * Returns a pointer to the component control at index aIndex in the component control list.
+ * Returns the title bar at index 0, then the page selector
+ * Does not imply transfer of ownership.
+ */
+EXPORT_C CCoeControl* CEikDialog::ComponentControl(TInt aIndex) const
+ {
+ if ( CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ switch (aIndex)
+ {
+ case 0:
+ return iTitleBar;
+ case 1:
+ return iPageSelector;
+ case 2:
+ return ( iButtonGroupContainer &&
+ iButtonGroupContainer->ButtonGroup() ) ?
+ iButtonGroupContainer->ButtonGroup()->AsControl() :
+ NULL;
+ default:
+ return NULL;
+ }
+ }
+
+ switch (aIndex)
+ {
+ case 0:
+ return iTitleBar;
+ case 1:
+ default:
+ return iPageSelector;
+ }
+ }
+
+/**
+ * Handles an event of type aEventType reported by the control aControl. By default, handles
+ * EEventStateChanged by calling HandleControlStateChangeL and EEventInteractionRefused by
+ * calling HandleInteractionRefused.
+ */
+EXPORT_C void CEikDialog::HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType)
+ {
+ switch (aEventType)
+ {
+ case EEventStateChanged:
+ {
+ if ( iPageSelector && iPageSelector->IsForm() && Extension() )
+ {
+ if ( Extension()->iPublicFlags.IsSet( CEikDialogExtension::EFullyConstructed ) )
+ {
+ TInt lineId = iPageSelector->LineId( *aControl );
+
+ if ( lineId != KErrNotFound )
+ {
+ HandleControlStateChangeL( lineId );
+ }
+ }
+ }
+ }
+ break;
+ case EEventInteractionRefused:
+ {
+ if (aControl==iButtonGroupContainer)
+ HandleInteractionRefused(0);
+ else
+ {
+ TInt lineId=iPageSelector->LineId(*aControl);
+ if (lineId!=KErrNotFound)
+ HandleInteractionRefused(lineId);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+/**
+ * Set the line which initally receives focus.
+ * This is the first focusable line on the first page in the
+ * dialog by default. Reimplementations of this method must
+ * activate a page before doing anything else.
+ */
+EXPORT_C void CEikDialog::SetInitialCurrentLine()
+ {
+ if ( !iExtension->iInitialMade )
+ {
+ TRAP_IGNORE(iPageSelector->ActivateFirstPageL());
+ }
+ if( !iIsEditable )
+ {
+ iPageSelector->SetInitialFocus();
+ }
+ }
+
+/**
+ * Handles a dialog button press for the button with id aButtonId.
+ * The cancel button press is not passed to the handler unless EEikDialogFlagNotifyEsc
+ * is set. Returns ETrue if the dialog is ready to exit. Returns ETrue by default.
+ */
+EXPORT_C TBool CEikDialog::OkToExitL(TInt /*aButtonId*/)
+ {
+ return ETrue;
+ }
+
+/**
+ * Handles a state change in the control with id aControlId. Empty by default.
+ */
+EXPORT_C void CEikDialog::HandleControlStateChangeL(TInt /*aControlId*/)
+ {
+ }
+
+/**
+ * Handles an attempt by the user to activate a dimmed button with
+ * id aControlId. Prints an info message by default.
+ */
+EXPORT_C void CEikDialog::HandleInteractionRefused(TInt /*aControlId*/)
+ {
+ // Does nothing in Avkon
+ }
+
+/**
+ * Adjusts all the ids of controls on the page identified by aPageId by incrementing their
+ * id values by aControlIdDelta.
+ */
+EXPORT_C void CEikDialog::AdjustAllIdsOnPage(TInt aPageId,TInt aControlIdDelta)
+ {
+ iPageSelector->AdjustAllIds(aPageId,aControlIdDelta);
+ }
+
+/**
+ * Makes the panel button identified by aButtonId visible if aVisible is ETrue.
+ */
+EXPORT_C void CEikDialog::MakePanelButtonVisible(TInt aButtonId,TBool aVisible)
+ {
+ // *** ToDo: Check whether this is only applicable for internal button group containers?
+ ButtonGroupContainer().MakeCommandVisible(aButtonId,aVisible);
+ }
+
+/**
+ * Takes any action required when the active dialog page is changed to aPageId.
+ * Empty by default.
+ */
+EXPORT_C void CEikDialog::PageChangedL(TInt /*aPageId*/)
+ {
+ }
+
+/**
+ * Takes any action required when the current line is changed to aControlId.
+ * Empty by default.
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::LineChangedL(TInt /*aControlId*/)
+ {
+ }
+
+/**
+ * Switches the latent line from aNoLongerLatent to aBecomesLatent. If dialog lines are
+ * latent they are not visible and are not taken into account when laying out the dialog.
+ * Latent lines can then be swapped around on the dialog later.
+ */
+EXPORT_C void CEikDialog::SwitchLineLatency(TInt aBecomesLatent,TInt aNoLongerLatent)
+ {
+ CEikCaptionedControl* becomesLatent=Line(aBecomesLatent);
+ CEikCaptionedControl* noLongerLatent=Line(aNoLongerLatent);
+#if defined(_DEBUG)
+ if (becomesLatent->IsLatent() || !noLongerLatent->IsLatent())
+ Panic(EEikDialogPanicWrongLatencySwitch);
+#endif
+ becomesLatent->SetLatent(ETrue);
+ noLongerLatent->SetLatent(EFalse);
+ noLongerLatent->CheckDimmedDisplayState();
+ }
+
+/**
+ * Sets the page identified by aPageId to be dimmed if aDimmmed is ETrue.
+ */
+EXPORT_C void CEikDialog::SetPageDimmedNow(TInt aPageId,TBool aDimmed)
+ {
+ iPageSelector->SetPageDimmed(aPageId,aDimmed,EDrawNow);
+ }
+
+/**
+ * Prepares the graphics context aGc for drawing the control in its normal state.
+ */
+EXPORT_C void CEikDialog::PrepareContext(CWindowGc& aGc) const
+ {
+ aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+ aGc.SetBrushColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));
+ aGc.SetPenColor(iEikonEnv->ControlColor(EColorDialogText,*this));
+ }
+
+/**
+ * Gets the list of logical colors employed in the drawing of the control,
+ * paired with an explanation of how they are used. Appends the list to aColorUseList.
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::GetColorUseListL(CArrayFix<TCoeColorUse>& aColorUseList) const
+ {
+ TInt commonAttributes = TCoeColorUse::ESurrounds|TCoeColorUse::EActive|TCoeColorUse::ENormal|TCoeColorUse::ENeutral;
+ TCoeColorUse colorUse;
+
+ colorUse.SetLogicalColor(EColorDialogText);
+ colorUse.SetUse(TCoeColorUse::EFore|commonAttributes);
+ aColorUseList.AppendL(colorUse);
+
+ colorUse.SetLogicalColor(EColorDialogBackground);
+ colorUse.SetUse(TCoeColorUse::EBack|commonAttributes);
+ aColorUseList.AppendL(colorUse);
+ }
+
+/**
+ * Handles a change to the control's resources of type aType
+ * which are shared across the environment, e.g. colors or fonts.
+ *
+ * @since ER5U
+ */
+EXPORT_C void CEikDialog::HandleResourceChange(TInt aType)
+ {
+
+ if(aType==KEikDynamicLayoutVariantSwitch)
+ {
+ if (IsVisible())
+ DoResourceChangeLayout();
+ else if (iExtension)
+ iExtension->iFlags.Set(CEikDialogExtension::ELayoutChangeWhileInvisible);
+
+ CCoeControl::HandleResourceChange(aType);
+ return;
+ }
+ else
+ {
+ CCoeControl::HandleResourceChange(aType);
+ }
+
+ if( !CAknEnv::Static()->TransparencyEnabled() && aType==KEikColorResourceChange)
+ {
+ Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));
+ }
+ }
+
+void CEikDialog::DoResourceChangeLayout()
+ {
+ // Layout must be forced through - bypass optimisations
+ // Must work through all pages
+
+ Layout();
+ SizeChanged();
+
+ TInt lastPage = ( iPageSelector->PageContainer()->NumPages() - 1 );
+ TInt pageIndex = 0;
+ CEikDialogPage* page;
+
+ while ( pageIndex++ <= lastPage )
+ {
+ page = iPageSelector->PageContainer()->Page( pageIndex );
+ page->HandleResourceChange( KEikDynamicLayoutVariantSwitch );
+ }
+
+ if (iExtension)
+ iExtension->iFlags.Clear(CEikDialogExtension::ELayoutChangeWhileInvisible);
+ }
+
+/**
+ * Returns a pointer to the dialog's internal button command observer. This is required when creating a
+ * new button group container for the dialog.
+ *
+ * A dialog uses a proxy to observe button commands. This means dialog subclasses can directly observe
+ * commands issued by controls added to the dialog pages or by menus launched by the dialog.
+ *
+ * @since ER5U
+ */
+EXPORT_C MEikCommandObserver* CEikDialog::ButtonCommandObserver() const
+ {
+ return (MEikCommandObserver*)iButtonCommandObserver;
+ }
+
+/**
+ * Writes the internal state of the control and its components to aStream.
+ * Does nothing in release mode.
+ * Designed to be overidden and base called by subclasses.
+ *
+ * @internal
+ * @since App-Framework_6.1
+ */
+#ifndef _DEBUG
+EXPORT_C void CEikDialog::WriteInternalStateL(RWriteStream&) const
+ {}
+#else
+EXPORT_C void CEikDialog::WriteInternalStateL(RWriteStream& aWriteStream) const
+ {
+ CEikBorderedControl::WriteInternalStateL(aWriteStream);
+ }
+#endif
+
+EXPORT_C void CEikDialog::Reserved_2()
+ {}
+EXPORT_C void CEikDialog::CEikDialog_Reserved_1()
+ {}
+EXPORT_C void CEikDialog::CEikDialog_Reserved_2()
+ {}
+
+EXPORT_C void CEikDialog::MakeVisible(TBool aVisible)
+ {
+ if (iExtension && iExtension->iFlags[CEikDialogExtension::ELayoutChangeWhileInvisible])
+ DoResourceChangeLayout();
+
+ // only for popup dialogs
+ if ( aVisible )
+ {
+ if (!(iDialogFlags&EEikDialogFlagFillAppClientRect) && !(iDialogFlags&EEikDialogFlagFillScreen) &&
+ !(iDialogFlags&EEikDialogFlagNoBackgroundFade)
+ // FIX for PTPA-7FYFDE: Query Input is also faded
+ // && !( AknLayoutUtils::PenEnabled() && ( iDialogFlags & EEikDialogFlagVirtualInput ) )
+ )
+ {
+ AknGlobalPopupPriorityController::FadeBehindPopup(*this, iPopupFader, *this, aVisible);
+ }
+ }
+
+ CEikBorderedControl::MakeVisible(aVisible);
+
+ }
+
+void CEikDialog::FadeBehindPopup(TBool aFade)
+ {
+ // record the requested fade state
+ if (aFade)
+ iDialogFlags |= EEikDialogAttemptFadeWhenVisible;
+ else
+ iDialogFlags &= ~EEikDialogAttemptFadeWhenVisible;
+
+ // Attempt to set the fade state to the requested fade state
+ DoFadeBehindPopup(aFade);
+ }
+
+void CEikDialog::DoFadeBehindPopup(TBool aFade)
+ {
+ // Fix for ELWG-7DSEKG: Fullscreen dialogs are now added to the fade stack to allow them
+ // to be opened on top of popups. PopupFader makes sure that actual fading does not happen.
+ //if ((iDialogFlags&EEikDialogFlagFillAppClientRect) || (iDialogFlags&EEikDialogFlagFillScreen) ||
+ // ( iDialogFlags & EEikDialogFlagNoBackgroundFade ) ||
+
+
+ // FIX for PTPA-7FYFDE: Query Input is added also to the fade stack
+ //if ( AknLayoutUtils::PenEnabled() && ( iDialogFlags & EEikDialogFlagVirtualInput ) )
+ // {
+ // return;
+ // }
+
+ // Real fade state is only set on when the dialog is visible
+ if (!IsVisible())
+ aFade = EFalse;
+
+ AknGlobalPopupPriorityController::FadeBehindPopup(*this, iPopupFader, *this, aFade);
+ }
+
+//
+//
+//
+
+/**
+ * @deprecated
+ */
+EXPORT_C void CEikDialog::GetCustomAutoValue(TAny* /*aReturnValue*/,TInt /*aControlType*/,const CCoeControl* /*aControl*/)
+ {
+ ASSERT(EFalse);
+ }
+
+/**
+ * Routine to map the button id ( Avkon softkey command id) to CEikBidCancel if it is a
+ * "cancel" type command type and to CEikBidOk if it is an "accept" type command
+ * Other cases left unchanged
+ *
+ * @since Avkon
+ */
+EXPORT_C TInt CEikDialog::MappedCommandId( TInt aButtonId )
+ {
+ switch ( aButtonId )
+ {
+// Do not test for case EEikBidCancel; it is defined to be the same as EAknSoftkeyCancel
+ case EAknSoftkeyCancel:
+ case EAknSoftkeyBack:
+ case EAknSoftkeyNo:
+ return EEikBidCancel;
+
+ default:
+ break;
+ }
+
+// Also process user range:
+ if ( aButtonId >= EAknSoftkeyLowestUserRejectId
+ && aButtonId < EAknSoftkeyLowestUserAcceptId )
+ return EEikBidCancel;
+
+ return aButtonId;
+ }
+
+EXPORT_C TInt CEikDialog::FormFlagsFromActivePage()
+ {
+ TInt activePageNum = ActivePageId();
+ if (activePageNum >=0) // not sure of valid range,,,,
+ return iPageSelector->PageContainer()->Page(activePageNum)->GetFormFlags();
+ return 0;
+ }
+
+/* deprecated method
+Instead use
+ TInt GetNumberOfLinesOnPage(TInt aPageIndex) const
+ TInt GetNumberOfPages() const
+ CEikCaptionedControl* GetLineByLineAndPageIndex(TInt aLineIndex, TInt aPageIndex) const
+*/
+
+EXPORT_C CEikCaptionedControl* CEikDialog::GetFirstLineOnFirstPageOrNull()
+ {
+ if (!iPageSelector)
+ return 0;
+ if (iPageSelector->PageContainer()->NumPages()>0)
+ {
+ CEikDialogPage* dPagePtr = iPageSelector->PageContainer()->Page(0);
+ CEikCaptionedControl* linePtr = dPagePtr->LineOnPageOrNull(0);
+ return linePtr;
+ }
+ else return 0;
+
+ };
+
+/* deprecated method
+Instead use
+ TInt GetNumberOfLinesOnPage(TInt aPageIndex) const
+ TInt GetNumberOfPages() const
+ CEikCaptionedControl* GetLineByLineAndPageIndex(TInt aLineIndex, TInt aPageIndex) const
+*/
+EXPORT_C void CEikDialog::ControlsOnPage(RArray<CEikCaptionedControl*>& aControls, TInt aPageId) const
+ {
+ if (!iPageSelector || iPageSelector->PageContainer()->NumPages() < aPageId)
+ return;
+
+ CEikDialogPage* dlgPage = iPageSelector->PageContainer()->Page(aPageId);
+ if (!dlgPage)
+ return;
+
+ TInt i = 0;
+ CEikCaptionedControl* control = NULL;
+ do
+ {
+ control = dlgPage->LineOnPageOrNull(i++);
+ if (control)
+ aControls.Append(control);
+ }
+ while (control != NULL);
+ }
+
+EXPORT_C TInt CEikDialog::DialogFlags()
+ {
+ return iDialogFlags;
+ };
+
+void CEikDialog::RegisterDialgWithPageSelector()
+ {
+ if (iPageSelector)
+ iPageSelector->SetDialg(this);
+ };
+
+EXPORT_C TTypeUid::Ptr CEikDialog::MopSupplyObject(TTypeUid aId)
+ {
+ if ( aId.iUid == MAknsControlContext::ETypeId
+ && Extension()
+ && ( Extension()->LayoutCategory() == CEikDialogExtension::EFormLayout ) )
+ return ( MAknsControlContext::SupplyMopObject( aId, iExtension->iBgContext ) ) ;
+
+ if ( aId.iUid == CAknEdwinDrawingModifier::ETypeId )
+ if ( Extension() && Extension()->iDrawingModifier )
+ return aId.MakePtr( Extension()->iDrawingModifier );
+
+ if ( aId.iUid == KAknMediatorFacade && iExtension )
+ { // we actually don't care if this is set or not
+ return aId.MakePtr(iExtension->iAknDSSD);
+ }
+ if( aId.iUid == CEikScrollBarFrame::ETypeId )
+ {
+ TInt activePageNum = ActivePageId();
+ CEikDialogPage* currentPage = NULL ;
+ if ( activePageNum >= 0 )
+ {
+ currentPage = iPageSelector->PageContainer()->Page( activePageNum ) ;
+ currentPage->SetScbState(ETrue);
+ }
+ return aId.MakePtr(iPageSelector->PageContainer()->ScrollBar());
+ }
+
+ if ( aId.iUid == CEikDialog::ETypeId )
+ {
+ return aId.MakePtr( this );
+ }
+
+ return SupplyMopObject(aId, iButtonGroupContainer);
+ }
+
+
+EXPORT_C TInt CEikDialog::CountFadedComponents()
+ {
+ // Don't count the CBA if it contains no commands, since
+ // we don't want it to be unfaded.
+ CCoeControl* cba = iButtonGroupContainer->ButtonGroup()->AsControl();
+ TBool fadeCba = static_cast<CEikCba*>( cba )->IsEmpty();
+ return fadeCba ? 1 : 2;
+ }
+
+EXPORT_C CCoeControl* CEikDialog::FadedComponent(TInt aIndex)
+ {
+ switch (aIndex)
+ {
+ case 0:
+ return this;
+ case 1:
+ return iButtonGroupContainer;
+ default:
+ return NULL;
+ }
+ }
+
+EXPORT_C void CEikDialog::UpdatePageL(TBool aRedraw)
+ {
+ if (Rect().Height())
+ {
+ if (iPageSelector)
+ if (iPageSelector->IsForm())
+ if (iPageSelector->PageContainer())
+ {
+ iPageSelector->PageContainer()->SetEditableL(iIsEditable);
+ if (CurrentLine())
+ TryChangeFocusToL(CurrentLine()->iId);
+ if (aRedraw)
+ DrawDeferred();
+ }
+ }
+ }
+
+
+EXPORT_C TInt CEikDialog::GetNumberOfLinesOnPage(TInt aPageIndex) const
+ {
+ if (iPageSelector)
+ {
+ CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
+ if (pageContainer)
+ {
+ CEikDialogPage* page = pageContainer->Page(aPageIndex);
+ if (page)
+ return page->NumberOfLines();
+ }
+ }
+ return 0;
+ }
+
+EXPORT_C TInt CEikDialog::GetNumberOfPages() const
+ {
+ if (iPageSelector)
+ {
+ CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
+ if (pageContainer)
+ return pageContainer->NumPages();
+ }
+ return 0;
+ }
+
+//--------------------------------------------------------------------------------
+// CEikDialog::HandleDialogPageEventL(TInt aEventID)
+// Handles dialog page events by closing dialog when event is EDialogPageTapped
+// and dialog has flag EEikDialogFlagCloseDialogWhenTapped
+//--------------------------------------------------------------------------------
+//
+EXPORT_C void CEikDialog::HandleDialogPageEventL(TInt aEventID )
+ {
+ // If event is EDialogPageTapped and flag EEikDialogFlagCloseDialogWhenTapped is on
+ if ( (aEventID == MEikDialogPageObserver::EDialogPageTapped) &&
+ (iDialogFlags & EEikDialogFlagCloseDialogWhenTapped) )
+ {
+ // Exit from dialog with cancel.
+ TryExitL(EEikBidCancel);
+ }
+ }
+
+EXPORT_C CEikCaptionedControl* CEikDialog::GetLineByLineAndPageIndex(TInt aLineIndex, TInt aPageIndex) const
+ {
+ if (iPageSelector)
+ {
+ CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
+ if (pageContainer)
+ {
+ CEikDialogPage* page = pageContainer->Page(aPageIndex);
+ if (page)
+ return page->LineByIndex(aLineIndex);
+ }
+ }
+ return 0;
+ }
+
+EXPORT_C CEikDialogExtension* CEikDialog::Extension() const
+ {
+ return iExtension ;
+ }
+
+CEikDialogExtension* CEikDialogExtension::NewL( const CEikDialog& aParent ) // static
+ {
+ CEikDialogExtension* self = new (ELeave) CEikDialogExtension( aParent ) ;
+ CleanupStack::PushL( self ) ;
+ self->ConstructL();
+ CleanupStack::Pop( self ) ;
+ return self ;
+ }
+
+CEikDialogExtension::CEikDialogExtension( const CEikDialog& aParent ) :
+ CActive( EPriorityLow ),
+ iParent( aParent )
+#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
+ , iRegisteredContext( KNullUid )
+#endif
+ {
+ }
+
+CEikDialogExtension::~CEikDialogExtension()
+ {
+ if ( IsActive() )
+ {
+ Cancel();
+ }
+ delete iAknDSSD; // will cancel commands if active
+ delete iBgContext ;
+ delete iDrawingModifier ;
+ }
+
+void CEikDialogExtension::ConstructL()
+ {
+ // <SKIN> create iBgContext
+ iBgContext = CAknsListBoxBackgroundControlContext::NewL(
+ KAknsIIDQsnBgAreaMainListGene, iParent.Rect(), ETrue,
+ KAknsIIDQsnBgColumnAB, iParent.Rect() ) ; // Last two parameters are effectively place-holders
+ iDrawingModifier = new (ELeave )CAknEdwinDrawingModifier();
+ iDrawingModifier->SetInhibitNotifyNewFormatDrawing( ETrue );
+ CActiveScheduler::Add( this );
+ }
+
+EXPORT_C CEikDialogExtension::TLayoutCategory CEikDialogExtension::LayoutCategory() const
+ {
+ TLayoutCategory type = EUnknownLayout;
+ if ( !iParent.iPageSelector )
+ type = ENotConstructed;
+ else if ( iParent.iPageSelector->IsForm() )
+ type = EFormLayout;
+ else if ( (iParent.iDialogFlags)&EEikDialogFlagFillAppClientRect ) // full screen but not Form
+ type = EFullScreenLayout;
+ else
+ type = EPopupLayout; // ends up being the default.
+
+ return type;
+ }
+
+#if (defined(__COVER_DISPLAY) || defined(__VOICE_UI ) )
+
+EXPORT_C void CEikDialog::PublishDialogL(TInt aDialogIndex, TUid aCatUid)
+ {
+ // create utility for these someday perhaps..
+ if (!iExtension)
+ {
+ iExtension = CEikDialogExtension::NewL( *this );
+ }
+ if (!iExtension->iAknDSSD)
+ {
+ iExtension->iAknDSSD = CAknMediatorFacade::NewL(this);
+ }
+ else // just in case, if someone changes the indeces while previous commands active
+ {
+ CancelMediatorCommand(this); // handles flagging
+ }
+
+ iExtension->iAknDSSD->CatUid() = aCatUid;
+ iExtension->iAknDSSD->DialogIndex() = aDialogIndex;
+ iExtension->iAknDSSD->ResetBuffer();
+ }
+
+EXPORT_C void CEikDialog::SetMediatorObserver(MAknDialogMediatorObserver* aObserver)
+ {
+ if (!iExtension)
+ {
+ iExtension = CEikDialogExtension::NewL( *this );
+ }
+ if (!iExtension->iAknDSSD)
+ {
+ iExtension->iAknDSSD = CAknMediatorFacade::NewL(this);
+ }
+
+ iExtension->iAknDSSD->SetObserver(aObserver);
+ }
+#else
+EXPORT_C void CEikDialog::PublishDialogL(TInt, TUid) {}
+EXPORT_C void CEikDialog::SetMediatorObserver(MAknDialogMediatorObserver*){}
+#endif
+
+void CEikDialogExtension::DoCancel()
+ {
+ }
+
+void CEikDialogExtension::RunL()
+ {
+ const_cast<CEikDialog&>( iParent ).TryExitL( iButtonId );
+ }
+
+void CEikDialogExtension::StartDelayedExit()
+ {
+ if (!IsActive())
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknToolbar::SlideToolbar
+// Draws the toolbar with sliding effect.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CEikDialog::SlideDialog()
+ {
+#ifdef RD_SLIDING_ANIMATION_EFFECTS
+ TBool useScreenBitmap = EFalse;
+ TBool useFrameBitmap = EFalse;
+
+ CFbsBitmap* screenCapture;
+ CFbsBitmap* frameBitmap;
+
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ TInt slidingMode = AknsDrawUtils::SlidingMode(skin);
+
+ TPoint startPos = Position();
+ TRect origRect(Position(),Rect().Size());
+
+ const TSize screenSize = iEikonEnv->EikAppUi()->ApplicationRect().Size();
+
+ // Try to copy screen to backup bitmap
+ iCoeEnv->WsSession().Flush(); // first update screen (not necessary?)
+ CWsScreenDevice* scrDevice = static_cast<CWsScreenDevice*>( SystemGc().Device() );
+ TDisplayMode displayMode( scrDevice->DisplayMode() );
+
+ RWsSession& wsSession = CCoeEnv::Static()->WsSession();
+
+ TRAPD( SCerr, screenCapture = new (ELeave) CWsBitmap( wsSession ) );
+
+ TInt errCode( KErrNone );
+ if (SCerr == KErrNone)
+ {
+ errCode = screenCapture->Create( screenSize, displayMode );
+ }
+
+ if (errCode == KErrNone)
+ {
+ errCode = scrDevice->CopyScreenToBitmap( screenCapture );
+ }
+
+ if (errCode == KErrNone)
+ {
+ useScreenBitmap = ETrue;
+ }
+
+
+ // Try to draw skin frame to offscreen bitmap
+ CFbsBitGc* fbsBitGc( NULL );
+ CFbsBitmapDevice* bmpDevice( NULL );
+ TRAPD(FBerr,
+ {
+ frameBitmap = new (ELeave) CFbsBitmap( );
+ CleanupStack::PushL(frameBitmap);
+ User::LeaveIfError( frameBitmap->Create( Rect().Size(), displayMode ) );
+ bmpDevice = CFbsBitmapDevice::NewL( frameBitmap );
+ CleanupStack::PushL( bmpDevice );
+
+ fbsBitGc = CFbsBitGc::NewL();
+ CleanupStack::PushL( fbsBitGc );
+
+ fbsBitGc->Activate( bmpDevice );
+ CleanupStack::Pop(3);
+ }
+ );
+
+ if ( iExtension->LayoutCategory() == CEikDialogExtension::EPopupLayout && FBerr == KErrNone)
+ {
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+
+ TAknLayoutRect topLeft;
+ topLeft.LayoutRect(Rect(), SkinLayout::Popup_windows_skin_placing__frame_general__Line_2());
+
+ TAknLayoutRect bottomRight;
+ bottomRight.LayoutRect(Rect(), SkinLayout::Popup_windows_skin_placing__frame_general__Line_5());
+
+ TRect outerRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);
+ TRect innerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);
+
+ useFrameBitmap = ETrue;
+ if (!AknsDrawUtils::DrawFrame( skin, *fbsBitGc, outerRect, innerRect,
+ KAknsIIDQsnFrPopup,KAknsIIDQsnFrPopupCenter) )
+ {
+ useFrameBitmap = EFalse;
+ }
+ else
+ {
+ useFrameBitmap = ETrue;
+ }
+ }
+
+
+ CEikDialogSlider* slider = NULL;
+ TRAPD( sliderErr, slider = slider->NewL(SystemGc(),frameBitmap,screenCapture ));
+
+ // sliding from the softkey direction
+ if (slidingMode == ESlidingFromCBA)
+ {
+ AknLayoutUtils::TAknCbaLocation location = AknLayoutUtils::CbaLocation();
+ switch(location)
+ {
+ case AknLayoutUtils::EAknCbaLocationRight:
+ slidingMode = ESlidingFromRight;
+ break;
+ case AknLayoutUtils::EAknCbaLocationLeft:
+ slidingMode = ESlidingFromLeft;
+ break;
+ case AknLayoutUtils::EAknCbaLocationBottom:
+ slidingMode = ESlidingFromBottom;
+ break;
+ default:
+ slidingMode = ESlidingFromBottom;
+ break;
+ }
+ }
+
+
+ // don't use math-library (one less dependency)
+ if (slidingMode == ESlidingFromRandom)
+ {
+ TTime homeTime;
+ homeTime.HomeTime();
+ TInt64 seed = homeTime.Int64();
+ TInt value = seed & 0xff;
+ value = value >> 5; // take bits 5-7
+ slidingMode = ESlidingFromLeft + value;
+ }
+
+ switch(slidingMode)
+ {
+ case ESlidingFromLeft:
+ startPos.iX = 0 - origRect.Size().iWidth; // just out of screen
+ break;
+
+ case ESlidingFromTopLeft:
+ startPos.iX = 0 - origRect.Size().iWidth;
+ startPos.iY = 0 - origRect.Size().iHeight;
+ break;
+
+ case ESlidingFromTop:
+ startPos.iY = 0 - origRect.Size().iHeight;
+ break;
+
+ case ESlidingFromTopRight:
+ startPos.iX = screenSize.iWidth;
+ startPos.iY = 0 - origRect.Size().iHeight;
+ break;
+
+ case ESlidingFromRight:
+ startPos.iX = screenSize.iWidth;
+ break;
+
+ case ESlidingFromBottomRight:
+ startPos.iX = screenSize.iWidth;
+ startPos.iY = screenSize.iHeight;
+ break;
+
+ case ESlidingFromBottom:
+ startPos.iY = screenSize.iHeight;
+ break;
+
+ case ESlidingFromBottomLeft:
+ startPos.iX = 0 - origRect.Size().iWidth;
+ startPos.iY = screenSize.iHeight;
+ break;
+
+ default:
+ break;
+ }
+
+ TPoint start = startPos;
+
+ TInt stepCount = 12;
+
+ //iCoeEnv->WsSession().Flush();
+
+ // only do sliding if we have screen capture, dialog background in bitmap and slider
+ // otherwise we have OOM and do no sliding
+ if (useScreenBitmap && useFrameBitmap && sliderErr == KErrNone)
+ {
+ TRAP_IGNORE(slider->SlideDialogL(start, origRect.iTl, stepCount));
+ }
+
+ //TRAP_IGNORE(ActivateL()); // do we need to do this before slider is deleted?
+
+ if (slider)
+ {
+ delete slider;
+ slider = NULL;
+ }
+
+ if (SCerr == KErrNone)
+ {
+ delete screenCapture;
+ }
+
+ if (FBerr == KErrNone)
+ {
+ delete bmpDevice;
+ delete fbsBitGc;
+ delete frameBitmap;
+ }
+#endif //RD_SLIDING_ANIMATION_EFFECTS
+ }
+
+#ifdef RD_SLIDING_ANIMATION_EFFECTS
+CEikDialogSlider::CEikDialogSlider(CWindowGc& aWindowGc, CFbsBitmap*& aDialogBack, CFbsBitmap*& aScreen)
+:iWindowGc(aWindowGc), iDialogBack(aDialogBack), iScreen(aScreen)
+ {
+ }
+
+
+CEikDialogSlider* CEikDialogSlider::NewL(CWindowGc& aWindowGc, CFbsBitmap*& aDialogBack, CFbsBitmap*& aScreen)
+ {
+ CEikDialogSlider* self = new(ELeave)CEikDialogSlider(aWindowGc, aDialogBack, aScreen);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+
+void CEikDialogSlider::ConstructL()
+ {
+ const TSize screenSize = iEikonEnv->EikAppUi()->ApplicationRect().Size();
+
+ CreateWindowL();
+ SetExtent( TPoint(0,0), screenSize);
+ }
+
+CEikDialogSlider::~CEikDialogSlider()
+ {
+ }
+
+void CEikDialogSlider::Draw(const TRect& /* aRect */) const
+ {
+ // only SlideDialog does drawing
+ }
+
+
+void CEikDialogSlider::SlideDialogL(TPoint& aStart, TPoint& aEnd, TInt aStepCount)
+ {
+ ActivateL();
+
+ TInt stepX = ( aEnd.iX - aStart.iX ) / aStepCount;
+ TInt stepY = ( aEnd.iY - aStart.iY ) / aStepCount;
+ TSize dialogSize = iDialogBack->SizeInPixels();
+ TSize ScreenSize = iScreen->SizeInPixels();
+ TPoint oldPos;
+ TRect vertiRect; // these are used to restore background under slided dialog
+ TRect horizRect;
+
+ // Because of rounding error, endpoint from sliding is not same as aEnd.
+ // To correct this, adjust startpoint.
+ aStart.iX = aEnd.iX - aStepCount * stepX;
+ aStart.iY = aEnd.iY - aStepCount * stepY;
+
+ // slide all but last frame
+ for (TInt i=0 ; i < aStepCount ; i++)
+ {
+ oldPos = aStart;
+ aStart.iX += stepX;
+ aStart.iY += stepY;
+ ActivateGc();
+ Window().Invalidate( );
+ Window().BeginRedraw( ); // this flushes window server
+
+ TRect dlgRect(aStart,dialogSize);
+
+ iWindowGc.BitBlt(dlgRect.iTl, iDialogBack);
+
+ if (stepX < dlgRect.Width() && stepY < dlgRect.Height()) // old and new rects are intersecting
+ {
+ if (stepY > 0) // dialog moving down, restore area from top of dialog
+ {
+ vertiRect = TRect(dlgRect.iTl.iX - stepX,
+ dlgRect.iTl.iY - stepY,
+ dlgRect.iBr.iX - stepX,
+ dlgRect.iTl.iY);
+ horizRect.iTl.iY = dlgRect.iTl.iY;
+ horizRect.iBr.iY = dlgRect.iBr.iY - stepY;
+ }
+ else if (stepY < 0) // moving up
+ {
+ vertiRect = TRect(dlgRect.iTl.iX - stepX,
+ dlgRect.iBr.iY,
+ dlgRect.iBr.iX - stepX,
+ dlgRect.iBr.iY - stepY);
+ horizRect.iTl.iY = dlgRect.iTl.iY - stepY;
+ horizRect.iBr.iY = dlgRect.iBr.iY;
+ }
+
+ if (stepX > 0) // dialog moving right, restore area from left of dialog
+ {
+ horizRect.iTl.iX = dlgRect.iTl.iX - stepX;
+ horizRect.iBr.iX = dlgRect.iTl.iX;
+ }
+ else if (stepX < 0) // moving left
+ {
+ horizRect.iTl.iX = dlgRect.iBr.iX;
+ horizRect.iBr.iX = dlgRect.iBr.iX - stepX;
+ }
+
+ if (stepX != 0 && stepY == 0) // set y-coordinates if only moving horizontally
+ {
+ horizRect.iTl.iY = dlgRect.iTl.iY;
+ horizRect.iBr.iY = dlgRect.iBr.iY;
+ }
+
+ iWindowGc.BitBlt(vertiRect.iTl,iScreen,vertiRect);
+ iWindowGc.BitBlt(horizRect.iTl,iScreen,horizRect);
+ }
+ else // old and new rects are not intersecting -> clear under old rect
+ {
+ TRect oldRect(oldPos,dialogSize);
+ iWindowGc.BitBlt(oldPos,iScreen,oldRect);
+ }
+
+ Window().EndRedraw();
+ DeactivateGc();
+
+ iCoeEnv->WsSession().Flush();
+ User::After(2000); // give little time to active objects
+ }
+ }
+#endif //RD_SLIDING_ANIMATION_EFFECTS
+
+EXPORT_C void CEikDialog::SetMultilineQuery(TBool aIsMultilineQuery)
+ {
+ if (iPageSelector)
+ {
+ CEikDialogPageContainer* pageContainer = iPageSelector->PageContainer();
+ if (pageContainer)
+ {
+ CEikDialogPage* page = pageContainer->Page(0);
+ if (page)
+ page->SetDoubleQuery(aIsMultilineQuery);
+ }
+ }
+
+ }
+
+
+void CEikDialog::HandleEmbeddedSofkeyStateChange()
+ {
+ // Check that dialog is constructed and actually with embedded
+ // softkeys
+ if ( iExtension && CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ TSize dialogSize( Rect().Size() );
+ CEikCba* cba = static_cast<CEikCba*>(
+ iButtonGroupContainer->ButtonGroup() );
+ TBool cbaVisible( cba->IsVisible() && !cba->IsEmpty() );
+
+ TRect screenRect;
+ AknLayoutUtils::LayoutMetricsRect(
+ AknLayoutUtils::EScreen, screenRect );
+ TAknLayoutRect cbaRect;
+ cbaRect.LayoutRect(
+ screenRect,
+ AknLayoutScalable_Avkon::popup_sk_window( 0 ).LayoutLine() );
+
+ if ( cbaVisible )
+ {
+ if ( dialogSize.iHeight == MinimumSize().iHeight )
+ {
+ dialogSize.iHeight += cbaRect.Rect().Height();
+ }
+ }
+ else
+ {
+ dialogSize.iHeight -= cbaRect.Rect().Height();
+ }
+
+ SetRect( TRect(
+ AknPopupUtils::Position( dialogSize, this ), dialogSize ) );
+ }
+ }
+
+
+TInt CEikDialog::HandleEmbeddedSoftkeyStateChangeCallBack( TAny* aAny )
+ {
+ CEikDialog* self = static_cast<CEikDialog*>( aAny );
+ self->HandleEmbeddedSofkeyStateChange();
+ return KErrNone;
+ }
+
+
+void CEikDialog::EnableContentObserver( TBool aEnabled )
+ {
+ // Content observer is only used with embedded softkeys.
+ if ( !CbaEmbeddedInDialog( iDialogFlags ) )
+ {
+ return;
+ }
+
+ // Set observer call back.
+ TCallBack callBack;
+ callBack.iPtr = NULL;
+
+ if ( aEnabled )
+ {
+ callBack = TCallBack(
+ HandleEmbeddedSoftkeyStateChangeCallBack, this );
+ }
+
+ if ( iButtonGroupContainer && iButtonGroupContainer->ButtonGroup() )
+ {
+ CCoeControl* control = iButtonGroupContainer->ButtonGroup()->AsControl();
+ CEikCba* cba = static_cast<CEikCba*>( control );
+ if ( cba )
+ {
+ AknCbaContentObserver::SetContentObserver( cba, callBack );
+ }
+ }
+ }
+
+
+// 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()
+ {
+ 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);
+ if (priority == KWgPriorityOfBlankScreen)
+ {
+ isBlankScreenDisplayed = ETrue;
+ }
+ }
+ }
+ delete wgIds;
+ RDebug::Printf("IsBlankScreenDisplayed():isBlankScreenDisplayed:%d",isBlankScreenDisplayed);
+ return isBlankScreenDisplayed;
+ }
+