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

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 #include "aknformphysics.h"
 #include "aknrecordinggc.h"
 #include <aknphysics.h>
 #include <aknappui.h>
 #include <AknPriv.hrh>
+#include "akntrace.h"
 //
 // Global constants.
 //
 const TInt KSpaceFromTitle=0 ;
 NONSHARABLE_CLASS(CDialogPageExtension) : public CBase
 {
 public:
 enum TFlags
 {
-ELineHandlerCalled
+ELineHandlerCalled,
+EDragEventsAllowed  // turned on when dragging is allowed
 };
 static CDialogPageExtension* NewL();
 ~CDialogPageExtension();
-void Feedback( CEikDialogPage* aControl, TTouchLogicalFeedback aFeedback ) const;
+void Feedback( const CEikDialogPage& aControl,
+TTouchLogicalFeedback aFeedback ) const;
 /**
-* Produces vibra-only feedback. Event filtering by pointer event is used..
+* Produces vibra-only feedback.
+* Event filtering by pointer event is used.
 */
-void SilentFeedback( CEikDialogPage* aDPage,
+void SilentFeedback( const CEikDialogPage& aDPage,
 TTouchLogicalFeedback aFeedback,
 const TPointerEvent& aPointerEvent ) const;
-void HandleFormFeedback( CEikDialogPage* aControl, const TPointerEvent& aPointerEvent, TInt aTouchedLineIndex, TInt aCurrentLine );
+/**
+* Produces feedback in cases where the captioned control itself
+* doesn't do it.
+*/
+void HandleFormFeedback( const CEikDialogPage& aDPage,
+const TPointerEvent& aPointerEvent,
+TInt aTouchedLineIndex,
+TInt aCurrentLine );
 protected:
 void ConstructL();
 private:
 public:
 TInt iPopFieldEvents;
 TBool iExternalScrollbar;
 TBool iIsDoubleQuery;
 TBool iFocusedClicked;
-TInt iPreviousThumbPosition;
 TBool iPreviousThumbDirection;
 MTouchFeedback* iFeedback;
 TBitFlags iFlags;
 /**
 * @c iDestroyedPtr is used for the object destruction check.
 TBool iHandlingScrollEvent;
 CPeriodic* iHighlightTimer;
 TInt iLastTouchedLine;
 TPoint iSynchronizedPosition;
 TBool iScrolling;
-TBool iScrolled;
 TBool iInitialLayoutDone;
+TBool iSetInitialFocusDone;
 TBool iHandlingResourceChange;
 TInt iCapturingItem;
 // record the center point Y value of current view when touch down an item
 TInt iOldCenterY;
 // top item in current view, -1 if item's Y is negative
 * Boolean used to check if application is single touch compatible.
 */
 TBool iUsesSingleClick;
 // It is used to distinguish if the focus item has changed.
 TBool iFocusItemChanged;
+// Boolean to check if form was scrolling on button down
+TBool iWasScrolling;
 };
 CDialogPageExtension::CDialogPageExtension()
 {
 }
 iHighlightTimer = CPeriodic::NewL( CActive::EPriorityStandard );
 iCapturingItem = KErrNotFound;
 }
 void CDialogPageExtension::HandleFormFeedback(
-CEikDialogPage* aDPage,
+const CEikDialogPage& aDPage,
 const TPointerEvent& aPointerEvent,
 TInt aTouchedLineIndex,
 TInt aCurrentLine )
 {
-// note, that iFormControl is checked in Feedback()
+CEikCaptionedControl* firstLine( aDPage.LineOnPageOrNull( 0 ) );
-if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&
-aCurrentLine != aTouchedLineIndex && aDPage->LineOnPageOrNull( 0 ) )
+if( aDPage.IsEditable() )
 {
-// feedback for edit/view mode form, when non-focused line is clicked
+// note, that iFormControl is checked in Feedback()
-// feedback for focused item is responsibility of the item
+if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&
-// no feedback with focus change when single click is enabled
+aCurrentLine != aTouchedLineIndex &&
-if ( !iUsesSingleClick )
+firstLine )
 {
-Feedback( aDPage, ETouchFeedbackSensitiveItem );
+// feedback for edit mode form, when non-focused line is clicked
-}
+// feedback for focused item is responsibility of the item
-iFocusItemChanged = ETrue;
+// no feedback with focus change when single click is enabled
-}
+if ( !iUsesSingleClick )
+{
-else if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&
+Feedback( aDPage, ETouchFeedbackSensitiveList );
-aTouchedLineIndex == aCurrentLine && aDPage->LineOnPageOrNull( 0 ) )
+}
-{
+iFocusItemChanged = ETrue;
-// Feedback for view mode form, when focused item is
+}
-// clicked. Basically same case as for msk simulation later on
+else if ( firstLine )
-// the function, but on pointer
+{
-// down. iExtension->iFocusedClicked is not valid here, since
+if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&
-// it can't be known in this phase whether user drags pointer
+aTouchedLineIndex == aCurrentLine )
-// away.
+{
-Feedback( aDPage, ETouchFeedbackBasicItem );
+// Feedback for edit mode form, when focused item is
-iFocusItemChanged = EFalse;
+// clicked. Basically same case as for msk simulation later on
-}
+// the function, but on pointer
+// down. iExtension->iFocusedClicked is not valid here, since
-else if ( aPointerEvent.iType == TPointerEvent::EButton1Up &&
+// it can't be known in this phase whether user drags pointer
-aDPage->LineOnPageOrNull( 0 ) )
+// away.
-{// when focus changed, it should not send feedback on up event.
+Feedback( aDPage, ETouchFeedbackList );
-//when up event comes, aTouchedLineIndex always equal to aCurrentLine
+iFocusItemChanged = EFalse;
-if ( !iFocusItemChanged )
+}
-{
+else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
-SilentFeedback( aDPage, ETouchFeedbackBasicItem, aPointerEvent );
+{
-}
+// When focus changed, it should not send feedback on up event.
-}
+// When up event comes, aTouchedLineIndex always equal to
-}
+// aCurrentLine.
+if ( !iFocusItemChanged )
-void CDialogPageExtension::Feedback( CEikDialogPage* aDPage,
+{
+SilentFeedback( aDPage, ETouchFeedbackList, aPointerEvent );
+}
+}
+}
+}
+}
+void CDialogPageExtension::Feedback( const CEikDialogPage& aDPage,
 TTouchLogicalFeedback aFeedback ) const
 {
-if ( aDPage
+if ( iFeedback &&
-&& aDPage->IsForm()
+aDPage.IsForm() &&
-&& iFeedback
+!aDPage.IsDimmed() &&
-&& !aDPage->IsDimmed()
+aDPage.IsVisible() )
-&& aDPage->IsVisible() )
 {
 iFeedback->InstantFeedback( aFeedback );
 }
 }
