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

equal deleted inserted replaced

-:2f259fa3e83a
+:8ca85d2f0db7
 #include <AknTasHook.h> // for testability hooks
 #include "aknformphysics.h"
 #include "aknrecordinggc.h"
 #include <aknphysics.h>
 #include <aknappui.h>
-#include <aknPriv.hrh>
+#include <AknPriv.hrh>
+#include "akntrace.h"
 //
 // Global constants.
 //
 const TInt KSpaceFromTitle=0 ;
 // CEikDialogPage.
 //
 CEikDialogPage::~CEikDialogPage()
 {
+	_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
 // Page observer needs to be nulled or an already deleted instance is
 // called when pointer up event is handled. This is valid only for dialogs
 // that have embedded virtual inputs.
 iPageObserver = NULL;
 delete iPhysics;
 delete iLines;
 delete iScroll;
 delete iExtension;
+_AKNTRACE_FUNC_EXIT;
 }
 CEikDialogPage* CEikDialogPage::NewL(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikDialogPage* self=CEikDialogPage::NewLC(aPageId,aViewWin,aSBFrame,aParent,aPageObserver);
 CleanupStack::Pop();
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 void CEikDialogPage::CommonConstructCodeBetweenNewL(CEikDialogPage& aDialogPage, const CEikDialogPageContainer& aParent)
 {
 aDialogPage.CopyControlContextFrom(&aParent);
 };
 CEikDialogPage* CEikDialogPage::NewLC(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikDialogPage* self=new(ELeave) CEikDialogPage(aPageId,aViewWin,aSBFrame,aPageObserver);
 CleanupStack::PushL(self);
 CommonConstructCodeBetweenNewL(*self,aParent);
 AKNTASHOOK_ADDL( self, "CEikDialogPage" );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikDialogPage* CEikDialogPage::NewL(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver,TResourceReader& aReader)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikDialogPage* self=CEikDialogPage::NewLC(aPageId,aViewWin,aSBFrame,aParent,aPageObserver,aReader);
 CleanupStack::Pop();
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikDialogPage* CEikDialogPage::NewLC(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver,TResourceReader& aReader)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikDialogPage* self=new(ELeave) CEikDialogPage(aPageId,aViewWin,aSBFrame,aPageObserver);
 CleanupStack::PushL(self);
 CommonConstructCodeBetweenNewL(*self,aParent);
 self->ConstructFromResourceL(aReader);
 AKNTASHOOK_ADDL( self, "CEikDialogPage" );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikDialogPage::CEikDialogPage(TInt aPageId,RWindow& /*aViewWin*/,
 CEikScrollBarFrame& /*aSBFrame*/,MEikDialogPageObserver* aPageObserver)
 : iPageObserver(aPageObserver),
 iPageId(aPageId),iCurrentLine(-1)
 {
+	_AKNTRACE_FUNC_ENTER;
 SetBlank();
 SetComponentsToInheritVisibility();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::ConstructL()
 {
+	_AKNTRACE_FUNC_ENTER;
 iLines=new(ELeave)CEikCapCArray(KLineArrayGranularity);
 SetContainerWindowL( *iPageContainer );
 Window().SetPointerGrab(ETrue);
 Window().SetShadowDisabled(ETrue);
 Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));
 iScroll = new(ELeave)CAknPaneScroll(this);
 iScroll->SetLines(iLines);
 iExtension = CDialogPageExtension::NewL();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::ConstructFromResourceL(TResourceReader& aReader, TBool aFormControl )
 {
+	_AKNTRACE_FUNC_ENTER;
 iFormControl = aFormControl ;
 if ( IsForm() )
 {
 if ( iAvkonAppUi )
 return;
 TResourceReader indirectReader;
 iCoeEnv->CreateResourceReaderLC(indirectReader,indirectRid);
 ConstructFromResourceL(indirectReader);
 CleanupStack::PopAndDestroy();
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 // This section modified to handle FORM structure (which contains DIALOG_LINE structs )
 // There might be lines on the page already
 if (!iScroll)
 {
 iScroll = new(ELeave)CAknPaneScroll(this);
 }
 iScroll->SetLines(iLines);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::ConstructFormFromResourceL( TResourceReader& aReader )
 {
+	_AKNTRACE_FUNC_ENTER;
 iFormFlags = TInt16(aReader.ReadInt16()) ;
 iFormLayout = (iFormFlags&EEikFormUseDoubleSpacedFormat) ? EDouble : ESingle;
 ConstructFromResourceL( aReader, ETrue ) ;
+_AKNTRACE_FUNC_EXIT;
 }
 CCoeControl* CEikDialogPage::CreateLineByTypeL(const TDesC& aCaption,TInt aLineId,TInt aControlType,TAny* aReturnValue)
 {
+	_AKNTRACE_FUNC_ENTER;
 ShowFocus( EFalse, EFalse ) ;  // Turn the focus off the current line.
 CEikCaptionedControl* line=new(ELeave) CEikCaptionedControl;
 CleanupStack::PushL(line);
 line->SetComponentsToInheritVisibility();
 // Try to insert line above the currently selected line.  If no line is currently selected then append (TimW 22/5/00)
 ChangeFocusTo( targetLine );
 // physics engine needs to be updated when lines are added after the initial layout
 UpdatePhysics();
+_AKNTRACE_FUNC_EXIT;
 return line->iControl;
 }
 CEikCaptionedControl* CEikDialogPage::ConstructLineL(TInt aResourceId)
 {
+	_AKNTRACE_FUNC_ENTER;
 TResourceReader resourceReader;
 iCoeEnv->CreateResourceReaderLC(resourceReader,aResourceId);
 CEikCaptionedControl* line=ConstructLineL(resourceReader);
 CleanupStack::PopAndDestroy(); // resourceReader
+_AKNTRACE_FUNC_EXIT;
 return line;
 }
 CEikCaptionedControl* CEikDialogPage::ConstructLineL(TResourceReader& aReader)
 {
+	_AKNTRACE_FUNC_ENTER;
 CEikCaptionedControl* line=new(ELeave) CEikCaptionedControl;
 CleanupStack::PushL(line);
 line->iIsFormControl=iFormControl;
 line->SetComponentsToInheritVisibility();
 TInt controlType=aReader.ReadInt16();
 ConstructByTypeL(controlType,line,this);
 line->ConstructFromResourceL(*reader);
 if (indirectRid)
 CleanupStack::PopAndDestroy();
 CleanupStack::Pop(); // line
+_AKNTRACE_FUNC_EXIT;
 return line;
 }
 void CEikDialogPage::ConstructByTypeL(TInt aType,CEikCaptionedControl* aLine,CCoeControl* aContainer)
 {
+	_AKNTRACE_FUNC_ENTER;
 SEikControlInfo controlInfo=EikControlFactory::CreateByTypeL(aType);
 if (!controlInfo.iControl)
 controlInfo=CreateCustomControlL(aType);
 aLine->iIsFormControl=iFormControl;
 aLine->iControl=controlInfo.iControl;
 {
 HBufC* tmp=iCoeEnv->AllocReadResourceLC(controlInfo.iTrailerTextId);
 aLine->SetTrailerL(tmp->Des());
 CleanupStack::PopAndDestroy(); // tmp
 }
+_AKNTRACE_FUNC_EXIT;
 }
 SEikControlInfo CEikDialogPage::CreateCustomControlL(TInt aControlType)
 {
 ASSERT(iPageObserver);
 return iPageObserver->CreateCustomControlL(aControlType);
 }
 void CEikDialogPage::SetActiveL()
 {
+	_AKNTRACE_FUNC_ENTER;
 ActivateL();
 MakeVisible(ETrue);
 if(AknLayoutUtils::PenEnabled())
 {
 );
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::SetActiveAndFocusL()
 {
+	_AKNTRACE_FUNC_ENTER;
 SetActiveL();
 SetEditableL(iIsEditable, ETrue);
 //When active a page, need to show the focus in that page.
 ShowFocus( ETrue, EFalse ) ;
 // Display the focus on the current line
 SetInitialFocus() ;
 }
 ExposeLine( iCurrentLine, EFalse );
 UpdateScrollBarL();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::SetInactiveL()
 {
+	_AKNTRACE_FUNC_ENTER;
 MakeEdwinScrollbarsVisibleL(EFalse);
 MakeVisible(EFalse);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::MakeEdwinScrollbarsVisibleL(TBool aVisible)
 {
+	_AKNTRACE_FUNC_ENTER;
 const TInt numLines=iLines->Count();
 for (TInt ii=0;ii<numLines;ii++)
 {
 CEikCaptionedControl* thisLine=(*iLines)[ii];
 const TInt controlType(thisLine->iControlType);
 for (TInt jj=0;jj<count;jj++)
 frame->ComponentControl(jj)->MakeVisible(aVisible);
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikDialogPage::PageId() const
 {
 return iPageId;
 return KErrNotFound;
 }
 TBool CEikDialogPage::SetInitialFocus()
 {
+	_AKNTRACE_FUNC_ENTER;
 TBool focusSet=EFalse;
 const TInt numLines=iLines->Count();
 for (TInt ii=0;ii<numLines;ii++)
 {
 		iLines->MoveLineToScreen( ii, iPhysics->ViewTopY(), ETrue );
 }
 break;
 }
 iExtension->iSetInitialFocusDone = ETrue;
+_AKNTRACE( "return focusSet;: [%d]", focusSet );
+_AKNTRACE_FUNC_EXIT;
 return focusSet;
 }
 TKeyResponse CEikDialogPage::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
 {
+	_AKNTRACE_FUNC_ENTER;
 TKeyResponse response=EKeyWasNotConsumed;
 if (!(PageContainer()->PageSelector()->Dialg()->DialogFlags() & EEikDialogFlagDontEatUpDownEvents))
 {
 if (aType != EEventKey)
-return response;
+	{
+_AKNTRACE_FUNC_EXIT;
+return response;
+	}
 }
 const TInt numLines=iLines->Count();
 if ((iCurrentLine>-1)&&(iCurrentLine<numLines))
 {
 || aKeyEvent.iCode==EKeyTab
 || aKeyEvent.iCode==EKeyNext
 || aKeyEvent.iCode==EKeyPrevious
 ))
 response=OfferUpDownKeyEventL(aKeyEvent,aType,ENonCyclic);
+_AKNTRACE_FUNC_EXIT;
 return response;
 }
 TKeyResponse CEikDialogPage::OfferUpDownKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType,TFocusNavigationMode aFocusNavigationMode)
 {
+	_AKNTRACE_FUNC_ENTER;
 TKeyResponse response=EKeyWasNotConsumed;
 if (aType==EEventKey)
 {
 const TInt numLines=iLines->Count();
 if ((iCurrentLine>-1)&&(iCurrentLine<numLines))
 }
 }
 if (response==EKeyWasConsumed)
 UpdateScrollBarThumb();
+_AKNTRACE_FUNC_EXIT;
 return response;
 }
 TKeyResponse CEikDialogPage::HandleNonCyclicFocusNavigationKeyL(const TKeyEvent& aKeyEvent)
 {
 return ownsLine;
 }
 void CEikDialogPage::SetDimmed(TBool aDimmed)
 {
+	_AKNTRACE_FUNC_ENTER;
 CCoeControl::SetDimmed(aDimmed);
 const TInt numLines=iLines->Count();
 for (TInt ii=0;ii<numLines;ii++)
 {
 CEikCaptionedControl* thisLine=(*iLines)[ii];
 thisLine->iControl->SetDimmed(aDimmed);
 thisLine->CheckDimmedDisplayState();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikDialogPage::RotateFocusByL(TInt aDelta)
 {
+	_AKNTRACE_FUNC_ENTER;
 TInt numLines=iLines->Count();
 if (numLines == 0)
+{
+_AKNTRACE_FUNC_EXIT;
 return(EFalse);
+}
 // If form is in view mode and highlight is hidden then the first
 // navigation key press just displays the highlight.
 if ( IsForm() && !IsEditable() && !HighlightVisible() )
 {
 {
 iExtension->iLastTouchedLine = lineIndex;
 HandleHighlightTimer();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 TInt max=numLines-1;
 TInt currentLine=iCurrentLine;
 continue;
 ChangeFocusToAndExposeL(currentLine);
 LineChangedL((*iLines)[currentLine]->iId);
 iExtension->iFocusedClicked = ETrue;
+_AKNTRACE_FUNC_EXIT;
 return(ETrue);
 }
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 void CEikDialogPage::ChangeFocusToAndExposeL( TInt aLine, TBool /*aShowWholeControl*/ )
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "CEikDialogPage::ChangeFocusToAndExposeL() aLine: [%d]", aLine );
 if ( aLine < 0 || aLine == iCurrentLine )
+{
+_AKNTRACE_FUNC_EXIT;
 return;
+}
 TInt oldLine = iCurrentLine;
 if( aLine != iCurrentLine )
 (*iLines)[iCurrentLine]->ScrollBackEditor();
 ShowFocus(ETrue, EFalse);
 }
 DrawDeferred();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikDialogPage::TopFocusableLine() const
 {
 const TInt numLines=iLines->Count();
 return KErrNotFound;
 }
 TBool CEikDialogPage::LineIsFocusable(TInt aLine) const
 {
+	_AKNTRACE_FUNC_ENTER;
 TBool focusable(ETrue);
 CEikCaptionedControl* line=(*iLines)[aLine];
 if (line->IsNonFocusing() || line->IsDimmed() || !(line->IsVisible()))
 focusable=EFalse;
+_AKNTRACE( "focusable: [%d]", focusable );
+_AKNTRACE_FUNC_EXIT;
 return focusable;
 }
 void CEikDialogPage::SetDensePacking(TBool aDensePacking)
 {
 iLines->SetDensePacking(aDensePacking);
 }
 void CEikDialogPage::InsertLineL(TInt aPosition,TInt aResourceId)
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "aPosition: [%d]", aPosition );
 // alteration is bloated but should not provide any side-effects.
 if (!iFormControl)
 {
 CEikCaptionedControl* line=ConstructLineL(aResourceId);
 CleanupStack::PushL(line);
 iCurrentLine should be increased as it is relative to the lines in that page
 and we have just added a new line before it in the page.
 */
 if (iCurrentLine>=aPosition)
 iCurrentLine++;
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::DeleteLine(TInt aLineId, TBool aRedraw)
 {
+	_AKNTRACE_FUNC_ENTER;
 TInt index( LineIndex( aLineId ) ) ;
+	_AKNTRACE( "Delete line index: [%d]", index );
 if ( index == iCurrentLine ) // we're deleting the current line
 {
 // If this is the last line then move the focus to the line above.  (becomes -1 if last line)
 if( iCurrentLine == iLines->Count() - 1 )
 iCurrentLine-- ;
 }
 DrawNow();
 TRAP_IGNORE(UpdateScrollBarL()); // if OOM, scrollbar will not be updated - No great loss.
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::AdjustAllIds(TInt aControlIdDelta)
 {
 iLines->AdjustAllIds(aControlIdDelta);
 }
 TInt CEikDialogPage::FocusLineL(TInt aLineId)
 {
+_AKNTRACE_FUNC_ENTER;
 TInt lineIndex=LineIndex(aLineId);
+_AKNTRACE( "Delete line index: [%d]", lineIndex );
 if (lineIndex==KErrNotFound)
 return KErrNotFound;
 PrepareForFocusTransitionL();
 // Show whole line, not scroll into line.
 ChangeFocusToAndExposeL(lineIndex, ETrue);
 LineChangedL(aLineId);
+_AKNTRACE_FUNC_EXIT;
 return KErrNone;
 }
 TInt CEikDialogPage::FocusedLineId() const
 {
 TInt CEikDialogPage::LineToYPos(TInt& aLine) const
 //
 // Calcs YPos of line relative to the ViewWin and adjusts aLine if its out of bounds
 {
+	_AKNTRACE_FUNC_ENTER;
 ASSERT(iLines);
 const TInt numLines=iLines->Count();
 ASSERT(numLines>0);
 if (aLine<0)
 aLine=0;
 else if (aLine>=numLines)
 aLine=numLines-1;
+_AKNTRACE( "[%s][%s][%d]", "CEikDialogPage", __FUNCTION__, (*iLines)[aLine]->Position().iY );
+_AKNTRACE_FUNC_EXIT;
 return (*iLines)[aLine]->Position().iY; // TPREMOVAL +iDataWinPos.iY;
 }
 void CEikDialogPage::ExposeLine(TInt aLine, TBool aForceResize, TBool aShowWholeLine)
 //
 /* Exposes the given line so that its fully visible in the ViewWin
 */  {
+	_AKNTRACE_FUNC_ENTER;
 if ( iSize.iHeight == 0 || aLine == -1 )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CAknPaneScroll::TScrollChangeType change = iScroll->ExposeLine( aLine, aShowWholeLine );
 if ( change == CAknPaneScroll::ENoChange && !aForceResize )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CEikCaptionedControl* capCtrl = (*iLines)[aLine];
 capCtrl->MinimumSize();
 if ( aLine != iLastExposedLine )
 {
 iLastExposedLine = aLine;
 iLastExposedLineViewWinYPosition = topYPosOfControlWhichMustBeViewable + idealDataWindowPosition;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::SetDataPosition( TInt aTopY, TInt aBottomY, TBool aForceResize )
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "[%s][%s] aTopY: [%d]", "CEikDialogPage", __FUNCTION__, aTopY );
 // update rect only if the currently focused control doesn't fit
 if ( iFormControl )
 {
 TInt topY = iPhysics->ViewTopY();
 TInt maxBottomY = topY + iSize.iHeight;
 iPhysics->SetViewCenter( viewCenter );
 iLines->MoveLineToScreen( iCurrentLine, iPhysics->ViewTopY(), ETrue );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /*
 class CDummy: public CCoeControl
 {
 return (*iLines)[aLineIndex]->Size().iHeight;
 }
 void CEikDialogPage::SizeChanged()
 {
+	_AKNTRACE_FUNC_ENTER;
 // update form area's size to scroll control
 iScroll->SetOutsideRect( Rect() );
 iLines->SetRect( Rect(), iScroll->Top(), iScroll->Middle(), iScroll->Bottom() );
 if ( (iLines->Count() > 0 ) && ( iCurrentLine >= 0 ) )
 TRAP_IGNORE( UpdateScrollBarL() ); // ignore any errors.
 AknsUtils::RegisterControlPosition( this );
 UpdatePhysics();
 iExtension->iInitialLayoutDone = ETrue;
+_AKNTRACE_FUNC_EXIT;
 }
 TSize CEikDialogPage::MinimumSize()
 {
+	_AKNTRACE( "[%s][%s] MinimumSize: w = %d, h = %d.",
+	                "CEikDialogPage", __FUNCTION__, iLines->MinimumSize().iWidth, 0 );
 return TSize( iLines->MinimumSize().iWidth, 0 );   // Can be zero height
 }
 void CEikDialogPage::PrepareForFocusLossL()
 {
 * From MEikEdwinObserver. Look for navigation and editor text update events, as scrolling
 might be required to keep cursor visible.
 */
 void CEikDialogPage::HandleEdwinEventL(CEikEdwin* aEdwin,TEdwinEvent aEventType)
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( IsForm() && ( aEventType == EEventTextUpdate
 || aEventType == EEventTextUpdateAPI ) )
 {
 CEikCaptionedControl* line = NULL;
 TInt controlType = -1;
 }
 }
 }
 if( iCurrentLine == iLastExposedLine || iCurrentLine == -1 )
+{
+_AKNTRACE_FUNC_EXIT;
 return;
+}
 if( aEventType == EEventNavigation || aEventType == EEventTextUpdate )
 {
 ExposeLine( iCurrentLine, EFalse );
 UpdateScrollBarL();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Handle events caused by popup field controls, and resize if necessary
 */
 void CEikDialogPage::HandlePopupFieldEventL(CAknPopupField* aPopupField, TAknPopupFieldEvent aEventType, TInt /*aHint*/)
 {
+	_AKNTRACE_FUNC_ENTER;
 switch (aEventType)
 {
 case EAknPopupFieldEventValueChange:
 {
+_AKNTRACE( "[%s][%s][%d] EAknPopupFieldEventValueChange",
+		   "CEikDialogPage", __FUNCTION__, __LINE__ );
 CEikCaptionedControl* line = NULL;
 for ( TInt i = 0; i < iLines->Count(); ++i )
 {
 line = (*iLines)[i];
 if ( line->iControl == aPopupField )
 }
 break;
 }
 case EAknPopupFieldEventModeChange:
 {
+_AKNTRACE( "[%s][%s][%d] EAknPopupFieldEventModeChange",
+		   "CEikDialogPage", __FUNCTION__, __LINE__ );
 TInt index = iCurrentLine;
 if(iIsEditable && (iExtension->iPopFieldEvents != 0))
 {
 iExtension->iPopFieldEvents = 0;
 break;
 }
 default:
 break;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::PrepareToDrawVerticalLine() const
 { // to avoid flushes, we resize skin frame bitmaps before actual draw.
 // NOTE, this should be possiblie to call from SizeChanged() or OfferKeyEventL() method :-) (the GC?)
 {
 }
 void CEikDialogPage::HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType)
 {
+	_AKNTRACE_FUNC_ENTER;
 switch (aEventType)
 {
 case EEventPrepareFocusTransition:
 PrepareForFocusTransitionL();
 break;
 case EEventRequestCancel:
 case EEventInteractionRefused:
 default:
 break;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::PassOnEventL(CCoeControl* aControl,MCoeControlObserver::TCoeEvent aEvent)
 {
 MCoeControlObserver* observer=Observer();
 }
 void CEikDialogPage::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)
 {
+	_AKNTRACE_FUNC_ENTER;
 iExtension->iHandlingScrollEvent = ETrue;
 switch (aEventType)
 {
 case EEikScrollPageUp:
 default:
 break;
 }
 iExtension->iHandlingScrollEvent = EFalse;
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikDialogPage::LineHandlerCalled() const
 {
 return iExtension->iFlags.IsSet( CDialogPageExtension::ELineHandlerCalled );
 return mainPaneRect;
 }
 void CEikDialogPage::UpdateScrollBarL()
 {
+	_AKNTRACE_FUNC_ENTER;
 // Only forms in S60 need dialog's scrollbar.
 if ( !iFormControl || !iPageContainer->ScrollBar() || iSize.iHeight == 0 || iSize.iWidth == 0 || iExtension->iHandlingScrollEvent )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CAknScrollBar* scrollBar = STATIC_CAST(CAknScrollBar*, iPageContainer->ScrollBar()->VerticalScrollBar());
 	if(ctrl->ControlIsAPopfield(ctrl->iControlType))
 				{
 	            CAknPopupField::EAknPopupFieldSelectionMode mode = ((CAknPopupField*)ctrl->iControl)->SelectionMode();
 	            if (mode == CAknPopupField::EAknPopupFieldSelectionListMode)
 	                {
+	                _AKNTRACE_FUNC_EXIT;
 	                return;
 	                }
 				}
 	UpdateScrollBarThumb();
 	}
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::UpdateScrollBarThumb()
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( !iFormControl || !iPageContainer->ScrollBar() || ScbState() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CAknScrollBar* scrollBar = STATIC_CAST(CAknScrollBar*, iPageContainer->ScrollBar()->VerticalScrollBar());
 iExtension->iPreviousThumbPosition = vertModel.iThumbPosition;
 TRAP_IGNORE(scrollBar->SetModelL(&vertModel)); // won't leave now, but can't guarantee forever
 iPageContainer->ScrollBar()->Tile(&vertModel);
 iPageContainer->ScrollBar()->SetVFocusPosToThumbPos(vertModel.iThumbPosition);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 CCoeControl* CEikDialogPage::ComponentControl(TInt aIndex) const
 {
 if ( IsForm() && !iExtension->iHandlingResourceChange)
 PrepareToDrawVerticalLine();
 }
 void CEikDialogPage::ShowFocus(TBool aFocus, TBool aRedraw)
 {
+	_AKNTRACE_FUNC_ENTER;
 if (iCurrentLine>=0)
 {
 if ( iExtension && iExtension->iUsesSingleClick && aFocus )
 {
 aFocus = HighlightVisible();
 if (aRedraw)
 (*iLines)[iCurrentLine]->DrawNow();
 else
 (*iLines)[iCurrentLine]->DrawDeferred();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::ChangeFocusTo(TInt aLineIndex)
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "CEikDialogPage::ChangeFocusTo() aLineIndex: [%d]", aLineIndex );
 TInt oldLine = iCurrentLine;
 if (aLineIndex==iCurrentLine)
 return;
+// If current line has settingslist open, close it
+CEikCaptionedControl* currentLine = CurrentLine();
+if ( currentLine &&
+currentLine->ControlIsAPopfield( currentLine->ControlType() ) )
+{
+CAknPopupField *field = ( CAknPopupField* )currentLine->iControl;
+if ( field && field->SelectionMode()
+== CAknPopupField::EAknPopupFieldSelectionListMode )
+{
+TRAP_IGNORE( field->CloseSelectionListL() );
+}
+}
 ShowFocus( EFalse, EFalse );
 iCurrentLine=aLineIndex;
 ShowFocus(ETrue, EFalse );
 if ( ( oldLine != iCurrentLine && IsForm() ) &&
 }
 		RecordLineL( iCurrentLine );
 		iLines->MoveLineToScreen( iCurrentLine, iPhysics->ViewTopY(), ETrue );
 		}
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikDialogPage::FindLineIndex(const CCoeControl* aControl) const
 {
 return(iLines->FindLineIndex(aControl));
 * Handles a change to the control's resources of type aType
 * which are shared across the environment, e.g. colors or fonts.
 */
 void CEikDialogPage::HandleResourceChange(TInt aType)
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( aType==KEikDynamicLayoutVariantSwitch )
 {
 const TInt numLines=iLines->Count();
 for ( TInt i=0; i < numLines; i++ )
 {
 default:
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 CCoeControl* CEikDialogPage::Control(TInt aLineId) const
 {
 return(Line(aLineId)->iControl);
 return NULL;
 }
 void CEikDialogPage::FocusChanged(TDrawNow /*aDrawNow*/)
 {
+	_AKNTRACE_FUNC_ENTER;
 if (iCurrentLine>=0 && !IsFocused())
 {
 CEikCaptionedControl* currentLine=(*iLines)[iCurrentLine];
 currentLine->SetCurrent(EFalse);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::ResetLineMinimumSizes()
 {
 iLines->ResetMinimumSizes();
 }
 void CEikDialogPage::SetEditableL( TBool aEditable, TBool /*aActivePage*/ )
 {
 // Tell each of the controls on the page (which are part of a form) of their editable state.
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE( "CEikDialogPage::SetEditableL() aEditable: [%d]", aEditable );
 iIsEditable = aEditable;
 HighlightVisible( aEditable );
 if ( iExtension->iUsesSingleClick && iExtension->iSetInitialFocusDone )
 if ((iLines->Count()>0) && (iCurrentLine >= 0))
 {
 ExposeLine(iCurrentLine,ETrue);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikDialogPage::AnythingToDisplay() const
 {
 // assume Form control... shouldnt be called otherwise (Panic?)
 CleanupStack::PopAndDestroy(); // finished with current val of dataBuffer
 }
 void CEikDialogPage::Draw(const TRect& /*aRect*/) const
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( iFormControl )
 {
 // added this to see if anything on the page is visible.
 // if not, this is used to display the No data found screen.
 TBool anythingToShow= AnythingToDisplay();
 }
 iExtension->iRecordingGc->FlushBuffer( targetRect, lineToSkip );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPage::AfterAddingNewLinesL(TInt aNewLineAdded)
 {
 /**
 *   #1 register the the dialog page with the caption control.
 *   #2 register the control on this line (e.g. an edwin) with the one above it
 *   #3 call Register component on the line, to set up listeners, etc.
 *   #4 Set the editable value to whatever the dialog page's editable value is.
 */
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "aNewLineAdded: [%d]", aNewLineAdded );
 __ASSERT_DEBUG(iLines && (aNewLineAdded<=iLines->Count()), Panic(EEikDialogPanicErrorDuringAddingLine));
 if (aNewLineAdded== -1)
+{
+_AKNTRACE_FUNC_EXIT;
 return; // line has not been added yet.
+}
 CEikCaptionedControl* lineAdded = iLines->At(aNewLineAdded);
 // if aNewLineAdded is zero, then there is no line above, else set value.
 CEikCaptionedControl* lineVisuallyAboveAndNumericallyBelow =
 (!aNewLineAdded)? 0:iLines->At(aNewLineAdded-1);
 // #1
 ExposeLine( aNewLineAdded, EFalse );
 if ( IsForm() && iSize.iHeight != 0 && aNewLineAdded != -1 )
 iLines->MoveLineToScreen( aNewLineAdded, iPhysics->ViewTopY(), EFalse );
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikDialogPage::GetFormFlags() const
 {return iFormFlags;};
 // CEikDialogPage::HandleFormPointerEventL
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::HandleFormPointerEventL( const TPointerEvent& aPointerEvent )
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( LineHandlerCalled() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TInt touchedLine = iLines->YPositionToLineIndex( aPointerEvent.iPosition.iY + iPhysics->ViewTopY() );
 TBool callDefaultImplementation = ETrue;
 // Tapping form's empty area takes no action of any kind. Also bounce
 // effect can't be stopped.
 if ( ( aPointerEvent.iType == TPointerEvent::EButton1Down && touchedLine == KErrNotFound ) || !iPhysics->CanBeStopped() )
 {
 IgnoreEventsUntilNextPointerUp();
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CEikCaptionedControl* newLine = NULL;
 TInt controlType = KErrNotFound;
 }
 }
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down && touchedLine != KErrNotFound )
 {
+_AKNTRACE( "TPointerEvent::EButton1Down" );
 iExtension->iOldCenterY = iPhysics->ViewCenter().iY;
 TInt bottom = iExtension->iOldCenterY + iSize.iHeight - iSize.iHeight / 2;
 if ( bottom < 0 )
 {
 iExtension->iBottomItem = -1;
 }
 }
 if ( aPointerEvent.iType == TPointerEvent::EDrag )
 {
+_AKNTRACE( "TPointerEvent::EDrag" );
 TPoint drag( iExtension->iDragStartPosition - aPointerEvent.iPosition );
 if ( Abs( drag.iY ) > iPhysics->DragThreshold() )
 {
 iExtension->iHighlightTimer->Cancel();
 }
 }
 if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
 {
+_AKNTRACE( "TPointerEvent::EButton1Up" );
 iExtension->HandleFormFeedback( this, aPointerEvent, touchedLine, iCurrentLine );
 if ( !IsEditable() && iExtension->iUsesSingleClick &&
 HighlightVisible() )
 {
 HighlightVisible( EFalse );
 key.iCode=EKeyOK;
 key.iModifiers=0;
 key.iRepeats = 0;
 CEikonEnv::Static()->SimulateKeyEventL( key, EEventKey );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::UpdatePhysics
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::UpdatePhysics()
 {
+	_AKNTRACE_FUNC_ENTER;
 if ( IsForm() )
 {
 TPoint viewCenter( iSize.iWidth / 2, 0 );
 if ( iLines->Count() > 0 )
 worldSize.iHeight = Max( worldSize.iHeight, iSize.iHeight );
 TRAP_IGNORE( iPhysics->InitPhysicsL( worldSize, iSize, viewCenter ) );
 TRAP_IGNORE( UpdateScrollBarL() );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::HighlightTimerCallBack
 // CEikDialogPage::UpdateLineInCache
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::UpdateLineInCache( CEikCaptionedControl* aLine )
 {
+	_AKNTRACE_FUNC_ENTER;
 TInt lineIndex = iLines->FindLineIndex( aLine );
 if ( lineIndex != KErrNotFound )
 {
 if ( aLine->Position() != TPoint( 1000, 0 ) )
 if ( iExtension->iInitialLayoutDone )
 {
 UpdatePhysics();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::Synchronize
 // CEikDialogPage::RecordLinesL
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::RecordLinesL()
 {
+	_AKNTRACE_FUNC_ENTER;
 Parent()->Parent()->Parent()->SetCustomGc( iExtension->iRecordingGc );
 iExtension->iRecordingGc->PurgeBuffer();
 CEikCaptionedControl* line = NULL;
 line->DrawForeground( line->Rect() );
 DrawControl( line );
 }
 Parent()->Parent()->Parent()->SetCustomGc( NULL );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::RecordLineL
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::RecordLineL( TInt aLine )
 {
+	_AKNTRACE_FUNC_ENTER;
+	_AKNTRACE( "CEikDialogPage::RecordLineL() aLine: [%d]", aLine );
 Parent()->Parent()->Parent()->SetCustomGc( iExtension->iRecordingGc );
 CEikCaptionedControl* line = (*iLines)[aLine];
 if ( line )
 line->DrawForeground( (line->Rect() ) );
 DrawControl( line );
 }
 Parent()->Parent()->Parent()->SetCustomGc( NULL );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::ScrollByPixels
 ASSERT(EFalse); // aPageIndex not found.
 }
 TInt CEikDialogPageContainer::ActivateFirstPageL()
 {
+	_AKNTRACE_FUNC_ENTER;
 // Activate first page that isn't dimmed.
 // SetToolTips() ;
 const TInt numPages=iPageArray->Count();
 for (TInt ii=0;ii<numPages;ii++)
 {
 if(iActivePage!=ii)
 {
 thisPage->ReportPageChangedL();
 iActivePage=ii;
 }
+_AKNTRACE_FUNC_EXIT;
 return thisPage->PageId();
 }
 }
 // All dimmed, so activate first.
 if(iActivePage!=0)
 {
 firstPage->ReportPageChangedL();
 iActivePage=0;
 }
+_AKNTRACE_FUNC_EXIT;
 return firstPage->PageId();
 }
 TInt CEikDialogPageContainer::PageId(TInt aIndex) const
 return preferredSize;
 }
 void CEikDialogPageContainer::ActivateL()
 {
+	_AKNTRACE_FUNC_ENTER;
 // Pass the activate event to child controls always.
 CCoeControl::ActivateL();
 //
 // Have to do this here instead of CEikCaptionedControl::ActivateL, because CaptionedControl has no
 // activateL overridden.
 );
 }
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikDialogPageContainer::FocusChanged(TDrawNow aDrawNow)
 {
 (*iPageArray)[iActivePage]->SetFocus(IsFocused(),aDrawNow);

branch	RCL_3
changeset 4	8ca85d2f0db7
parent 0	2f259fa3e83a
child 9	aabf2c525e0f