-void CDialogPageExtension::SilentFeedback( CEikDialogPage* aDPage,
-TTouchLogicalFeedback aFeedback,
+void CDialogPageExtension::SilentFeedback(
-const TPointerEvent& aPointerEvent ) const
+const CEikDialogPage& aDPage,
-{
+TTouchLogicalFeedback aFeedback,
-if ( aDPage
+const TPointerEvent& aPointerEvent ) const
-&& aDPage->IsForm()
+{
-&& iFeedback
+if ( iFeedback &&
-&& !aDPage->IsDimmed()
+aDPage.IsForm() &&
-&& aDPage->IsVisible() )
+!aDPage.IsDimmed() &&
-{
+aDPage.IsVisible() )
-iFeedback->InstantFeedback( aDPage, aFeedback, ETouchFeedbackVibra, aPointerEvent );
+{
-}
+iFeedback->InstantFeedback( &aDPage,
-}
+aFeedback,
+ETouchFeedbackVibra,
+aPointerEvent );
+}
+}
 class CAknPaneScroll : public CBase
 {
 public:
 enum TScrollChangeType
 // 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
 iLines->AppendL(thisLine);
 CleanupStack::Pop(); // thisLine
 thisLine->iIsFormControl = aFormControl ;
 if ( aFormControl )
 {
-thisLine->GetAknLayoutValuesL() ;   // should cause the control to have size.
 if ( iFormFlags )
 thisLine->SetFormFlags( iFormFlags ) ;
 }
 // allow the caption to know the one above itself
 AfterAddingNewLinesL(iLines->LineIndexFromId(thisLine->iId));
 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())
 {
 AknsUtils::RegisterControlPosition(capCtrl->iCaption);
 AknsUtils::RegisterControlPosition(capCtrl->iControl);
 AknsUtils::RegisterControlPosition(capCtrl->iTrailer);
 AknsUtils::RegisterControlPosition(capCtrl->iBitmap);
 if ( capCtrl->iIsFormControl && iCurrentLine != i)
 {
+if (capCtrl->ControlIsAnEdwin(capCtrl->iControlType))
-if (capCtrl->ControlIsAnEdwin(capCtrl->iControlType))
+{
-{
+CEikEdwin *edwin = (CEikEdwin*)capCtrl->iControl;
-CEikEdwin *edwin = (CEikEdwin*)capCtrl->iControl;
+TRAP_IGNORE( edwin->TextView()->SetDocPosL( 0 ) );
-TRAP_IGNORE(edwin->TextView()->SetDocPosL(0)
+}
-);
+}
 }
-}
+_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++)
 {
 CEikCaptionedControl* line=(*iLines)[ii];
 if (line->IsNonFocusing() || line->IsDimmed() || !(line->IsVisible()))
 continue;
 ChangeFocusTo(ii);
 focusSet=ETrue;
-if ( IsForm() )
-{
-// move line with initial focus to the screen
-		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))
 iExtension->iFocusedClicked = ETrue;
 switch (aFocusNavigationMode)
 {
 case ECyclic:
-iExtension->iScrolled = ETrue;
 response=HandleCyclicFocusNavigationKeyL(aKeyEvent);
 break;
 case ENonCyclic:
-iExtension->iScrolled = ETrue;
 response=HandleNonCyclicFocusNavigationKeyL(aKeyEvent);
 break;
 default:
 break;
 }
 }
 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();
+(*iLines)[iCurrentLine]->ScrollBackEditorL();
 ChangeFocusTo( aLine );
 ExposeLine( iCurrentLine, EFalse );
 if ( oldLine != iCurrentLine )
 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-- ;
 if (iCurrentLine!=-1)
 {
 TInt targetLine = iCurrentLine ;
 iCurrentLine = -1 ;
 ChangeFocusTo( targetLine ) ;
-ExposeLine( targetLine, EFalse ) ;
+ExposeLine( targetLine, ETrue ) ;
 ShowFocus( ETrue, EFalse ) ;
 }
 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
 {
 }
 return KErrNotFound;
 }
-TInt CEikDialogPage::YPosToLine2(TInt aYPos) const
-{
-return iLines->YPosToLine( Rect(), iScroll->Top(), iScroll->Middle(), iScroll->Bottom(), aYPos );
-}
-TInt CEikDialogPage::LineToYPos(TInt& aLine) const
-//
-// Calcs YPos of line relative to the ViewWin and adjusts aLine if its out of bounds
-{
-ASSERT(iLines);
-const TInt numLines=iLines->Count();
-ASSERT(numLines>0);
-if (aLine<0)
-aLine=0;
-else if (aLine>=numLines)
-aLine=numLines-1;
-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();
 topYPosOfControlWhichMustBeViewable = iLastExposedLineViewWinYPosition;
 bottomYPosOfControlWhichMustBeViewable = topYPosOfControlWhichMustBeViewable + controlHeight;
 }
 }
+// If control height is greater then screen. Make sure that edwin's cursor is visible
+if (controlType == EEikCtEdwin && controlHeight > Rect().Height())
+{
+CEikEdwin* edwin = dynamic_cast<CEikEdwin*>(capCtrl->iControl);
+if (edwin)
+{
+TInt pos = edwin->CursorPos();
+TRect linerect;
+TRAP_IGNORE( linerect = edwin->TextLayout()->GetLineRectL(pos, pos) );
+TPoint capctrlpos = capCtrl->Position();
+TPoint edwinpos = edwin->Position();
+if (edwinpos.iY - capctrlpos.iY + (linerect.iTl.iY + linerect.iBr.iY)/2 > Rect().Height()/2) // cursor not fully visible
+{
+TInt offset = edwinpos.iY - capctrlpos.iY + (linerect.iTl.iY + linerect.iBr.iY)/2 - Rect().Height()/2;
+if (topYPosOfControlWhichMustBeViewable + offset + Rect().Height() <= bottomYPosOfControlWhichMustBeViewable)
+{
+topYPosOfControlWhichMustBeViewable += offset;
+bottomYPosOfControlWhichMustBeViewable = topYPosOfControlWhichMustBeViewable + Rect().Height();
+}
+else
+{
+topYPosOfControlWhichMustBeViewable = bottomYPosOfControlWhichMustBeViewable - Rect().Height();
+}
+}
+else
+{
+bottomYPosOfControlWhichMustBeViewable = topYPosOfControlWhichMustBeViewable + Rect().Height();
+}
+}
+}
 SetDataPosition( topYPosOfControlWhichMustBeViewable, bottomYPosOfControlWhichMustBeViewable, aForceResize );
 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;
+	if ( IsForm() )
+	    {
+iExtension->iInitialLayoutDone = EFalse;
+iScroll->SetOutsideRect( Rect() );
+// force each line to resize
+TInt count = iLines->Count();
+for ( TInt i = 0; i < count; ++i )
+{
+(*iLines)[i]->HandleResourceChange( KEikDynamicLayoutVariantSwitch );
+}
+iLines->SetRect( Rect(), iScroll->Top(), iScroll->Middle(), iScroll->Bottom() );
+iExtension->iInitialLayoutDone = ETrue;
+UpdatePhysics();
+if ( iExtension->iScrolling
+|| iExtension->iFlags.IsSet(
+CDialogPageExtension::EDragEventsAllowed ) )
+{
+iPhysics->Stop();
+Synchronize();
+}
+if ( count > 0 && iCurrentLine != KErrNotFound )
+{
+if ( iLastExposedLine != -1 )
+{
+iLastExposedLineViewWinYPosition =
+iLines->LineIndexToYPosition( iLastExposedLine, 0 );
+}
+ExposeLine( iCurrentLine, ETrue );
+if ( Size() != TSize::EUninitialized )
+{
+(*iLines)[iCurrentLine]->DrawDeferred();
+}
+}
+TRAP_IGNORE( UpdateScrollBarL() ); // ignore any errors.
+AknsUtils::RegisterControlPosition( this );
+_AKNTRACE_FUNC_EXIT;
+return;
+	    }
 // 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;
 {
 RecordLineL( i );
 if ( i != iCurrentLine )
 {
-DrawNow();
+DrawDeferred();
 }
 break;
 }
 }
 }
 }
 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 )
 {
 if ( IsForm() )
 {
 RecordLineL( i );
 }
-DrawNow();
+DrawDeferred();
 break;
 }
 }
 break;
 }
 case EAknPopupFieldEventModeChange:
 {
+_AKNTRACE( "[%s][%s][%d] EAknPopupFieldEventModeChange",
+		   "CEikDialogPage", __FUNCTION__, __LINE__ );
 TInt index = iCurrentLine;
 if(iIsEditable && (iExtension->iPopFieldEvents != 0))
 {
 iExtension->iPopFieldEvents = 0;
 }
 else
 {
 iExtension->iPopFieldEvents = 1;
 }
-ReconsiderPageSize();
+(*iLines)[iCurrentLine]->SetRect( (*iLines)[iCurrentLine]->Rect() );
 ExposeLine( index, ETrue );
 DrawNow();
 UpdateScrollBarL();
 PrepareToDrawVerticalLine();
 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?)
 rectNotToDrawOuter,
 rectNotToDrawInner,
 KAknsIIDQsnFrInput,
 KAknsIIDDefault ) ;
 }
 }
+}
 }
-}
-void CEikDialogPage::DrawVerticalLine() const
-{
-}
 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();
 const TInt maxHeight=iSize.iHeight-(KSpaceFromTitle+KSpaceFromBottom);
 TInt height = aDesirableEdwinSize.iHeight;
 if (height > maxHeight)
 height = maxHeight;
-TSize size = aEdwin->Size();
+TSize size( aEdwin->Size() );
 TInt maximumEdwinHeight = aEdwin->MaximumHeight();
 // ensure maxheight as dynamic construction may be done whilst form is of zero height.
 if ((maximumEdwinHeight > maxHeight) && maxHeight)
 aEdwin->SetMaximumHeight(maxHeight);    // Can't be bigger than form itself
 else if ((maximumEdwinHeight == 0) && (size.iHeight == height))
 if ( (maximumEdwinHeight > 0) && (height > maximumEdwinHeight))
 height=maximumEdwinHeight;  // Can't be bigger than edwin itself
 size.iHeight = height;
 // Must force a size change on current captioned contrl even if control doesn't change size (so that edwin is resized by aknutils)
 aEdwin->SetSize(size);
-ReconsiderPageSize();
-ExposeLine(iCurrentLine, ETrue);
+if ( IsForm() )
+{
+(*iLines)[iCurrentLine]->SetRect( (*iLines)[iCurrentLine]->Rect() );
+ExposeLine( iCurrentLine, ETrue );
+}
+else
+{
+ReconsiderPageSize();
+ExposeLine(iCurrentLine, ETrue);
+}
 PrepareToDrawVerticalLine(); // do flushes here.
 /* improved redraw code
 Due to some unpleasantness about dialogs, forms and requirements, to get caption controls
 to draw properly requires a call to draw now.  A system initiated draw does not work correctly
 }
 return ETrue;
 }
-static TInt CountNumberOfLines_Edwin(CEikEdwin *aEdwin, TRect aRect, TInt numOfLines)
-{
-TInt edwinLines = numOfLines;
-TInt count = 0;
-for(TInt i=0;i<edwinLines;i++)
-{
-TInt scrolledLines = aEdwin->TextLayout()->FirstLineInBand();
-TInt docPos = aEdwin->TextLayout()->FirstCharOnLine(scrolledLines + i+1);
-TPoint point;
-aEdwin->TextLayout()->PosInBand(docPos, point);
-TInt yPos = point.iY;
-TRect lineRect;
-aEdwin->TextLayout()->GetLineRect(yPos, lineRect);
-lineRect.iTl += aEdwin->Position();
-lineRect.iBr += aEdwin->Position();
-if (aRect.Contains(lineRect.iTl) && aRect.Contains(lineRect.iBr))
-count++;
-}
-return count;
-}
-static TInt CountNumberOfLines_Ctrl(CCoeControl *aControl, TRect aRect)
-{
-TRect rect = TRect(aControl->Position(), aControl->Size());
-TInt count = 0;
-if (aRect.Contains(rect.iTl) && aRect.Contains(rect.iBr))
-count ++;
-return count;
-}
-static TInt CountNumberOfVisibleLines(CEikCaptionedControl *aControl, TRect aClipRect)
-{
-TInt count = 0;
-if (aControl->ControlIsAnEdwin(aControl->iControlType))
-count += CountNumberOfLines_Edwin((CEikEdwin*)aControl->iControl, aClipRect, aControl->NumberOfLines());
-else
-count += CountNumberOfLines_Ctrl(aControl->iControl, aClipRect);
-count += CountNumberOfLines_Ctrl(aControl->iCaption, aClipRect);
-return count;
-}
-static TInt NumberOfTextLinesVisible(CEikCapCArray *aLines, TInt aItem, TRect aClipRect)
-{
-if (aItem < 0) return 0;
-CEikCaptionedControl *control = (*aLines)[aItem];
-return CountNumberOfVisibleLines(control, aClipRect);
-}
 void CEikDialogPage::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)
 {
+	_AKNTRACE_FUNC_ENTER;
 iExtension->iHandlingScrollEvent = ETrue;
 switch (aEventType)
 {
 case EEikScrollPageUp:
 case EEikScrollPageDown:
 case EEikScrollThumbDragVert:
-iExtension->iScrolled = ETrue;
 iExtension->iScrolling = ETrue;
 iLines->MoveLineToScreen( iCurrentLine, 0, EFalse );
 break;
 default:
 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 (scrollBar)
 {
-TInt top = iScroll->Top();
-TInt middle = iScroll->Middle();
-TInt bottom = iScroll->Bottom();
-TRect parent( Rect() );
-TBool topmostPartial = top == -1;
-iLines->CalcItemIndexes(top, middle, bottom, parent.Size());
-TInt extraLines = topmostPartial ? NumberOfTextLinesVisible(iLines, top-1, parent) : 0;
-iExtension->iPreviousThumbPosition = iLines->NumberOfTextLinesBeforeLine( top - extraLines );
 // Using form layout, since this is used by AknForm only
 TAknWindowComponentLayout layout = TAknWindowComponentLayout::Compose(
 AknLayoutScalable_Avkon::listscroll_form_pane(),
 AknLayoutScalable_Avkon::scroll_pane_cp8());
-TRect scrollBarParent( MainPane().Size()/*mainPaneRect.Size()*/ );
+		//Using Rect() instead of main pane rect for supporting partial input mode.
+//TRect scrollBarParent( MainPane().Size() );
-AknLayoutUtils::LayoutVerticalScrollBar(iPageContainer->ScrollBar(), scrollBarParent, layout.LayoutLine());
+AknLayoutUtils::LayoutVerticalScrollBar(iPageContainer->ScrollBar(), Rect(), layout.LayoutLine());
 if(!ScbState() &&  iCurrentLine!=-1 && iCurrentLine < iLines->Count() )
 	{
 		CEikCaptionedControl *ctrl = (*iLines)[iCurrentLine];
 	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());
 // TODO: replace iLines->MinimumSize with world size, presumably saved in CAknFormPhysics
 vertModel.iScrollSpan = iLines->MinimumSize().iHeight;
 vertModel.iThumbSpan = iSize.iHeight - iSize.iHeight % 2;
 vertModel.iThumbPosition = Max( iPhysics->ViewTopY(), 0 );
-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() );
+}
+}
+// If new line is edwin, move cursor to the end of the string.
+CEikCaptionedControl* theNewLine =  (*iLines)[aLineIndex];
+if ( iExtension->iSetInitialFocusDone
+		&& IsForm()
+		&& theNewLine->ControlIsAnEdwin( theNewLine->iControlType )
+		&& theNewLine->iIsEditable )
+	{
+CEikEdwin* edwinPtr = STATIC_CAST( CEikEdwin*, theNewLine->iControl );
+if( edwinPtr->Text() )
+	{
+TRAP_IGNORE( edwinPtr->SetCursorPosL( edwinPtr->TextLength(), EFalse ) );
+	}
+	}
 ShowFocus( EFalse, EFalse );
 iCurrentLine=aLineIndex;
 ShowFocus(ETrue, EFalse );
 if ( ( oldLine != iCurrentLine && IsForm() ) &&
 iExtension->iInitialLayoutDone )
 {
+// Set temporarily for EFalse to prevent one extra physics update
+// because of two calls to iLines->MoveLineToScreen
+iExtension->iInitialLayoutDone = EFalse;
 if ( oldLine != -1 )
 {
 iLines->MoveLineToScreen( oldLine, 0, EFalse );
-RecordLineL( oldLine );
+TRAP_IGNORE( RecordLineL( oldLine ) );
 }
-		RecordLineL( iCurrentLine );
+// set back to correct value
+iExtension->iInitialLayoutDone = ETrue;
+		TRAP_IGNORE( 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)
 {
-if ( aType==KEikDynamicLayoutVariantSwitch )
+	_AKNTRACE_FUNC_ENTER;
+if ( aType==KEikDynamicLayoutVariantSwitch && !IsForm() )
 {
 const TInt numLines=iLines->Count();
 for ( TInt i=0; i < numLines; i++ )
 {
 CEikCaptionedControl* thisLine=(*iLines)[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();
 someone accepts the hotkey, to only offering the hot key to the current line and then, only if
 it accepts hotkeys.
 Added Enter key as a special case...
 */
 if ( (iCurrentLine!=-1) && (iCurrentLine < iLines->Count()) )
+{
 if ( (*iLines)[iCurrentLine]->OfferHotKeys() ||
 (*iLines)[iCurrentLine]->TakesEnterKey() && (aKeyEvent.iCode==EKeyEnter)
 )
+{
+CEikCaptionedControl* currentLine = ( *iLines )[iCurrentLine];
+const TInt controlType( currentLine->iControlType );
+if ( currentLine->ControlIsAnEdwin( controlType ) )
+{
+CEikEdwin* edwin = ( CEikEdwin* )currentLine->iControl;
+TBool readOnly = edwin->IsReadOnly();
+// The control is an editor which is read-only,
+// such as an on/off control
+if ( readOnly )
+{
+iPageObserver->HandleDialogPageEventL(
+MEikDialogPageObserver::EDialogPageTapped );
+return EKeyWasConsumed;
+}
+}
 if (!IsForm()|| iIsEditable)
+{
 return (*iLines)[iCurrentLine]->iControl->OfferKeyEventL(aKeyEvent,aType);
+}
+}
+}
 return EKeyWasNotConsumed;
 }
 TBool CEikDialogPage::TakesEnterKey()
 {
 }
 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;
+TBool initialLayoutDone = iExtension->iInitialLayoutDone;
+iExtension->iInitialLayoutDone = EFalse;
 HighlightVisible( aEditable );
-if ( iExtension->iUsesSingleClick )
+if ( iExtension->iUsesSingleClick && iExtension->iSetInitialFocusDone )
 {
-ShowFocus( EFalse );
+ShowFocus( EFalse, EFalse );
 }
 const TInt numLines=iLines->Count() ;
 /* if a form, no currently selected line, in edit mode,  and there is a line
 available (we know this as iLines->Count()>0), then select the first line.
 if ((iLines->Count()>0) && (iCurrentLine >= 0))
 {
 ExposeLine(iCurrentLine,ETrue);
 }
+iExtension->iInitialLayoutDone = initialLayoutDone;
+if ( IsForm() )
+{
+UpdatePhysics();
+}
+_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();
 if (!anythingToShow)
 {
 // Have to call non const leaving function...  Ignore the TRAP as result is cosmetic only.
 TRAP_IGNORE( const_cast<CEikDialogPage*>(this)->DrawEmptyListL( windowGcRef ) ) ;
 }
-else
-DrawVerticalLine();
 if ( IsForm() )
 {
 TInt delta = iPhysics->ViewCenter().iY;
 delta -= iPhysics->ViewCenterDistance();
 }
 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;};
 {
 // Tell the line that it is on a form - activate it to enable it draw its highlight box
 aLine->iIsFormControl = iFormControl ;
 if ( iFormFlags )
 aLine->SetFormFlags( iFormFlags ) ;
-aLine->GetAknLayoutValuesL() ;  // should cause the control to have size.
 }
 };
 void CEikDialogPage::SetPageContainer(const CEikDialogPageContainer* aPageContainer)
 CEikCaptionedControl* capCtrl =(*iLines)[lineIndex];
 aHeightOfControlVisibleOnPage=capCtrl->Rect().Height();
 return EFalse;
 }
-TSize CEikDialogPage::RealDataSize() const
-{
-if (iLines)
-if (iLines->Count()>0)
-return TRect((*iLines)[0]->Rect().iTl,(*iLines)[iLines->Count()-1]->Rect().iBr).Size();
-return iSize;
-}
 TInt CEikDialogPage::NumberOfLines() const
 {
 if (iLines)
 return iLines->Count();
 return 0;
 // 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;
 {
 iExtension->iTopItem = iLines->Count();
 }
 }
 iExtension->iScrolling = EFalse;
-iExtension->HandleFormFeedback( this, aPointerEvent, touchedLine, iCurrentLine );
+iExtension->HandleFormFeedback( *this,
+aPointerEvent,
+touchedLine,
+iCurrentLine );
-TBool wasScrolling = ( iPhysics->OngoingPhysicsAction() !=
+iExtension->iWasScrolling = ( iPhysics->OngoingPhysicsAction() !=
 CAknPhysics::EAknPhysicsActionNone );
-iPhysics->Stop();
+if(iExtension->iWasScrolling)
+{
+iPhysics->Stop();
+iExtension->Feedback( *this, ETouchFeedbackList );
+}
 iExtension->iLastTouchedLine = touchedLine;
 iExtension->iDragStartPosition = aPointerEvent.iPosition;
 iExtension->iLastPointerPos = aPointerEvent.iPosition;
 iExtension->iStartTime.HomeTime();
 {
 iExtension->iFocusedClicked = EFalse;
 if ( iExtension->iUsesSingleClick )
 {
-if ( !wasScrolling )
+if ( !iExtension->iWasScrolling )
 {
-HighlightVisible( ETrue );
+if ( iFormFlags & EEikFormDisableHighlightInViewMode )
-HighlightTimerCallBack( this );
+{
+HighlightVisible( EFalse );
+}
+else
+{
+HighlightVisible( ETrue );
+HighlightTimerCallBack( this );
+}
 }
 }
 else
 {
 iExtension->iHighlightTimer->Cancel();
 HighlightVisible( ETrue );
 ShowFocus( ETrue, ETrue );
 }
 }
 }
+iExtension->iFlags.Set( CDialogPageExtension::EDragEventsAllowed );
 }
 if ( aPointerEvent.iType == TPointerEvent::EDrag )
 {
+_AKNTRACE( "TPointerEvent::EDrag" );
 TPoint drag( iExtension->iDragStartPosition - aPointerEvent.iPosition );
-if ( Abs( drag.iY ) > iPhysics->DragThreshold() )
+if ( Abs( drag.iY ) > iPhysics->DragThreshold()
+&& iExtension->iFlags.IsSet(
+CDialogPageExtension::EDragEventsAllowed ) )
 {
 iExtension->iHighlightTimer->Cancel();
 if ( !iExtension->iScrolling && !textSelected )
 {
 ShowFocus( EFalse, ETrue );
 }
 }
 iExtension->iScrolling = ETrue;
-iExtension->iScrolled = ETrue;
 iExtension->iLastPointerPos = aPointerEvent.iPosition;
 RemovePressedDownHighlight();
 iLines->MoveLineToScreen( iCurrentLine, 0, EFalse );
 callDefaultImplementation = EFalse;
 }
 }
 }
 if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
 {
-iExtension->HandleFormFeedback( this, aPointerEvent, touchedLine, iCurrentLine );
+_AKNTRACE( "TPointerEvent::EButton1Up" );
+iExtension->HandleFormFeedback( *this,
+aPointerEvent,
+touchedLine,
+iCurrentLine );
 if ( !IsEditable() && iExtension->iUsesSingleClick &&
 HighlightVisible() )
 {
 HighlightVisible( EFalse );
 TPoint drag( iExtension->iDragStartPosition - aPointerEvent.iPosition );
 if ( !textSelected )
 {
-if ( !iPhysics->StartFlick( drag, iExtension->iStartTime ) )
+if ( !iExtension->iFlags.IsSet( CDialogPageExtension::EDragEventsAllowed )
+|| !iPhysics->StartFlick( drag, iExtension->iStartTime ) )
 {
 iExtension->iScrolling = EFalse;
-if ( iPageObserver && GrabbingComponent() )
+if ( iPageObserver && GrabbingComponent()
+&& !iExtension->iWasScrolling
+&& touchedLine == iCurrentLine )
 {
 iPageObserver->HandleDialogPageEventL( MEikDialogPageObserver::EDialogPageTapped );
 }
 }
 else
 if ( !iExtension->iScrolling )
 {
 // feedback is given every time when new item
 // appears to the screen -> follows the visual feedback
-iExtension->SilentFeedback( this, ETouchFeedbackSensitiveItem, aPointerEvent );
+iExtension->SilentFeedback( *this,
+ETouchFeedbackSensitiveList,
+aPointerEvent );
 // It might happen that there are no drag events between down and
 // up if the distance is short enough.
 iExtension->iHighlightTimer->Cancel();
 iExtension->iScrolling = ETrue;
-iExtension->iScrolled = ETrue;
 iLines->MoveLineToScreen( iCurrentLine, 0, EFalse );
 RemovePressedDownHighlight();
 }
 }
 }
+iExtension->iFlags.Clear( CDialogPageExtension::EDragEventsAllowed );
 }
 // forward pointer event to line's observer
 if ( touchedLine == iCurrentLine && newLine &&
 ( iExtension->iFocusedClicked ||
 aPointerEvent.iType == TPointerEvent::EButton1Up &&
 touchedLine == iCurrentLine &&
 ( iExtension->iFocusedClicked || iExtension->iUsesSingleClick ) &&
 !iExtension->iScrolling )
 {
-mskPress = ETrue;
+		mskPress = ETrue;
 callDefaultImplementation = EFalse;
 }
 if ( callDefaultImplementation && ( iExtension->iFocusedClicked ||
-iExtension->iUsesSingleClick ) && newLine )
+iExtension->iUsesSingleClick ) && newLine &&
+!iExtension->iWasScrolling )
 {
 if ( newLine->ControlIsAPopfield( controlType ) )
 {
 if(aPointerEvent.iType == TPointerEvent::EButton1Down)
 {
 if ( mskPress )
 {
 TKeyEvent key;
 key.iCode=EKeyOK;
-key.iModifiers=0;
+key.iModifiers=EModifierSpecial;
 key.iRepeats = 0;
-CEikonEnv::Static()->SimulateKeyEventL( key, EEventKey );
+iEikonEnv->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 )
 {
 viewCenter.iY = Abs( (*iLines)[0]->Rect().iTl.iY - iPosition.iY );
 }
-viewCenter.iY += iPhysics->ViewCenterDistance();
+TInt viewCenterDistance = iPhysics->ViewCenterDistance();
+viewCenter.iY += viewCenterDistance;
 if ( iExtension->iInitialLayoutDone )
 {
 TInt oldScreenHeight = iPhysics->ViewSize().iHeight;
-TInt delta = ( iPhysics->ViewCenterDistance() ) -
+TInt delta = ( viewCenterDistance ) - ( oldScreenHeight / 2 );
-( oldScreenHeight / 2 );
 viewCenter = iPhysics->ViewCenter();
 viewCenter.iY += delta;
 }
 TSize worldSize( iLines->MinimumSize() );
 worldSize.iHeight = Max( worldSize.iHeight, iSize.iHeight );
+// align to borders if those are crossed
+if ( viewCenter.iY < viewCenterDistance )
+{
+viewCenter.iY = viewCenterDistance;
+}
+else if ( viewCenter.iY > ( worldSize.iHeight - viewCenterDistance ) )
+{
+viewCenter.iY = worldSize.iHeight - viewCenterDistance;
+}
 TRAP_IGNORE( iPhysics->InitPhysicsL( worldSize, iSize, viewCenter ) );
 TRAP_IGNORE( UpdateScrollBarL() );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::HighlightTimerCallBack
 {
 (*iLines)[touchedLine]->ActivateL();
 if ( LineIsFocusable( touchedLine ) )
 {
-TRAP_IGNORE( PrepareForFocusTransitionL() );
+TRAP_IGNORE( PrepareForFocusTransitionL();
 ChangeFocusToAndExposeL( touchedLine );
 LineChangedL( (*iLines)[touchedLine]->iId );
+);
 }
 }
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::ScrollCacheByPixels
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::ScrollCacheByPixels(
-		TInt /*aDelta*/, const TDesC& /*aDebugMsg*/, TBool aDrawNow )
+		TInt /*aDelta*/, TBool aDrawNow )
 {
 if ( iLines->Count() <= 0 )
 return;
 TInt bottomItem, upperItem;
 TInt bottom = iPhysics->ViewCenter().iY + iSize.iHeight - iSize.iHeight / 2;
 }
 if ( upperItem == -1 || bottomItem == iLines->Count() )
 {
 if ( upperItem != iExtension->iTopItem || bottomItem != iExtension->iBottomItem )
 {
-iExtension->SilentFeedback( this, ETouchFeedbackSensitiveItem, TPointerEvent() );
+switch(iPhysics->OngoingPhysicsAction())
+{
+case CAknPhysics::EAknPhysicsActionBouncing:
+case CAknPhysics::EAknPhysicsActionDragging:
+case CAknPhysics::EAknPhysicsActionFlicking:
+iExtension->SilentFeedback( *this,
+ETouchFeedbackSensitiveList, TPointerEvent() );
+break;
+default:
+break;
+}
 }
 }
 else if ( upperItem >= 0 || bottomItem < iLines->Count() )
 {
 if ( upperItem < iExtension->iTopItem || bottomItem > iExtension->iBottomItem )
 {
-iExtension->SilentFeedback( this, ETouchFeedbackSensitiveItem, TPointerEvent() );
+switch(iPhysics->OngoingPhysicsAction())
+{
+case CAknPhysics::EAknPhysicsActionBouncing:
+case CAknPhysics::EAknPhysicsActionDragging:
+case CAknPhysics::EAknPhysicsActionFlicking:
+iExtension->SilentFeedback( *this,
+ETouchFeedbackSensitiveList, TPointerEvent() );
+break;
+default:
+break;
+}
 }
 }
 iExtension->iBottomItem = bottomItem;
 iExtension->iTopItem = upperItem;
 if ( aDrawNow )
 // CEikDialogPage::UpdateLineInCache
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::UpdateLineInCache( CEikCaptionedControl* aLine )
 {
+	_AKNTRACE_FUNC_ENTER;
+	if ( !IsActivated() )
+	    {
+_AKNTRACE_FUNC_EXIT;
+return;
+	    }
 TInt lineIndex = iLines->FindLineIndex( aLine );
 if ( lineIndex != KErrNotFound )
 {
 if ( aLine->Position() != TPoint( 1000, 0 ) )
 if ( iExtension->iInitialLayoutDone )
 {
 UpdatePhysics();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::Synchronize
 // ---------------------------------------------------------------------------
 //
 void CEikDialogPage::Synchronize()
 {
 iExtension->iScrolling = EFalse;
+iExtension->iFlags.Clear( CDialogPageExtension::EDragEventsAllowed );
 iLines->MoveLineToScreen( iCurrentLine, iPhysics->ViewTopY(), ETrue );
 }
 // ---------------------------------------------------------------------------
 // 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
-// ---------------------------------------------------------------------------
-//
-void CEikDialogPage::ScrollByPixels( TInt aDelta )
-{
-if ( aDelta != 0 )
-{
-iLines->ScrollByPixels( aDelta );
-TRAP_IGNORE( UpdateScrollBarL() );
-DrawNow();
-TRAP_IGNORE( RecordLinesL() );
-}
 }
 // ---------------------------------------------------------------------------
 // CEikDialogPage::RemovePressedDownHighlight
 if ( currentLine && currentLine->PressedDownState() )
 {
 currentLine->SetPressedDownState( EFalse );
 if ( IsForm() )
 {
-RecordLineL( iCurrentLine );
+TRAP_IGNORE( RecordLineL( iCurrentLine ) );
 }
 }
 }
 }
 }
 CCoeControl* grabbingComponent = GrabbingComponent();
 TBool callDefaultImplementation = ETrue;
 TBool focusItem = EFalse;
-// YPosToLine is scaled to iDataWinPos, so add it to pointer Y position
+TInt touchedLineIndex = iLines->YPositionToLineIndex( aPointerEvent.iPosition.iY );
-TInt yPosition = aPointerEvent.iPosition.iY; // + iDataWinPos.iY;
-TInt touchedLineIndex = YPosToLine2( yPosition );
 // If the stylus is down and the touched line is already the current one,
 // mark this fact in iExtension->iFocusedClicked to be used later when the stylus is up.
 if ( touchedLineIndex != KErrNotFound &&
 iExtension->iCapturingItem != KErrNotFound &&
 touchedLineIndex != iExtension->iCapturingItem )
 {
 iExtension->iCapturingItem = KErrNotFound;
 if ( PageContainer()->PageSelector()->Dialg()->Extension()->iPublicFlags.IsSet( CEikDialogExtension::EUseVirtualInput ) )
 {
 clear = ETrue;
 }
-if ( focusItem || iExtension->iFocusedClicked)
+if ( focusItem || iExtension->iFocusedClicked )
 {
-iExtension->HandleFormFeedback( this, aPointerEvent, touchedLineIndex, iCurrentLine );
+iExtension->HandleFormFeedback( *this,
+aPointerEvent,
+touchedLineIndex,
+iCurrentLine );
 }
 if ( focusItem )
 {
 PrepareForFocusTransitionL();
-(*iLines)[iCurrentLine]->ScrollBackEditor();
+(*iLines)[iCurrentLine]->ScrollBackEditorL();
 ShowFocus( EFalse, EFalse );
 iCurrentLine = touchedLineIndex;
 ShowFocus( ETrue, EFalse );
 ExposeLine( iCurrentLine, EFalse );
 LineChangedL((*iLines)[touchedLineIndex]->iId);
 {
 TKeyEvent key;
 key.iCode=EKeyOK;
 key.iModifiers=0;
 key.iRepeats = 0;
-CEikonEnv::Static()->SimulateKeyEventL(key, EEventKey);
+iEikonEnv->SimulateKeyEventL(key, EEventKey);
 // SimulateKeyEventL has to be last, because it can
 // possibly delete the dialog.. Must not do anything
 // to the dialog after the call.
 }
 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);
 }
 }
 CCoeControl::HandleResourceChange(aType);
-if(aType==KEikDynamicLayoutVariantSwitch)
+// if this is a form then its size has been set already by
+// CEikDialog::HandleResourceChange
+if ( aType == KEikDynamicLayoutVariantSwitch && !iForm )
 {
 SizeChanged();
 }
 TInt numPages = iPageArray->Count();
 void CEikDialogPageContainer::SetPageSelector(const CEikDialogPageSelector* aPageSelector)
 {
 iPageSelector = aPageSelector;
 }
-void CEikDialogPageContainer::SetPageFormSized()
+void CEikDialogPageContainer::SetPageFormSized(const TRect& aRect)
 {
 iForm = ETrue;
 //
 // Form layout
 //
-/** Dialog page container and page have the same size */
+SetRect(aRect);
-TRect mainPaneRect;
-AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPaneRect );
-mainPaneRect = TRect( mainPaneRect.Size() );    // Moving to point (0, 0)
-TAknLayoutRect formPaneLt;
-formPaneLt.LayoutRect( mainPaneRect, AknLayoutScalable_Avkon::listscroll_form_pane().LayoutLine() );
-formPaneLt.LayoutRect( formPaneLt.Rect(), AknLayoutScalable_Avkon::list_form_gen_pane().LayoutLine() );
-//
-// End of form layout
-//
-if ( formPaneLt.Rect() != Rect() )
-{
-// TODO: use static method to do variation between traditional scrolling and panning when available
-//SetRect( formPaneLt.Rect() );
-SetRect( mainPaneRect );
-}
 /** Only forms have line highlight animations. Animation creation is delayed
 * here.
 */
 if ( !iAnimation )

branch	RCL_3
changeset 20	d48ab3b357f1
parent 19	aecbbf00d063
child 21	978afdc0236f