FCL/sf/mw/classicui: comparison uifw/EikStd/coctlsrc/EIKEDWIN.CPP

equal deleted inserted replaced

-:aecbbf00d063
+:d48ab3b357f1
 #include "smileymanager.h"
 #include "smileycustomwrap.h"
 #include <touchfeedback.h>
+// declare function
+void ReadSpecialCharFromSCTL( TPtr& ptr, TInt sctResourceId );
+void ReadSCTHeadPane( TResourceReader& aReader );
 GLDEF_C void Panic(TEikEdwinPanic aPanic)
 {
 _LIT(KPanicCat,"EIKON-EDWIN");
 User::Panic(KPanicCat,aPanic);
 }
 // Unicode for euro sign
 const TInt KEuroSign = 0x20AC;
 const TInt KSegmSize = 1024;
-const TInt KMicroSecondsDelay = 500000;
 const TInt KNormalAnimPlayTimes = 2;
 const TInt KInfiniteAnimPlayTimes = 0x7ffff;
 const TInt KAdditionalPixels = 0x400;
 const TInt KFullFormatLengthForSmiley = 5000;
+const TInt KContentThreshold = 8;
+const TInt KNmericSCTLimit( 256 );
+const TInt KTInt16Length( sizeof( TInt16 ) );
+const TInt KTInt32Length( sizeof( TInt32 ) );
+const TInt KTUint32Length( sizeof( TUint32 ) );
 //
 // class CEikEdwin::CUndoBuffer
 //
 NONSHARABLE_CLASS(CEikEdwinFepSupport) : public CBase, public MCoeFepAwareTextEditor, public MCoeFepAwareTextEditor_Extension1, public TCoeInputCapabilities::MCoeFepSpecificExtensions
 {
 friend class CEikEdwin;
 public:
+// The length of text window
+const static TInt KMaxSegmentLength = 10000;
+// The threshold for text window position change
+const static TInt KSegmentUpdateTrigger = 100;
 static CEikEdwinFepSupport* New(CEikEdwin& aEdwin);
 virtual ~CEikEdwinFepSupport();
 TBool IsHandledByFepL(TPointerEvent::TType aType, TUint aModifiers, TInt aDocumentPosition);
 /**
 * Set the input capabilities in the edwin fep support object. A copy of the input capabilities
 const TCoeInputCapabilities* InputCapabilities() const;
 void ConstructStateHolder();
 // from MCoeFepAwareTextEditor_Extension1
 void SetStateTransferingOwnershipL(CState* aState, TUid aTypeSafetyUid);
 CState* State(TUid aTypeSafetyUid); // this function does *not* transfer ownership
+// New functions for Touch Input sync performance improvement. A sliding window method is used
+// here to show only part of text of editor to Touch Input, so the text sync between Touch input and
+// editor can be faster.
+/**
+* To update start position of text window according to cursor position. The cursor position has to
+* be in the visible text window.
+*/
+void UpdateDocPosOffsetL( TInt aCursorPos );
+/**
+* To check if FEP wants to get information of whole text, not the text window.
+*/
+TBool FepRequireWholeTextData() const;
 private:
 enum TPointerState
 {
 EPointerIsUp,
 EPointerIsDownStartingInsideInlineText,
 public:
 const MFormCustomDraw* iOldCustomDraw; // does not own anything
 MTouchFeedback* iFeedback;
 TBool iSelectionIsCancel;
 TInt iMoveThumbFeedbackNeeded;
+// record start position of text window
+	TInt iDocPosOffset;
 private:
 MFepPointerEventHandlerDuringInlineEdit* iPointerEventHandlerDuringInlineEdit; // does not own anything
 SPointerEventInInlineText iLastPointerEventInInlineText;
 TPointerState iPointerState;
 TCoeInputCapabilities* iInputCapabilities;
 iPositionOfInlineTextInDocument=selection.LowerPos();
 iPointerEventHandlerDuringInlineEdit=&aPointerEventHandlerDuringInlineEdit;
 TBool paragraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;
 TInt numberOfCharactersSuccessfullyDeleted=0;
 TInt numberOfCharactersSuccessfullyInserted=0;
+iEdwin.ConvertSmileyForDeleteL( selection );
 // handle extended highlights
 /*
 WARNING.  do not insert any leaving function calls after the iEdwin.iText->StartFepInlineEditL unless they are trapped
 as this will call update-state problems.
 TInt numberOfCharactersSuccessfullyDeleted=0;
 TInt numberOfCharactersSuccessfullyInserted=0;
 TRAPD(error,iEdwin.iText->UpdateFepInlineTextL(paragraphContainingStartPositionOfInlineTextHasChangedFormat,numberOfCharactersSuccessfullyDeleted,numberOfCharactersSuccessfullyInserted,iPositionOfInsertionPointInDocument,iPositionOfInlineTextInDocument+aPositionOfInsertionPointInInlineText,aNewInlineText));
 iLengthOfInlineText=numberOfCharactersSuccessfullyInserted;
 UpdateTextViewAfterChangeInInlineTextL(paragraphContainingStartPositionOfInlineTextHasChangedFormat,numberOfCharactersSuccessfullyDeleted,numberOfCharactersSuccessfullyInserted,error);
-iEdwin.ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 }
 void CEikEdwinFepSupport::SetInlineEditingCursorVisibilityL(TBool aCursorVisibility)
 {
-__ASSERT_ALWAYS(iPositionOfInlineTextInDocument>=0,Panic(EEikPanicBadInlineEditingState7)); // assert that we're currently inline editing
-__ASSERT_DEBUG((iOriginalSelection.iCursorPos>=0) && (iOriginalSelection.iAnchorPos>=0) && (iPositionOfInsertionPointInDocument>=0) && (iPositionOfInlineTextInDocument>=0) && (iLengthOfInlineText>=0) && (iPointerEventHandlerDuringInlineEdit!=NULL),Panic(EEikPanicBadInlineEditingState8));
 iEdwin.SetCursorVisibilityL(aCursorVisibility);
 iShowCursor = aCursorVisibility;
 }
 void CEikEdwinFepSupport::CancelFepInlineEdit()
 #endif
 }
 TInt CEikEdwinFepSupport::DocumentLengthForFep() const
 {
+// If the length between text window start position and text end is shorter
+// than length of text window, return the short length, otherwise return
+// text window length.
+if ( !FepRequireWholeTextData() && iEdwin.TextLength() > KMaxSegmentLength )
+{
+TInt lengthToEnd( iEdwin.TextLength() - iDocPosOffset );
+if ( lengthToEnd < KMaxSegmentLength )
+{
+return lengthToEnd;
+}
+return KMaxSegmentLength;
+}
 return iEdwin.TextLength();
 }
 TInt CEikEdwinFepSupport::DocumentMaximumLengthForFep() const
 {
+// return the length between textlimit and text window start position
+if ( !FepRequireWholeTextData() && KMaxSegmentLength < iEdwin.iTextLimit )
+{
+return iEdwin.iTextLimit - iDocPosOffset;
+}
 return iEdwin.iTextLimit;
 }
 void CEikEdwinFepSupport::SetCursorSelectionForFepL(const TCursorSelection& aCursorSelection)
 {
+// if text window is enabled, the pos of parameter selection are relative to
+// text window start position, so convert them back to actual doc pos.
 TInt cursorPos( aCursorSelection.iCursorPos );
 TInt anchorPos( aCursorSelection.iAnchorPos );
+TInt textLength( iEdwin.TextLength() );
+if ( !FepRequireWholeTextData() )
+{
+cursorPos += iDocPosOffset;
+anchorPos += iDocPosOffset;
+cursorPos = cursorPos > textLength ? textLength : cursorPos;
+anchorPos = anchorPos > textLength ? textLength : anchorPos;
+if ( cursorPos != anchorPos )
+{
+TCursorSelection select( iEdwin.Selection() );
+if ( ( anchorPos == iDocPosOffset || anchorPos == iDocPosOffset +
+KMaxSegmentLength ) && anchorPos >= select.LowerPos() &&
+anchorPos <= select.HigherPos() )
+{
+anchorPos = cursorPos > anchorPos ? select.LowerPos() :
+select.HigherPos();
+}
+}
+}
+// Selection position can not be in smiley code string, so check if
+// the position needs to be changed.
 if ( iEdwin.IsSmileyEnabled() )
 {
 CSmileyManager* smiley( iEdwin.iEdwinExtension->iSmiley );
 TInt oldPos = ( cursorPos == anchorPos ) ? iEdwin.CursorPos() : anchorPos;
 smiley->HandleSetCursor( oldPos, cursorPos );
 else
 {
 smiley->HandleSetCursor( cursorPos, anchorPos );
 }
 }
-	iEdwin.SetSelectionL( cursorPos, anchorPos );
+iEdwin.SetSelectionL( cursorPos, anchorPos );
+// Cursor pos is changed, so update text window position.
+	UpdateDocPosOffsetL( cursorPos );
 iEdwin.ReportEdwinEventL(MEikEdwinObserver::EEventNavigation);
 }
 void CEikEdwinFepSupport::GetCursorSelectionForFep(TCursorSelection& aCursorSelection) const
 {
 aCursorSelection=iEdwin.Selection();
+// To use text window, FEP can not access text view of editor directly but
+// FEP needs to know some information which can not be provided by current
+// interface. So use below method to transfer the information to FEP.
+CAknEdwinState* state( iEdwin.EditorState() );
+if ( state )
+{
+TInt flag( state->Flags() );
+TTmDocPos docPos;
+iEdwin.TextView()->GetCursorPos( docPos );
+if ( docPos.iLeadingEdge )
+{
+flag |= EAknEditorFlagCursorLedingEdge;
+}
+else
+{
+flag &= ~EAknEditorFlagCursorLedingEdge;
+}
+state->SetFlags( flag );
+}
+// If text window is enabled, convert the actual doc pos to relative doc pos.
+if ( !FepRequireWholeTextData() )
+{
+if ( aCursorSelection.iAnchorPos < iDocPosOffset )
+{
+aCursorSelection.iAnchorPos = iDocPosOffset;
+}
+else if ( aCursorSelection.iAnchorPos > iDocPosOffset + KMaxSegmentLength )
+{
+aCursorSelection.iAnchorPos = iDocPosOffset + KMaxSegmentLength;
+}
+aCursorSelection.iCursorPos -= iDocPosOffset;
+aCursorSelection.iAnchorPos -= iDocPosOffset;
+}
 }
 void CEikEdwinFepSupport::GetEditorContentForFep(TDes& aEditorContent,TInt aDocumentPosition,TInt aLengthToRetrieve) const
 {
+// If text window is enabled, convert relative doc pos to actual doc pos.
+if ( !FepRequireWholeTextData() )
+{
+aDocumentPosition += iDocPosOffset;
+}
 TInt length( Min( aLengthToRetrieve, iEdwin.TextLength() - aDocumentPosition ) );
+if ( !FepRequireWholeTextData() )
+{
+length = Min( length, KMaxSegmentLength );
+}
 iEdwin.iText->Extract( aEditorContent, aDocumentPosition, length );
-if ( iEdwin.IsSmileyEnabled() )
+CSmileyManager* smiley( iEdwin.iEdwinExtension->iSmiley );
-{
+if ( smiley && smiley->HasSmileyIconsInText() )
-CSmileyManager* smiley( iEdwin.iEdwinExtension->iSmiley );
+{
 CAknEdwinState* state( iEdwin.EditorState() );
 if ( state )
 {
 TCursorSelection inlineText( state->CurrentInlineEditSpan() );
 if ( aDocumentPosition >= inlineText.LowerPos() &&
 aDocumentPosition + length <= inlineText.HigherPos() )
 {
-iEdwin.iEdwinExtension->iSmiley->ConvertTextForSmileyL(
+TRAP_IGNORE( smiley->ConvertTextForSmileyL( aDocumentPosition, aEditorContent,
-aDocumentPosition, aEditorContent, EFalse );
+EFalse ); )
 }
 }
-TBool prevIsCode( EFalse );
+// Replace all 'i' following smiley code to invisbile placeholder for
+// Touch Input can not recognize it as part of smiley code string.
+TInt smileyEndPos( 0 );
 for ( TInt i( 0 ); i < length; i++ )
 {
 if ( aEditorContent[i] == CSmileyManager::KCompensateChar )
 {
-if ( i == 0 )
+// when 'i' is the first character, it is unkonwn whether it is
-{
+// part of a smiley code string or not, so we have to use another
-prevIsCode = ( CSmileyManager::IsSmileyCode(
+// function to decide.
-smiley->SmileyCodeByPos( aDocumentPosition ) ) );
+if ( ( i > 0 && i < smileyEndPos ) ||
-}
+( i == 0 && smiley->SmileyCodeByPos( aDocumentPosition ) > 0 ) )
-if ( prevIsCode )
 {
 aEditorContent[i] = CSmileyManager::KPlaceHolder;
 }
 }
-else
+else if ( smiley->IsSmileyCode( aEditorContent[i] ) )
 {
-prevIsCode = CSmileyManager::IsSmileyCode( aEditorContent[i] );
+smileyEndPos = i + smiley->SmileyLength( aDocumentPosition + i );
 }
 }
 }
 }
 STATIC_CAST(CGlobalText*,iEdwin.iText)->GetCharFormat(aFormat,notUsed,aDocumentPosition,(aDocumentPosition==iEdwin.TextLength())? 0: 1);
 }
 void CEikEdwinFepSupport::GetScreenCoordinatesForFepL(TPoint& aLeftSideOfBaseLine,TInt& aHeight,TInt& aAscent,TInt aDocumentPosition) const
 {
+// If text window is enabled, convert relative doc pos to actual doc pos.
+aDocumentPosition += iDocPosOffset;
 aDocumentPosition %= ( iEdwin.iText->DocumentLength() + 1 );
 iEdwin.iTextView->DocPosToXyPosL(aDocumentPosition,aLeftSideOfBaseLine);
 aLeftSideOfBaseLine+=iEdwin.DrawableWindow()->InquireOffset(iEdwin.iCoeEnv->RootWin()); // make position "absolute" (i.e. not relative to the window that iEdwin is using) - note that *any* group window can be passed into InquireOffset to return the desired result, it doesn't have to be an ancestor of the window being used by iEdwin (i.e. this line of code does *not* make the assumption that iEdwin is (even indirectly) attached to iCoeEnv->RootWin())
 iEdwin.iLayout->GetCharacterHeightAndAscentL(aDocumentPosition,aHeight,aAscent);
 }
 void CEikEdwinFepSupport::DoCommitFepInlineEditL()
 {
 __ASSERT_ALWAYS(iPositionOfInlineTextInDocument>=0,Panic(EEikPanicBadInlineEditingState9)); // assert that we're currently inline editing
 __ASSERT_DEBUG((iOriginalSelection.iCursorPos>=0) && (iOriginalSelection.iAnchorPos>=0) && (iPositionOfInsertionPointInDocument>=0) && (iPositionOfInlineTextInDocument>=0) && (iLengthOfInlineText>=0) && (iPointerEventHandlerDuringInlineEdit!=NULL),Panic(EEikPanicBadInlineEditingState10));
-iEdwin.iEdwinExtension->iInlineEditing = EFalse;
 iCharsInserted = 0;
 iCharsDeleted = 0;
 TBool paragraphContainingStartPositionOfInlineTextHasChangedFormat=EFalse;
 TInt numberOfCharactersSuccessfullyDeleted=0;
 TInt numberOfCharactersSuccessfullyInserted=0;
 numberOfCharactersSuccessfullyInserted, iPositionOfInlineTextInDocument );
 if (iEdwin.iUndoStore!=NULL)
 {
 iEdwin.iUndoStore->SetNewText( select );
 }
+iEdwin.iEdwinExtension->iInlineEditing = EFalse;
 if ( iEdwin.IsSmileyEnabled() )
 {
 CAknEdwinState* state( iEdwin.EditorState() );
 TCursorSelection inlineSpan( state->CurrentInlineEditSpan() );
 if ( inlineSpan.Length() == 0 || iShowCursor )
 {
 iEdwin.HandleSelectionForSmiley( iEdwin.Selection() );
 }
 }
 iEdwin.SetAmountToFormatL( EFalse, ETrue );
-iEdwin.DrawDeferred();
+CAknEdwinState* edwinState =
+static_cast<CAknEdwinState*>( iEdwin.iEdwinFepSupport->State( KNullUid ) );
+if ( !( edwinState->Flags() & EAknEditorFlagHideTextView ) )
+{
+iEdwin.DrawDeferred();
+}
 }
 }
 iOriginalSelection.SetSelection(-1,-1);
 iPositionOfInsertionPointInDocument=-1;
 iPositionOfInlineTextInDocument=-1;
 void CEikEdwinFepSupport::MCoeFepSpecificExtensions_Reserved_2()
 {
 }
+// Update start position of text window, when cursor pos is out of current
+// text window or it is in trigger range, the text window position needs to
+// be changed and notify FEP the text change.
+void CEikEdwinFepSupport::UpdateDocPosOffsetL( TInt aCursorPos )
+{
+if ( FepRequireWholeTextData() )
+{
+return;
+}
+if ( iEdwin.TextLength() > KMaxSegmentLength )
+{
+TInt halfSegment( KMaxSegmentLength / 2 );
+TBool validDocPosOffset( iDocPosOffset >= 0 && aCursorPos > iDocPosOffset &&
+aCursorPos - iDocPosOffset < KMaxSegmentLength );
+TBool cursorInHead( validDocPosOffset &&
+aCursorPos - iDocPosOffset < KSegmentUpdateTrigger );
+TBool cursorInTail( validDocPosOffset &&
+iDocPosOffset + KMaxSegmentLength - aCursorPos < KSegmentUpdateTrigger &&
+iDocPosOffset + KMaxSegmentLength < iEdwin.TextLength() );
+if  ( !validDocPosOffset || cursorInHead || cursorInTail )
+{
+if ( iEdwin.TextLength() - aCursorPos < halfSegment )
+{
+iDocPosOffset = iEdwin.TextLength() - KMaxSegmentLength;
+}
+else
+{
+iDocPosOffset = aCursorPos - halfSegment;
+iDocPosOffset = iDocPosOffset >= 0 ? iDocPosOffset : 0;
+}
+static_cast<CAknEdwinState*>( State( KNullUid ) )->ReportAknEdStateEventL(
+MAknEdStateObserver::EAknCursorPositionChanged );
+}
+}
+}
+// Check if FEP set the flag to indicate it wants to get information of whole
+// text, not the text window.
+TBool CEikEdwinFepSupport::FepRequireWholeTextData() const
+{
+CAknEdwinState* state( static_cast<CAknEdwinState*>(
+const_cast<CEikEdwinFepSupport*>( this )->State(KNullUid) ) );
+return ( state->Flags() & EAknEditorFlagNeedWholeTextData );
+}
 //
 //  CEikEdwinExtension
 //
 CEikEdwin::CEikEdwinExtension* CEikEdwin::CEikEdwinExtension::NewL(CEikEdwin* aEdwin)
 iCenRepNotifyHandler->StartListeningL();
 iCenRep->Get(KAknFepClearDirection, iClearDirection);
 }
 iSmileyWrap = new ( ELeave ) CSmileyCustomWrap;
+iSkinInstance = AknsUtils::SkinInstance();
 }
 void CEikEdwin::CEikEdwinExtension::CreateFormExtendedInterfaceProviderIfNeededL()
 {
 if ( !iFormExtendedInterfaceProvider )
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::CEikEdwinExtension::EnableKineticScrollingL
 // ---------------------------------------------------------------------------
 //
-void CEikEdwin::CEikEdwinExtension::EnableKineticScrollingL()
+void CEikEdwin::CEikEdwinExtension::EnableKineticScrollingL( CAknPhysics* aPhysics )
 {
 iFlags.Set( EKineticScrollingEnabled );
-EnablePhysicsL();
+EnablePhysicsL( aPhysics );
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::CEikEdwinExtension::EnablePhysicsL
 // ---------------------------------------------------------------------------
 //
-void CEikEdwin::CEikEdwinExtension::EnablePhysicsL()
+void CEikEdwin::CEikEdwinExtension::EnablePhysicsL( CAknPhysics* aPhysics )
 {
 if ( iFlags.IsSet( EKineticScrollingEnabled )
 && !iPhysicsHandler && iEdwin->DrawableWindow() )
 {
-iPhysicsHandler = CAknEdwinPhysicsHandler::NewL( *iEdwin );
+iPhysicsHandler = CAknEdwinPhysicsHandler::NewL( *iEdwin, aPhysics );
 InitPhysicsL();
 if ( iEdwin->iLayout )
 {
 iEdwin->iLayout->RestrictScrollToTopsOfLines( EFalse );
 : CGlobalText::NewL(aParaFormatLayer,aCharFormatLayer,storage,granularity);
 iText=globalText;
 CreateLayoutL(globalText);
 SetHeightForNumOfLinesL();
 DoCreateCustomDrawL();
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TextLayout()->SetCustomWrap( iEdwinExtension->iSmileyWrap );
 }
 }
 return EKeyWasNotConsumed;
 }
 }
 if (iEdwinUserFlags&EDisplayOnly)
 return EKeyWasConsumed;
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 PerformRecordedOperationL();
 }
 const TInt modifiers=aKeyEvent.iModifiers;
 TBool navigation=EFalse;
 DeleteHighlightL(formatHasChanged,code==EKeyBackspace);
 const TInt lower=toDelete.LowerPos();
 const TCursorSelection sel(lower,lower);
 iTextView->SetPendingSelection(sel);
 iTextView->HandleInsertDeleteL(sel,toDelete.Length(),formatHasChanged);
+cursorPos = lower;
 reportChange=ETrue;
 }
 else if ( replaceSelection ) // All neutral protection cases
 {
 if ( !deleteSelection ) // selection has not been set yet
 iTextView->HandleCharEditL(charEditType,formatHasChanged);
 reportChange=ETrue;
 formatChange=formatHasChanged;
 }
 }
-if ( reportChange && iEdwinExtension->iSmiley )
+if ( reportChange && iEdwinExtension && iEdwinExtension->iSmiley )
 {
 ConvertTextForSmileyL( TCursorSelection( cursorPos, cursorPos ),
 ETrue );
 if ( deleteSelection || replaceSelection )
 {
 ret=EKeyWasNotConsumed;
 break;
 }
 InChar: CheckNotReadOnlyL();
 TChar character(code);
-if ( selectionLength && IsValidNumericCharL(character) )
+if ( selectionLength )
 {
 TInt pos=DeleteHighlightL(formatHasChanged);
 TRAPD(err,iText->InsertL(pos,character));
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleInsertL( pos, 1 );
 ConvertTextForSmileyL( TCursorSelection( pos, pos ), ETrue );
 }
 TCursorSelection selection=iTextView->Selection();
 User::LeaveIfError(err);
 reportChange=ETrue;
 formatChange=formatHasChanged;
 break;
 }
-if ( (!iTextLimit || TextLength()<iTextLimit) && IsValidNumericCharL(character) )
+if ( !iTextLimit || TextLength()<iTextLimit )
 {
 iText->InsertL(CursorPos(),character);
 ClearUndo();
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TInt cursorPos( CursorPos() );
 iEdwinExtension->iSmiley->HandleInsertL( cursorPos, 1 );
 ConvertTextForSmileyL( TCursorSelection( cursorPos, cursorPos ),
 ETrue );
 }
 if (reportChange)
 {
 ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 DoReportEventL( MCoeControlObserver::EEventStateChanged );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TInt docPos( CursorPos() );
 iEdwinExtension->iSmiley->HandleSetCursor( docPos,
 docPos );
 if ( docPos != CursorPos() )
 {
 SetCursorPosL( docPos, SelectionLength() > 0 );
 }
 }
 }
-if (navigation)
+if ( navigation && iEdwinExtension )
 {
 iEdwinExtension->iThumbPos = KErrNotFound;
 ReportEdwinEventL(MEikEdwinObserver::EEventNavigation);
 }
 if (formatChange)
 {
 return;
 }
 }
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 PerformRecordedOperationL();
 }
 TCursorSelection selectionBefore = iTextView->Selection();
 if (IsDimmed())
 }
 }
 }
 TBool shouldReturn( EFalse );
-iEdwinExtension->iPhysicsHandler->HandleKineticScrolling(
+if ( iEdwinExtension )
-aPointerEvent, shouldReturn );
+	{
+			iEdwinExtension->iPhysicsHandler->HandleKineticScrolling(
+aPointerEvent, shouldReturn );
+	}
 if ( shouldReturn )
 {
 return;
 }
 // Display only mode, don't handle selection but return here.
 if ( iEdwinUserFlags & EDisplayOnly )
 {
 return;
+}
+// If text selection is not visible, don't allow user to select any text
+// or scroll during selection ( if kinetic scrolling enabled ).
+if ( kineticScrollingEnabled && iEdwinFepSupport )
+{
+CAknEdwinState* edwinState( EditorState() );
+if ( edwinState && !( edwinState->Flags() & EAknEditorFlagSelectionVisible ) )
+{
+return;
+}
 }
 const TCursorSelection selection( iTextView->Selection() );
 const TPoint pointerPos( aPointerEvent.iPosition );
 }
 }
 }
 } // Kinetic scrolling not enabled
-if ( iEdwinExtension->iPtSuppressor->SuppressPointerEvent( aPointerEvent ) )
+if ( iEdwinExtension && iEdwinExtension->iPtSuppressor->SuppressPointerEvent( aPointerEvent ) )
 {
 return;
 }
 if ( IsFocused() )
 {
 iLastPointerDocPos=newCursorPos;
 iLastPointerAnchorPos=newAnchorPos;
 iEdwinInternalFlags&=(~ELeftDownInViewRect);
 // We can't open cut-copy-paste menu if dragging started
-if ( IsReadOnly() && IsSelectionVisible() && !( kineticScrollingEnabled
+if ( IsReadOnly() && IsSelectionVisible() && IsFocused() && !( kineticScrollingEnabled
 && iEdwinExtension->iPhysicsHandler->DraggingStarted() ) )
 {
 iEdwinFepSupport->iFeedback->InstantFeedback(
 this,
 ETouchFeedbackPopUp,
 if ( !IsReadOnly() && !iEdwinExtension->iDragging &&
 !iEdwinExtension->iPhysicsHandler->DraggingStarted()
 )
 {
 iEdwinFepSupport->iFeedback->InstantFeedback( this,
-ETouchFeedbackEditor, ETouchFeedbackVibra,
+ETouchFeedbackEdit, ETouchFeedbackVibra,
 aPointerEvent );
 }
 }
 else // Kinetic scrolling not enabled
 {
 iEdwinUserFlags & CEikEdwin::EReadOnly |
 iEdwinUserFlags & CEikEdwin::EAvkonNotEditable ) ) ) )
 {
 iEdwinFepSupport->iFeedback->InstantFeedback(
 this,
-ETouchFeedbackEditor,
+ETouchFeedbackEdit,
 ETouchFeedbackVibra,
 aPointerEvent );
 iEdwinFepSupport->iSelectionIsCancel = EFalse;
 }
 }
 MoveCursorL(TCursorPosition::EFLineUp,select);
 rect.Move(0,-(viewRect.Height()+2000));
 }
 Window().RequestPointerRepeatEvent(KPointerRepeatRate,rect);
 navigation = ETrue;
-iEdwinExtension->iThumbPos = KErrNotFound;
+if ( iLayout && !iLayout->IsFormattingBand() )
+{
+iEdwinExtension->iThumbPos = KErrNotFound;
+}
 }
 else if (iEdwinInternalFlags&EDragDouble)
 {
 TInt newWordStartPos,newWordLength;
 GetWordInfo(newCursorPos,newWordStartPos,newWordLength);
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down && editingEnabled )
 {
 // on down event feedback is given if cursor/selection changes
 if ( paintingPossible && !readOnly || editorWillGetFocus )
 {
-iEdwinFepSupport->iFeedback->InstantFeedback( this, ETouchFeedbackBasic );
+iEdwinFepSupport->iFeedback->InstantFeedback( this, ETouchFeedbackEdit );
 }
 }
 else  if ( selectionChanged &&
-( ( aPointerEvent.iType == TPointerEvent::EDrag ) ||
+( selectionAfter.iAnchorPos != selectionAfter.iCursorPos ) &&
+( ( aPointerEvent.iType == TPointerEvent::EDrag ) ||
 ( aPointerEvent.iType == TPointerEvent::EButtonRepeat ) ) )
 {
-// selectionAfter.iCursorPos-1 below is because we need to select the previous char
-TBool ltr = ( selectionAfter.iCursorPos >= selectionBefore.iCursorPos );
 TInt readPos = selectionAfter.iCursorPos;
-if (ltr && readPos > 0)
+if ( selectionAfter.iCursorPos > selectionAfter.iAnchorPos )
 {
-readPos -= 1; // read previous char
+readPos -= 1;//drag backword
 }
 TChar currentSelectedChar = Text()->Read( readPos, 1 )[0];
 TBool isSpace = currentSelectedChar.IsSpace();
-TBool isText = currentSelectedChar.IsAlpha()
+TBool isSmiley = CSmileyManager::IsSmileyCode(currentSelectedChar);
-|| currentSelectedChar.IsDigit();
+TBool isText = currentSelectedChar.IsGraph();
 // case line
 TInt prevLineNr = TextLayout()->GetLineNumber(selectionBefore.iCursorPos);
 TInt lineNr = TextLayout()->GetLineNumber(selectionAfter.iCursorPos);
-if ( prevLineNr != lineNr && ( selection.Length() != 0 ) )
+if ( prevLineNr != lineNr )
 {
-TInt group = ( currentSelectedChar.GetCategory() & 0xF0 );
+TInt group = currentSelectedChar.GetCategory();
-TBool isEmptyLine = ( group == TChar::ESeparatorGroup );
+TBool isEmptyLine = ( group == TChar::EZpCategory );
 TTouchLogicalFeedback fType = ( isEmptyLine ?
 ETouchFeedbackEmptyLineSelection : ETouchFeedbackLineSelection );
 iEdwinFepSupport->iFeedback->InstantFeedback( this, fType );
 }
 // case space
 else if (isSpace)
 {
 iEdwinFepSupport->iFeedback->InstantFeedback( this, ETouchFeedbackBlankSelection );
 }
 // case text
-else if (isText)
+else if ( isText || isSmiley )
 {
 iEdwinFepSupport->iFeedback->InstantFeedback( this, ETouchFeedbackTextSelection );
 }
 }
 }
 {
 if ( !focused )
 {
 TRAP_IGNORE( edwinState->ReportAknEdStateEventL(
 MAknEdStateObserver::EAknSyncEdwinState ) );
+// if text view is already hidden and editor loses focus, display text view.
+				if ( ( edwinState->Flags() & EAknEditorFlagHideTextView ) &&
+( iEdwinExtension && iEdwinExtension->iTextViewHidden ) )
+{
+iTextView->MakeVisible( ETrue );
+edwinState->SetFlags( edwinState->Flags() &
+~EAknEditorFlagHideTextView );
+iEdwinExtension->iTextViewHidden = EFalse;
+DrawDeferred();
+}
 }
 else
 {
 if ( edwinState->Flags() & EAknEditorFlagLaunchPenInputAutomatic &&
 !IsReadOnly() && !IsDimmed() && !( iEdwinUserFlags & EDisplayOnly ) )
 }
 DoCreateCustomDrawL(); //  Done after TextView is created so that optimized drawer is constructed
 // Create the required formatters according to the editor set-up
-if ( IsPurePhoneNumberEditor() )
+if ( IsPurePhoneNumberEditor() && iEdwinExtension )
 {
 if ( phoneNumberGroupingSupported )
 {
 CAknEdwinState* edwinState = STATIC_CAST( CAknEdwinState*, iEdwinFepSupport->State(KNullUid) );
 edwinState->SetFlags( edwinState->Flags() | EAknEditorFlagNumberGrouping );
 iEdwinExtension->CreatePurePhoneNumberFormatterL( *iLayout, *iText );
 }
 }
-else // Make approximation that all other editors have no matches indicator functionality
+else if ( iEdwinExtension )// Make approximation that all other editors have no matches indicator functionality
 {
 iEdwinExtension->CreateNoMatchesIndicatorFormatterL( *iLayout );
 }
 // Rich text editors that have been configured for phone number grouping
 if (iEdwinInternalFlags&ERichText && iEdwinInternalFlags&EPhoneNumberGrouping &&
-phoneNumberGroupingSupported )
+phoneNumberGroupingSupported && iEdwinExtension )
 {
 CAknEdwinState* edwinState = STATIC_CAST( CAknEdwinState*, iEdwinFepSupport->State(KNullUid) );
 edwinState->SetFlags( edwinState->Flags() | EAknEditorFlagNumberGrouping );
 iEdwinExtension->CreateRichTextPhoneNumberFormatterL( *iLayout, *(static_cast<CRichText*>(iText)) );
 }
 // Install the custom formatter system if needed
-if ( iEdwinExtension->FormExtendedInferfaceProvider() )
+if ( iEdwinExtension && iEdwinExtension->FormExtendedInferfaceProvider() )
 TextLayout()->SetInterfaceProvider( iEdwinExtension->FormExtendedInferfaceProvider() );
 UpdateScrollBarsL();
 ForceScrollBarUpdateL();
 if ( condition )
 {
 SetCursorVisibilityL( ETrue );
 }
 // View size changed, Initialize physics here
-iEdwinExtension->InitPhysicsL();
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->InitPhysicsL();
+	}
 }
 EXPORT_C TInt CEikEdwin::CountComponentControls() const
 {
 TInt count=CEikBorderedControl::CountComponentControls();
 EXPORT_C void CEikEdwin::SetAmountToFormatL(TBool aIsNewDoc)
 {
 if (!iTextView)
 return;
 const TInt chars=iText->DocumentLength();
-if ( iEdwinExtension->iSmiley && !iEdwinExtension->iDisableConvertInFormat )
+if ( iEdwinExtension && iEdwinExtension->iSmiley && !iEdwinExtension->iDisableConvertInFormat )
 {
 if ( chars > KFullFormatLengthForSmiley )
 {
 ConvertVisibleTextForSmileyL( ETrue );
 }
 }
 if (!iTextView)
 return;
 const TInt chars=iText->DocumentLength();
-if ( iEdwinExtension->iSmiley && !iEdwinExtension->iDisableConvertInFormat )
+if ( iEdwinExtension && iEdwinExtension->iSmiley && !iEdwinExtension->iDisableConvertInFormat )
 {
 if ( chars > KFullFormatLengthForSmiley )
 {
 ConvertVisibleTextForSmileyL( ETrue );
 }
 {
 const TInt count=iObserverArray->Count();
 for (TInt ii=0;ii<count;ii++)
 (*iObserverArray)[ii]->HandleEdwinEventL(this,aEventType);
 }
-if ( aEventType == MEikEdwinObserver::EEventScroll ||
+if ( aEventType == MEikEdwinObserver::EEventTextUpdate && iEdwinExtension )
-aEventType == MEikEdwinObserver::EEventNavigation
-)
-{
-HandleScrollForSmileyL();
-}
-if ( aEventType == MEikEdwinObserver::EEventTextUpdate )
 {
 iEdwinExtension->iExtendedInputCapabilities->ReportEventL(
 CAknExtendedInputCapabilities::
 MAknEventObserver::EControlContentUpdatedInternally,
 NULL );
 EXPORT_C void CEikEdwin::SetCursorPosL(TInt aDocPos,TBool aSelect)
 {
 // CTextView::SetDocPosL will cause textview to be drawn. This could happen
 // before the drawing of editor. So adding following codes to postpone the action to
 // first drawing of editor.
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 iEdwinExtension->iTempCursorPos = aDocPos;
 iEdwinExtension->iTempSelect = aSelect;
 if ( !aSelect )
 {
 if (!iTextView)
 CreateTextViewL();
 TInt oldPos( CursorPos() );
 TInt docPos( aDocPos );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleSetCursor( oldPos, docPos );
 }
 TCursorSelection select( Selection() );
 select.iCursorPos = docPos;
 ScrollIfAtTopOrBottomL();
 if ( iEdwinFepSupport &&
 ( aDocPos != oldPos || ( select.Length() > 0 && !aSelect ) ) )
 {
+// Update text window position for cursor change.
+iEdwinFepSupport->UpdateDocPosOffsetL( docPos );
 CAknEdwinState* edwinState = static_cast<CAknEdwinState*>( iEdwinFepSupport->State(KNullUid) );
 if ( edwinState )
 {
 TRAP_IGNORE( edwinState->ReportAknEdStateEventL( MAknEdStateObserver::EAknCursorPositionChanged ) );
 }
 }
+	// scrollbar:thumb is displayed on the top when editor set cursor position.
+iEdwinExtension->iThumbPos = KErrNotFound;
 UpdateVertScrollBarThumbL();
 UpdateHorizScrollBarThumb();
 }
 EXPORT_C void CEikEdwin::SetDocumentOwnership(TOwnershipType aOwner)
 {
 CancelFepTransaction();
 }
 if (!iTextView)
 CreateTextViewL();
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 iEdwinExtension->iTempCursorPos = aCursorPos;
 iEdwinExtension->iTempAnchorPos = aAnchorPos;
 return;
 }
 iEdwinExtension->iSmiley->HandleSetCursor( aCursorPos, aAnchorPos );
 }
 TCursorSelection select( aCursorPos, aAnchorPos );
 HandleSelectionForSmiley( select );
 iTextView->SetSelectionL( select );
-iEdwinExtension->iThumbPos =  KErrNotFound;
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->iThumbPos =  KErrNotFound;
+	}
 if ( iEdwinFepSupport )
 {
+// Update text window position for cursor change.
+iEdwinFepSupport->UpdateDocPosOffsetL( aCursorPos );
 CAknEdwinState* edwinState = static_cast<CAknEdwinState*>( iEdwinFepSupport->State(KNullUid) );
 if ( edwinState )
 {
 TRAP_IGNORE( edwinState->ReportAknEdStateEventL( MAknEdStateObserver::EAknCursorPositionChanged ) );
 }
 if (iEdwinUserFlags&EOwnsWindow && !OwnsWindow())
 CreateWindowL(&aParent);
 else
 CCoeControl::SetContainerWindowL(aParent);
-iEdwinExtension->EnablePhysicsL();
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->EnablePhysicsL();
+	}
 }
 EXPORT_C void CEikEdwin::SetContainerWindowL()
 {
 __ASSERT_DEBUG(iEdwinUserFlags&EOwnsWindow, Panic(EEikPanicEdwinNoWindow));
 if (!OwnsWindow())
 CreateWindowL();
-iEdwinExtension->EnablePhysicsL();
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->EnablePhysicsL();
+	}
 }
 EXPORT_C TCoeInputCapabilities CEikEdwin::InputCapabilities() const
 {
 if (IsReadOnly())
 */
 EXPORT_C void CEikEdwin::CreateLayoutL(MLayDoc* aLayDoc)
 {
 __ASSERT_DEBUG(aLayDoc,Panic(EEikPanicEdwinNoText));
-if ((iEdwinUserFlags&EAvkonEditor))
+if ( iEdwinUserFlags&EAvkonEditor && iEdwinExtension )
 {
 iLayout=CTextLayout::NewL(aLayDoc,KMaxTInt); // supply real wrapping width later
 iLayout->SetCustomWrap(&(iEdwinExtension->TextWrapper()));
 // This WAS ETrue, then fixed to EFalse, caused regression and now back to
 gc.DiscardFont(); // So the GC will not try to use the font.
 }
 EXPORT_C void CEikEdwin::TrappedDraw(const TRect& aViewRect) const
 {
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 CEikEdwin* edwin( const_cast<CEikEdwin*>( this ) );
 edwin->iEdwinExtension->iDrawInvoked = CEikEdwinExtension::EDrawing;
 TRAP_IGNORE( edwin->PerformRecordedOperationL(); );
 }
 return;
 }
 }
 TInt oldCursor( CursorPos() );
 TPoint movePoint=iTextView->MoveCursorL( aMovement, aSelect );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TCursorSelection select( 0, 0 );
 if ( AdjustCursorForSmileyL( oldCursor, select ) )
 {
 SetSelectionL( select.iCursorPos, select.iAnchorPos );
 if ( movePoint.iY )
 UpdateVertScrollBarThumbL();
 if ( iEdwinFepSupport )
 {
+// Update text window position for cursor change.
+iEdwinFepSupport->UpdateDocPosOffsetL( CursorPos() );
 CAknEdwinState* edwinState = static_cast<CAknEdwinState*>(
 iEdwinFepSupport->State( KNullUid ) );
 if ( edwinState )
 {
 TRAP_IGNORE( edwinState->ReportAknEdStateEventL(
 __ASSERT_DEBUG(iTextView,Panic(EEikPanicEdwinNoView));
 // Before scrolling into blank space was allowed, but this eventually
 // causes a panic at CTextView::ScrollDisplayL().
 const TInt move=iTextView->ScrollDisplayL(aMovement,CTextLayout::EFDisallowScrollingBlankSpace);
-if (move)
+if ( move && iEdwinExtension )
 {
 iEdwinExtension->iThumbPos = KErrNotFound;
 switch (aMovement)
 {
 case TCursorPosition::EFLeft:
 }
 EXPORT_C TInt CEikEdwin::CursorPos() const
 {
 __ASSERT_DEBUG(iTextView,Panic(EEikPanicEdwinNoView));
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
 iEdwinExtension->iTempCursorPos != KErrNotFound )
 {
 return iEdwinExtension->iTempCursorPos;
 }
 else
 EXPORT_C TInt CEikEdwin::SelectionLength() const
 {
 __ASSERT_DEBUG(iTextView,Panic(EEikPanicEdwinNoView));
 TCursorSelection selection( 0, 0 );
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
 iEdwinExtension->iTempCursorPos != KErrNotFound &&
 iEdwinExtension->iTempAnchorPos != KErrNotFound )
 {
 selection.iCursorPos = iEdwinExtension->iTempCursorPos;
 selection.iAnchorPos = iEdwinExtension->iTempAnchorPos;
 {
 if (iEdwinInternalFlags&ERichText)
 STATIC_CAST(CRichText*,iText)->CancelInsertCharFormat();
 aChanged=iText->DeleteL(aSelection.LowerPos(),length);
 }
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleDeleteL( aSelection.LowerPos(), length );
 }
 CleanupStack::Pop();
 }
 	return;
 if( textCursor != TCursor::EFCursorInvisible )
 	{
 SetAknEditorFlags( edwinState->Flags() | EAknEditorFlagTextCursorVisible );
 	}
-else
+else if ( iEdwinExtension )
 	{
 	SetAknEditorFlags( edwinState->Flags() & ~EAknEditorFlagTextCursorVisible );
 // If cursor is disabled during kinetic scrolling
 // by other party (for any reason), reset flag so that we don't show it again
 if ( iTextLimit && TextLength() > iTextLimit )
 {
 select.iCursorPos = iTextLimit;
 }
 TBool hasSmiley( EFalse );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 hasSmiley = iEdwinExtension->iSmiley->HasSmileyIconsInText();
 }
 if ( hasSmiley )
 {
 }
 segmBufPtr = aDes->Mid( segmStart, insertLength);
 AknTextUtils::ReplaceCharacters(segmBufPtr, KLineBreakCharacter,
 TChar(CEditableText::EParagraphDelimiter));
 	    iText->InsertL(oldLength+segmStart,*segmBuf);
-	    if ( iEdwinExtension->iSmiley )
+	    if ( iEdwinExtension && iEdwinExtension->iSmiley )
 	        {
 	        iEdwinExtension->iSmiley->HandleInsertL( oldLength+segmStart,
 	            insertLength );
 	        }
 	    segmStart = segmEnd;
 	        }
 	    }
 	    CleanupStack::PopAndDestroy(segmBuf);
 TRAP(err,iText->DeleteL(0,oldLength));
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleDeleteL( 0, oldLength );
 ConvertTextForSmileyL( TCursorSelection( 0,
 iText->DocumentLength() ), ETrue );
 }
 }
 else
 {
 iText->Reset(); // Duplicates previous behaviour where null pointer argument reset text object
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleDeleteL( 0,
 iText->DocumentLength() );
 }
 }
 CheckRemovePictures(0,iText->DocumentLength());
 CheckValidityOfChars(0,iText->DocumentLength());
-iEdwinExtension->iDisableConvertInFormat = ETrue;
+if ( iEdwinExtension )
-SetAmountToFormatL(ETrue); // performs formatting
+	{
-iEdwinExtension->iDisableConvertInFormat = EFalse;
+		iEdwinExtension->iDisableConvertInFormat = ETrue;
+		}
+	SetAmountToFormatL(ETrue); // performs formatting
+	if ( iEdwinExtension )
+	{
+		iEdwinExtension->iDisableConvertInFormat = EFalse;
+	}
 	// Update cursor position as CursorWidth() needs that.
 if (IsReadyToDraw())
 {
 ApplyAutoSelectionL();
 }
 if ( iCcpuSupport )
 {
 iCcpuSupport->HandleSelectionChangeL();
 }
 }
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->iThumbPos = KErrNotFound;
+	}
 if (IsReadyToDraw())
 {
 UpdateScrollBarsL();
 }
 User::LeaveIfError(err);
 }
 EXPORT_C TCursorSelection CEikEdwin::Selection()    const
 {
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw &&
 iEdwinExtension->iTempCursorPos != KErrNotFound &&
 iEdwinExtension->iTempAnchorPos != KErrNotFound )
 {
 return TCursorSelection( iEdwinExtension->iTempCursorPos,
 iEdwinExtension->iTempAnchorPos );
 const TInt lower=newText.LowerPos();
 TInt undoneLength=0;
 TRAPD(err,undoneLength=iText->PasteFromStoreL(iUndoStore->Store(),iUndoStore->Dictionary(),lower))
 const TInt cursorPos=iUndoStore->OldCursorPos();
 iTextView->SetPendingSelection(TCursorSelection(cursorPos,cursorPos));
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleInsertL( lower, undoneLength );
 ConvertTextForSmileyL( TCursorSelection( lower, undoneLength ), ETrue );
 }
 TRAPD(err2,iTextView->HandleInsertDeleteL(TCursorSelection(lower,lower+undoneLength),newText.Length(),changed));
 const TInt cursorPos=CursorPos();
 iEikonEnv->BusyMsgL(R_EIK_TBUF_IMPORTING,500000); // after 0.5 seconds
 iText->ImportTextFileL(cursorPos,aFileName,aTextOrganisation);
 TInt insertLength( iText->DocumentLength() - oldLength );
 CheckValidityOfChars( oldLength, insertLength );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleInsertL( cursorPos, insertLength );
 ConvertTextForSmileyL( TCursorSelection( cursorPos,
 cursorPos + insertLength ), ETrue );
 }
 if ( KineticScrollingEnabled() )
 {
 // If we have deleted some text and previous position (before delete) is
 // out of current editor content, we must move back to inside content.
 TInt formattedHeight( iLayout->FormattedHeightInPixels() );
-if ( prevEndPosition > formattedHeight )
+if ( prevEndPosition > formattedHeight && iEdwinExtension )
 {
 TInt movement( prevEndPosition - formattedHeight );
 iEdwinExtension->iPhysicsHandler->MoveScrollIndex( movement );
 }
 }
-if (reportChange)
+if ( reportChange && iEdwinExtension )
 {
+iEdwinExtension->iThumbPos = KErrNotFound;
 ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 DoReportEventL( MCoeControlObserver::EEventStateChanged );
 NotifyEditorStateObserverOfStateChangeL();
 UpdateScrollBarsL();
 }
 CancelFepTransaction();
 TCursorSelection selection=Selection();
 CPlainText* text( iText );
 TInt start( selection.LowerPos() );
 HBufC* buf( NULL );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 buf = ExtractTextLC( selection );
 text = CPlainText::NewL();
 CleanupStack::PushL( text );
 TPtr ptr( buf->Des() );
 ptr, EFalse );
 start = 0;
 text->InsertL( start, *buf );
 }
 text->CopyToStoreL(aStore, aDict, start, selection.Length() );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 CleanupStack::PopAndDestroy( text );
 CleanupStack::PopAndDestroy( buf );
 }
 }
 }
 const TInt higher=selection.HigherPos()+newLength-oldTextLength;
 iTextView->SetPendingSelection(TCursorSelection(higher,higher));
 selection.iAnchorPos=selection.LowerPos();
 selection.iCursorPos=selection.iAnchorPos+pastedLength;
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleInsertL( selection.LowerPos(),
 selection.Length() );
 ConvertTextForSmileyL( selection, ETrue );
 }
 return;
 }
 TRect viewRect( AdjustedViewRect() );
 const TInt formattedLines = Max(1, iLayout->NumFormattedLines());
 const TInt formattedHeight = iLayout->FormattedHeightInPixels();
+	const TBool formattedHeightchanged( iEdwinExtension &&
+		( formattedHeight != iEdwinExtension->iRecordFormattedHeight ) );
+if ( iEdwinExtension )
+	{
+iEdwinExtension->iRecordFormattedHeight = formattedHeight;
+	}
 const TInt viewRectHeight = viewRect.Height();
 const TInt totalChars = iText->DocumentLength();
 const TInt formattedLength = Min( totalChars, iLayout->FormattedLength() );
 const TInt topLeftDocPos=iLayout->FirstDocPosFullyInBand();
 const TInt avgCharsPerLine = iAvgCharsPerLine ? iAvgCharsPerLine :
 if( AknLayoutUtils::PenEnabled() )
 {
 if ( !iLayout->IsFormattingBand() )
 {
 aVertModel.iThumbSpan = viewRectHeight;
 aVertModel.iScrollSpan = formattedHeight;
-aVertModel.iThumbPosition = iEdwinExtension->iThumbPos;
+if ( iEdwinExtension )
-if ( aVertModel.iThumbPosition == KErrNotFound )
+	{
+				aVertModel.iThumbPosition = iEdwinExtension->iThumbPos;
+	}
+if ( aVertModel.iThumbPosition == KErrNotFound || formattedHeightchanged )
 {
 if ( bottomPos == totalChars )
 {
 aVertModel.iThumbPosition = aVertModel.iScrollSpan -
 aVertModel.iThumbSpan;
 else
 {
 aVertModel.iThumbSpan = bottomPos - topPos;
 aVertModel.iScrollSpan = totalChars;
 aVertModel.iThumbPosition = topPos;
+if ( iEdwinExtension )
+	{
+				iEdwinExtension->iThumbPos = topPos;
+	}
 }
 return;
 }
 else
 {
 const TAknDoubleSpanScrollBarModel* doubleModel =
 static_cast< const TAknDoubleSpanScrollBarModel* >
 ( iSBFrame->CEikScrollBarFrame::VerticalScrollBar()->Model() );
-if ( !iEdwinExtension->iUseRateScroll )
+if ( iEdwinExtension && ( !iEdwinExtension->iUseRateScroll ) )
 {
 aVertModel.iScrollSpan = heightBeforeFormat + formattedHeight
 + heightAfterFormat;
 aVertModel.iThumbSpan = viewRectHeight;
 }
 // Rate scrolling
-if ( iEdwinExtension->iUseRateScroll )
+if ( iEdwinExtension && iEdwinExtension->iUseRateScroll )
 {
 TInt heightAboveView = formattedHeightAboveView + heightBeforeFormat;
 TInt heightBelowView = formattedHeightBelowView + heightAfterFormat;
 TInt curScrollSpan = aVertModel.iScrollSpan
 {
 approxTopVisibleLine = 1;
 }
 }
-if ( iEdwinExtension->iUseRateScroll )
+if ( iEdwinExtension && iEdwinExtension->iUseRateScroll )
 {
 aVertModel.iThumbPosition = anchorThumbPos;
 }
 else
 {
 aVertModel.iThumbPosition = approxTopVisibleLine * avgLineHeight;
 }
-iEdwinExtension->iScrollbarPosition = aVertModel.iThumbPosition;
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->iScrollbarPosition = aVertModel.iThumbPosition;
+	}
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::HandleScrollEventWithPhysicsL
 // ---------------------------------------------------------------------------
 TInt curScrollSpan = doubleModel->ScrollSpan();
 TInt curThumbSpan = doubleModel->WindowSize();
 TInt thumbSpaceAbove = aScrollBar->ThumbPosition();
 TInt thumbSpaceBelow = curScrollSpan - curThumbSpan - thumbSpaceAbove;
-TInt moveOffset = thumbSpaceAbove - iEdwinExtension->iScrollbarPosition;
+TInt moveOffset = 0;
+if ( iEdwinExtension )
+	{
+		moveOffset = thumbSpaceAbove - iEdwinExtension->iScrollbarPosition;
+	}
 const TInt formattedLines = Max( 1, iLayout->NumFormattedLines() );
 const TInt formattedHeight = iLayout->FormattedHeightInPixels();
 const TInt viewRectHeight = AdjustedViewRect().Height();
 const TInt totalChars = iText->DocumentLength();
 }
 else
 {
 return;
 }
-iEdwinExtension->iScrollbarPosition = thumbSpaceAbove;
 // If scrollbar thumb is moved to the beginning or end of scrollbar,
 // ensure that also editor content is moved also exactly to the beginning
 // or end. This is needed because otherwise in some situations editor
 // content is not moved enough. We can't move too much because moving is
 else if ( thumbSpaceAbove >= curScrollSpan - curThumbSpan )
 {
 textMovePixels -= KAdditionalPixels;
 }
-iEdwinExtension->iScrolledByScrollBar = ETrue;
+if ( iEdwinExtension )
+	{
-// Actual scrolling is done by calling MoveScrollIndex
+iEdwinExtension->iScrollbarPosition = thumbSpaceAbove;
-iEdwinExtension->iPhysicsHandler->MoveScrollIndex( -textMovePixels );
+iEdwinExtension->iScrolledByScrollBar = ETrue;
-iEdwinExtension->iScrolledByScrollBar = EFalse;
+// Actual scrolling is done by calling MoveScrollIndex
+iEdwinExtension->iPhysicsHandler->MoveScrollIndex( -textMovePixels );
+iEdwinExtension->iEndBorderExceeded = EFalse;
+iEdwinExtension->iStartBorderExceeded = EFalse;
+iEdwinExtension->iScrolledByScrollBar = EFalse;
+	}
 }
 EXPORT_C void CEikEdwin::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)
 {
 __ASSERT_DEBUG(iText,Panic(EEikPanicEdwinNoText));
 iTextView->SetViewL(docPos, yPos, yPosQ);
 UpdateVertScrollBarThumbL();
 UpdateHorizScrollBarThumb();// can also change horizontally
 }
 break;
+case EEikScrollThumbReleaseVert:
+{
+if ( KineticScrollingEnabled() )
+{
+RestoreCursorState();
+}
+}
+break;
 case EEikScrollUp:
 case EEikScrollDown:
 case EEikScrollPageUp:
 case EEikScrollPageDown:
 case EEikScrollThumbDragVert:
 {
 if ( KineticScrollingEnabled() )
 {
+StoreCursorState();
 HandleScrollEventWithPhysics( aScrollBar );
 break;
 }
 TRect viewRect( AdjustedViewRect() );
 {
 TInt topPos( iTextView->XyPosToDocPosL( viewRect.iTl ) );
 TInt bottomPos( iTextView->XyPosToDocPosL( viewRect.iBr ) );
 TInt visibleRange( bottomPos - topPos );
-if ( thumbPosition != thumbSpan )
+if ( thumbPosition != thumbSpan && iEdwinExtension )
 {
 TInt scrollRange( totalChars - visibleRange );
 docPos = ( TInt )( ( TInt64 )( thumbPosition ) * scrollRange
 / thumbSpan );
 if ( iEdwinExtension->iThumbPos > thumbPosition &&
 if ( thumbPosition == thumbSpan )
 {
 docPos = totalChars;
 yPos = viewRect.iBr.iY;
 }
-iEdwinExtension->iThumbPos = thumbPosition;
+if ( iEdwinExtension )
+	{
+				iEdwinExtension->iThumbPos = thumbPosition;
+	}
 TViewYPosQualifier yPosQ;
 yPosQ.SetMakeLineFullyVisible();
 iTextView->SetViewL( docPos, yPos, yPosQ,
 CTextView::EFViewDontDiscardFormat,
 CTextView::EFNoHorizontalScroll);
 STATIC_CAST(CRichText*,iText)->DeleteFromParagraph(aStartPos,1);
 else
 {
 TRAP_IGNORE( iText->DeleteL(aStartPos,1));
 }
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleDeleteL( aStartPos, 1 );
 }
 }
 else
 switch (aType)
 {
 case KEikDynamicLayoutVariantSwitch:
 {
-iEdwinExtension->iThumbPos = KErrNotFound;
+if ( KineticScrollingEnabled() && iEdwinExtension )
+{
+iEdwinExtension->iPhysicsHandler->DisableDragging();
+}
+if ( iEdwinExtension )
+	{
+			iEdwinExtension->iThumbPos = KErrNotFound;
+	        iEdwinExtension->iEndBorderExceeded = EFalse;
+	        iEdwinExtension->iStartBorderExceeded = EFalse;
+	}
 SizeChanged();
 if ( !IsReadOnly() && !IsNonFocusing()
-&& !( iEdwinUserFlags & EDisplayOnly ) )
+&& !( iEdwinUserFlags & EDisplayOnly )
+&& !KineticScrollingEnabled() )
 {
 TInt docPos = CursorPos();
 TRect viewRect( AdjustedViewRect() );
 TViewYPosQualifier yPosQ;
 TInt yPos = ( viewRect.iBr.iY + viewRect.iTl.iY )/2;
 }
 break;
 case KEikInputLanguageChange:
 {
 UpdateCache(KEikInputLanguageChange);
+TLanguage language = CAknEnv::Static()->SettingCache().InputLanguage();
+		if ( language == ELangArabic || language == ELangFarsi ||
+			language == ELangUrdu || language == ELangHebrew )
+			{
+			iEdwinUserFlags &= ~EAvkonEnableSmileySupport;
+			EnableSmileySupportL( EFalse );
+			}
+		else if ( iEdwinExtension->iEnableSmileySupported )
+			{
+			iEdwinUserFlags |= EAvkonEnableSmileySupport;
+			EnableSmileySupportL( ETrue );
+			}
 DoAlignment();
 }
 break;
 default:
 break;
 formatChanged=STATIC_CAST(CRichText*,iText)->DelSetInsertCharFormatL(lowerPos,length);
 }
 else
 {
 formatChanged=iText->DeleteL(lowerPos,length);
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleDeleteL( lowerPos, length );
 }
 }
 iText->InsertL(aInsertPos,aText);
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->HandleInsertL( aInsertPos, aText.Length() );
 ConvertTextForSmileyL( TCursorSelection( aInsertPos,
 aInsertPos + aText.Length() ), ETrue );
 }
 default:
 resId = R_EIK_ALLOWED_FIXEDDIALLINGNUMBERMODEKEYMAP;
 break;
 }
-return iEikonEnv->AllocReadResourceLC(resId);
+	    // get special character table resource ID
+TInt sctResourceId = state->SpecialCharacterTableResourceId();
+		if ( sctResourceId && ( state->Flags() & EAknEditorFlagUseSCTNumericCharmap ) )
+			{
+		    // numericSCTBuf containing number and special characters
+			HBufC* numericSCTBuf = HBufC::NewLC( KNmericSCTLimit );
+			TPtr numericSCTPtr( numericSCTBuf->Des() );
+			// read number characters and add them to numericSCTBuf
+			HBufC* numberResource = iEikonEnv->AllocReadResourceLC( resId );
+			TPtr numberResPtr( numberResource->Des() );
+			numericSCTPtr.Append( numberResPtr );
+			CleanupStack::PopAndDestroy( numberResource ); // numberResource
+		    // read special characters from SCT by dialog ID
+		    ReadSpecialCharFromSCTL( numericSCTPtr, sctResourceId );
+		    return numericSCTBuf;
+			}
+		else
+			{
+		    return iEikonEnv->AllocReadResourceLC( resId );
+			}
 }
 else
 {
 User::Leave(KErrNoMemory);
 return NULL;
 if (iEdwinFepSupport)
 {
 edwinState = STATIC_CAST(CAknEdwinState*, iEdwinFepSupport->State(KNullUid));
 }
-CAknPictographInterface* pictographInterface = iEdwinExtension->PictographInterface();
+CAknPictographInterface* pictographInterface = NULL;
+if ( iEdwinExtension )
+	{
+		pictographInterface = iEdwinExtension->PictographInterface();
+	}
 if (edwinState)
 {
 if (FeatureManager::FeatureSupported(KFeatureIdJapanese))
 {
 fullWidthCharactersAllowed = edwinState->PermittedInputModes() & (
 {
 iEdwinUserFlags|=aFlag;
 SetVKBStatus();
 if ( aFlag & EAvkonEnableSmileySupport )
 {
+iEdwinExtension->iEnableSmileySupported = ETrue;
 EnableSmileySupportL( ETrue );
 }
 }
 EXPORT_C void CEikEdwin::RemoveFlagFromUserFlags(TUint32 aFlag)
 {
 iEdwinUserFlags&=~aFlag;
 SetVKBStatus();
 if ( aFlag & EAvkonEnableSmileySupport )
 {
+iEdwinExtension->iEnableSmileySupported = EFalse;
 EnableSmileySupportL( EFalse );
 }
 }
 EXPORT_C TUint32 CEikEdwin::UserFlags() const
 return hasStrongCharacter;
 }
 EXPORT_C void CEikEdwin::SetPictographAnimationCallBack( TCallBack& aCallBack )
 {
-iEdwinExtension->SetPictoCallBack( aCallBack );
+	if ( iEdwinExtension )
+		{
+		iEdwinExtension->SetPictoCallBack( aCallBack );
+		}
 }
 const TCallBack& CEikEdwin::PictographAnimationCallBack() const
 {
 return iEdwinExtension->PictoCallBack();
 EXPORT_C void CEikEdwin::EnableKineticScrollingL( TBool aEnable )
 {
 if ( iEdwinExtension && aEnable )
 {
-iEdwinExtension->EnableKineticScrollingL();
+iEdwinExtension->EnableKineticScrollingL( NULL );
+}
+}
+EXPORT_C void CEikEdwin::EnableKineticScrollingL( CAknPhysics* aPhysics )
+{
+if ( iEdwinExtension )
+{
+iEdwinExtension->EnableKineticScrollingL( aPhysics );
 }
 }
 TBool CEikEdwin::NeedToChangeFormattingModeL() const
 {
 return rect;
 }
 void CEikEdwin::SetVKBStatus()
 {
-TUint cap = iEdwinExtension->iExtendedInputCapabilities->Capabilities();
+	TUint cap = 0;
+if ( iEdwinExtension )
+		{
+		cap = iEdwinExtension->iExtendedInputCapabilities->Capabilities();
+		}
 if ( iEdwinUserFlags & EAvkonDisableVKB )
 {
 cap |= CAknExtendedInputCapabilities::EInputEditorDisableVKB;
 }
 else
 {
 cap &= ~CAknExtendedInputCapabilities::EInputEditorDisableVKB;
 }
-iEdwinExtension->iExtendedInputCapabilities->SetCapabilities( cap );
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->iExtendedInputCapabilities->SetCapabilities( cap );
+	}
 }
 void CEikEdwin::ScrollViewToCursorLineL()
 {
 TInt cursorPos = CursorPos();
 TRAP_IGNORE( SetCursorVisibilityL( aVisible ) );
 }
 void CEikEdwin::PerformRecordedOperationL()
 {
-if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw ||
+if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw ||
 iEdwinExtension->iDrawInvoked == CEikEdwinExtension::EDrawing )
 {
 if ( iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 iEdwinExtension->iDrawInvoked = CEikEdwinExtension::EDrawn;
 {
 iTextView->ScrollDisplayL( TCursorPosition::EFLineDown );
 UpdateScrollBarsL();
 scroll = ETrue ;
 }
-if ( scroll && iEdwinExtension->iDrawInvoked !=
+if ( scroll && iEdwinExtension &&
-CEikEdwinExtension::EDrawing )
+		iEdwinExtension->iDrawInvoked != CEikEdwinExtension::EDrawing )
 {
 ReportEdwinEventL( MEikEdwinObserver::EEventNavigation );
 }
 }
 // for chinese popup flag
 TInt chinesePopup( aOldFlags & EAknEditorFlagChinesePopup );
 if ( chinesePopup != ( aNewFlags & EAknEditorFlagChinesePopup ) )
 {
 TRAP_IGNORE( ReportChinesePopupEventL( chinesePopup == 0 ) );
 }
+// To reduce power consumption, text view should be hidden when full screen Touch
+// Input is open and editor is covered by it, for user can not see editor in this
+// case. When full screen Touch Input is open, FEP will set flag EAknEditorFlagHideTextView
+// to notify editor the text view should be hidden. But we have to check if the feature
+// of partial screen input is enabled at the same time, for full screen Touch Input window
+// will only occupy part of the screen if the feature is eanbled and editor is still visible
+// to user. So editor can only be hidden in such situation: full screen Touch Input is open
+// and partial screen feature is disabled.
+// In the contrary situations (full screen touch input is closed or partial screen
+// feature is enabled), text view has to be shown so editor can work as normal.
+if ( iTextView && iEdwinExtension )
+{
+TBool textViewHideEnabled( ( aNewFlags & EAknEditorFlagHideTextView ) &&
+!( aOldFlags & EAknEditorFlagHideTextView ) );
+TBool textViewHideDisabled( !( aNewFlags & EAknEditorFlagHideTextView ) &&
+( aOldFlags & EAknEditorFlagHideTextView ) );
+TBool partialScreenEnabled( ( aNewFlags & EAknEditorFlagEnablePartialScreen ) &&
+!( aOldFlags & EAknEditorFlagEnablePartialScreen ) );
+TBool partialScreenDisabled( !( aNewFlags & EAknEditorFlagEnablePartialScreen ) &&
+( aOldFlags & EAknEditorFlagEnablePartialScreen ) );
+if ( ( textViewHideEnabled &&
+!( aNewFlags & EAknEditorFlagEnablePartialScreen ) ) ||
+( partialScreenDisabled && ( aNewFlags & EAknEditorFlagHideTextView ) ) )
+{
+iTextView->MakeVisible( EFalse );
+iEdwinExtension->iTextViewHidden = ETrue;
+}
+else if ( iEdwinExtension->iTextViewHidden && ( textViewHideDisabled || partialScreenEnabled ) )
+{
+iTextView->MakeVisible( ETrue );
+DrawNow();
+iEdwinExtension->iTextViewHidden = EFalse;
+}
+}
 }
 void CEikEdwin::ReportChinesePopupEventL( TBool aChinesePopupOpen )
 {
 if ( aChinesePopupOpen )
 }
 // for smiley support
 void CEikEdwin::EnableSmileySupportL( TBool aEnableSmiley )
 {
-if ( aEnableSmiley && !AknLayoutUtils::LayoutMirrored() )
+if ( aEnableSmiley && !AknLayoutUtils::LayoutMirrored() && iEdwinExtension )
 {
-if ( !iEdwinExtension->iSmiley )
+TLanguage language = CAknEnv::Static()->SettingCache().InputLanguage();
-{
+		if ( language != ELangArabic && language != ELangFarsi &&
-iEdwinExtension->iSmiley = CSmileyManager::NewL( *this );
+			language != ELangUrdu && language != ELangHebrew )
-iEdwinExtension->iSmiley->SetAnimationPlayTimes( KNormalAnimPlayTimes );
+			{
-if ( IsReadOnly() || iEdwinUserFlags & EDisplayOnly )
+			if ( !iEdwinExtension->iSmiley )
-{
+				{
-iEdwinExtension->iSmiley->SetAnimationPlayTimes(
+				iEdwinExtension->iSmiley = CSmileyManager::NewL( *this );
-KInfiniteAnimPlayTimes );
+				iEdwinExtension->iSmiley->SetAnimationPlayTimes( KNormalAnimPlayTimes );
-}
+				if ( IsReadOnly() || iEdwinUserFlags & EDisplayOnly )
-}
+					{
-if ( TextLayout() )
+					iEdwinExtension->iSmiley->SetAnimationPlayTimes(
-{
+						KInfiniteAnimPlayTimes );
-TextLayout()->SetCustomWrap( iEdwinExtension->iSmileyWrap );
+					}
-}
+				}
+			if ( TextLayout() )
+				{
+				TextLayout()->SetCustomWrap( iEdwinExtension->iSmileyWrap );
+				}
+			}
 }
-else
+else if ( iEdwinExtension )
 {
 delete iEdwinExtension->iSmiley;
 iEdwinExtension->iSmiley = NULL;
 if ( TextLayout() )
 {
 }
 }
 TBool CEikEdwin::IsSmileyEnabled() const
 {
-return ( iEdwinExtension->iSmiley != NULL );
+TBool ret = EFalse;
-}
+if ( iEdwinExtension )
+{
-void CEikEdwin::DrawSmileyInTextL( CBitmapContext& aGc, CFont& aFont,
+ret = ( iEdwinExtension->iSmiley != NULL );
-const TDesC& aText, const TPoint& aPt )
+}
+return ret;
+}
+void CEikEdwin::DrawSmileyInTextL( RRegion& rgn, const TRect& aDrawRect,
+CBitmapContext& aGc, CFont& aFont, const TDesC& aText, const TPoint& aPt )
 {
 TRect viewRect( AdjustedViewRect() );
 TInt topY( aPt.iY - aFont.AscentInPixels() );
 TInt bottomY( aPt.iY + aFont.DescentInPixels() );
 const TInt KThreshold = 10;
 text.Copy( aText );
 TrimText( text );
 TInt smileyWidth( aFont.TextWidthInPixels( KSmileyString ) );
 for ( TInt i( 0 ); i < text.Length(); i++ )
 {
-if ( CSmileyManager::IsSmileyCode( text[i] ) )
+if ( iEdwinExtension && CSmileyManager::IsSmileyCode( text[i] ) )
 {
 TInt x( pt.iX + aFont.TextWidthInPixels( text.Left( i ) ) );
-TRect rect( x, topY, x + smileyWidth, bottomY );
+TRect clipRect( x, aDrawRect.iTl.iY, x + smileyWidth,
-iEdwinExtension->iSmiley->DrawIconL( aGc, rect, i + pos );
+aDrawRect.iBr.iY );
+rgn.SubRect( clipRect, NULL );
+TRect iconRect( x, topY, x + smileyWidth, bottomY );
+iEdwinExtension->iSmiley->DrawIconL( aGc, iconRect, i + pos );
 }
 }
 }
 delete buf;
 }
 void CEikEdwin::ConvertVisibleTextForSmileyL( TBool aTextToCode )
 {
-if ( !iEdwinExtension->iSmiley && !iTextView )
+if ( iEdwinExtension && !iEdwinExtension->iSmiley && !iTextView )
 {
 return;
 }
 TCursorSelection visibleRange( GetVisibleTextRangeL() );
 ConvertTextForSmileyL( visibleRange, aTextToCode );
 }
 void CEikEdwin::ConvertTextForSmileyL( TCursorSelection aSelect,
 TBool aTextToCode, TBool aRedraw )
 {
-if ( iEdwinExtension->iSmiley && !iEdwinExtension->iInlineEditing )
+if ( iEdwinExtension && iEdwinExtension->iSmiley && !iEdwinExtension->iInlineEditing )
 {
 if ( aTextToCode )
 {
 ExtendedRangeForSmiley( aSelect );
 }
 iText->InsertL( start, ptr );
 }
 CleanupStack::PopAndDestroy( buf );
 if ( aRedraw )
 {
-DrawDeferred();
+CAknEdwinState* edwinState =
+static_cast<CAknEdwinState*>( iEdwinFepSupport->State( KNullUid ) );
+if ( !( edwinState->Flags() & EAknEditorFlagHideTextView ) )
+{
+DrawDeferred();
+}
 }
 }
 }
 void CEikEdwin::TrimText( TDes& aText )
 return buf;
 }
 void CEikEdwin::ConvertSmileyIconToTextL( TInt aStartPos, TDes& aText )
 {
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley->ConvertTextForSmileyL( aStartPos,
 aText, EFalse );
 }
 }
 void CEikEdwin::ExtendedRangeForSmiley( TCursorSelection& aSelect )
 {
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TInt textLength( TextLength() );
 TInt start = aSelect.LowerPos() - CSmileyManager::KMaxLength;
 if ( start < 0 )
 {
 }
 }
 TBool CEikEdwin::ConvertSmileyForDeleteL( TInt aDocPos, TBool aBackSpace )
 {
-if ( !iEdwinExtension->iSmiley || ( aDocPos == 0 && aBackSpace ) ||
+if ( iEdwinExtension && !iEdwinExtension->iSmiley || ( aDocPos == 0 && aBackSpace ) ||
 ( aDocPos == TextLength() && !aBackSpace ) )
 {
 return EFalse;
 }
 TInt checkPos( aDocPos );
 if ( aBackSpace )
 {
 checkPos--;
 checkPos = checkPos >= 0 ? checkPos : 0;
 }
-if ( CSmileyManager::IsSmileyCode( iEdwinExtension->iSmiley->
+if ( iEdwinExtension->iSmiley->SmileyCodeByPos( checkPos ) > 0 )
-SmileyCodeByPos( checkPos ) ) &&
-!iEdwinExtension->iSmiley->IsDisabledSmileyIcon( checkPos ) )
 {
 TInt codeLength( iEdwinExtension->iSmiley->SmileyLength( checkPos ) );
 iEdwinExtension->iSmiley->DisableSmileyIcon( checkPos );
 TCursorSelection select( aDocPos, aDocPos );
 if ( aBackSpace )
 return EFalse;
 }
 void CEikEdwin::ConvertSmileyForDeleteL( const TCursorSelection &aSelect )
 {
-if ( !iEdwinExtension->iSmiley )
+if ( iEdwinExtension && !iEdwinExtension->iSmiley )
 {
 return;
 }
 TInt lowerPos( aSelect.LowerPos() );
 iText->InsertL( lowerPos, ptr );
 }
 CleanupStack::PopAndDestroy( buf );
 }
-void CEikEdwin::HandleScrollForSmileyL()
-{
-if ( !iEdwinExtension->iSmiley )
-{
-return;
-}
-TCursorSelection select( GetVisibleTextRangeL() );
-if ( select.LowerPos() != iEdwinExtension->iVisibleRange.LowerPos() ||
-select.HigherPos() != iEdwinExtension->iVisibleRange.HigherPos() )
-{
-iEdwinExtension->iVisibleRange.iCursorPos = select.iCursorPos;
-iEdwinExtension->iVisibleRange.iAnchorPos = select.iAnchorPos;
-}
-iEdwinExtension->iSmiley->SetVisibleRange( select.LowerPos(),
-select.Length() );
-}
 TBool CEikEdwin::AdjustCursorForSmileyL( TInt aOldCursor, TCursorSelection& aSelect )
 {
 TBool ret( EFalse );
 TCursorSelection select( Selection() );
 TInt cursor( select.iCursorPos );
-iEdwinExtension->iSmiley->HandleSetCursor( aOldCursor, cursor );
+if ( iEdwinExtension )
+	{
+		iEdwinExtension->iSmiley->HandleSetCursor( aOldCursor, cursor );
+	}
 if ( cursor != select.iCursorPos )
 {
 if ( select.iAnchorPos == select.iCursorPos )
 {
 select.iAnchorPos = cursor;
 {
 TRect viewRect( AdjustedViewRect() );
 return TRect( viewRect.iTl.iX, aRect.iTl.iY, viewRect.iBr.iX, aRect.iBr.iY );
 }
-void CEikEdwin::GetClipRegionForSmiley( RRegion& rgn, CFont& aFont,
-const TDesC& aText, const TPoint& aPt, const TRect& aDrawRect ) const
-{
-TInt smileyWidth( aFont.TextWidthInPixels( KSmileyString ) );
-TInt topY( aDrawRect.iTl.iY );
-TInt bottomY( aDrawRect.iBr.iY );
-for ( TInt i( 0 ); i < aText.Length(); i++ )
-{
-if ( CSmileyManager::IsSmileyCode( aText[i] ) )
-{
-TInt x( aPt.iX + aFont.TextWidthInPixels( aText.Left( i ) ) );
-TRect rect( x, topY, x + smileyWidth, bottomY );
-rgn.SubRect( rect, NULL );
-}
-}
-}
 TBool CEikEdwin::AdjustCursorPosByMovementL( TCursorPosition::TMovementType aMovement,
 TBool aSelect )
 {
 TBool ret( EFalse );
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 TInt oldPos( CursorPos() );
 TInt curPos( oldPos );
 if ( aMovement == TCursorPosition::EFLeft )
 {
 }
 }
 return ret;
 }
-void CEikEdwin::SetSelectionVisibilityL( TBool isVisable )
+void CEikEdwin::SetSelectionVisibilityL( TBool aIsVisable )
 {
-iTextView->SetSelectionVisibilityL(isVisable);
+if ( iEdwinExtension && iEdwinExtension->iSmiley && !aIsVisable )
+{
+iTextView->SetSelectionVisibilityL( aIsVisable );
+HandleSelectionForSmiley( TCursorSelection( 0, 0 ) );
+}
+else
+{
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
+{
+HandleSelectionForSmiley( Selection() );
+}
+iTextView->SetSelectionVisibilityL( aIsVisable );
+}
 CAknEdwinState*edwinState = EditorState();
-if( !edwinState )
+if ( edwinState )
-	return;
+{
-if(isVisable)
+if ( aIsVisable )
-	{
+{
 SetAknEditorFlags( edwinState->Flags() | EAknEditorFlagSelectionVisible );
-	}
+}
 else
-	{
+{
-	SetAknEditorFlags( edwinState->Flags() & ~EAknEditorFlagSelectionVisible );
+SetAknEditorFlags( edwinState->Flags() & ~EAknEditorFlagSelectionVisible );
-	}
+}
+}
 return;
 }
 TBool CEikEdwin::IsSelectionVisible()
 	{
 	TBool ret = EFalse;
 		if (text[i] == ' ')
 			return ETrue;
 		TChar::TCategory category = character.GetCategory();
-		if ( !((category&TChar::ESeparatorGroup == TChar::ESeparatorGroup) ||
+		if ( !( ( ( category & TChar::ESeparatorGroup ) == TChar::ESeparatorGroup ) ||
-			   (text[i]>=0x200B && text[i]<=0xFFFC)) )
+			   ( text[i] >= 0x200B && text[i] <= 0xFFFC ) ) )
 			{
 			ret = ETrue;
 			break;
 			}
 		}
 if ( scrolledPixels != aPixelsToScroll )
 {
 // We can't move enough, we have exceeded the border
 // (at the beginning or end of the document)
-if ( aPixelsToScroll != 0 )
+if ( aPixelsToScroll != 0 && iEdwinExtension )
 {
 if ( aPixelsToScroll < 0 )
 {
 // End of document. Set flag to tell about that
 iEdwinExtension->iEndBorderExceeded = ETrue;
 // Set variable how many pixels we are out of border
 iEdwinExtension->iPixelsOutOfBorder = 0;
 }
 }
-if ( scrolledPixels != 0 )
+if ( scrolledPixels != 0 && iEdwinExtension )
 {
 iEdwinExtension->iScrolledDelta = scrolledPixels;
 TRAP_IGNORE( UpdateVertScrollBarThumbL() );
 iEdwinExtension->iScrolledDelta = 0;
 }
 // ends (scrolling over the border toward content). In this case we
 // can use ScrollDisplayPixelsNoLimitBorderL to scroll only to border.
 // After that we have to move to mode where we use ScrollDisplayPixelsL
 // to detect if we exceed border again.
 TBool adjustScrolling( EFalse );
-if ( aPixelsToScroll > 0  && iEdwinExtension->iEndBorderExceeded )
+if ( iEdwinExtension )
-{
+	{
-if ( aPixelsToScroll > - iEdwinExtension->iPixelsOutOfBorder )
+		if ( aPixelsToScroll > 0  && iEdwinExtension->iEndBorderExceeded )
-{
+			{
-adjustScrolling = ETrue;
+			if ( aPixelsToScroll > - iEdwinExtension->iPixelsOutOfBorder )
-}
+				{
-}
+				adjustScrolling = ETrue;
-else if ( aPixelsToScroll < 0 &&  iEdwinExtension->iStartBorderExceeded )
+				}
-{
+			}
-if ( aPixelsToScroll < - iEdwinExtension->iPixelsOutOfBorder )
+		else if ( aPixelsToScroll < 0 &&  iEdwinExtension->iStartBorderExceeded )
-{
+			{
-adjustScrolling = ETrue;
+			if ( aPixelsToScroll < - iEdwinExtension->iPixelsOutOfBorder )
-}
+				{
-}
+				adjustScrolling = ETrue;
+				}
+			}
+	}
 if ( adjustScrolling )
 {
 // we are scrolling over the border, calculate how many
 // pixels we can scroll and how many pixels there is rest
 // after movement
 }
 // We are out of borders. Call scrolling function that supports bounce-effect
 TRAP_IGNORE( iTextView->ScrollDisplayPixelsNoLimitBorderL( aPixelsToScroll ) );
-// Update variable that tells how near the border we are.
+if ( iEdwinExtension )
-iEdwinExtension->iPixelsOutOfBorder += aPixelsToScroll;
+	{
+		// Update variable that tells how near the border we are.
-if ( iEdwinExtension->iStartBorderExceeded
+		iEdwinExtension->iPixelsOutOfBorder += aPixelsToScroll;
-&& iEdwinExtension->iPixelsOutOfBorder <= 0 )
-{
+		if ( iEdwinExtension->iStartBorderExceeded
-// We are inside borders, reset flag and tell to caller
+			&& iEdwinExtension->iPixelsOutOfBorder <= 0 )
-iEdwinExtension->iStartBorderExceeded = EFalse;
+			{
-aEndOfBounce = ETrue;
+			// We are inside borders, reset flag and tell to caller
-}
+			iEdwinExtension->iStartBorderExceeded = EFalse;
-else if ( iEdwinExtension->iEndBorderExceeded
+			aEndOfBounce = ETrue;
-&& iEdwinExtension->iPixelsOutOfBorder >= 0 )
+			}
-{
+		else if ( iEdwinExtension->iEndBorderExceeded
-// we are inside borders, reset flag and tell to caller
+			&& iEdwinExtension->iPixelsOutOfBorder >= 0 )
-iEdwinExtension->iEndBorderExceeded = EFalse;
+			{
-aEndOfBounce = ETrue;
+			// we are inside borders, reset flag and tell to caller
-}
+			iEdwinExtension->iEndBorderExceeded = EFalse;
+			aEndOfBounce = ETrue;
+			}
+	}
 if ( aPixelsToScroll != 0 )
 {
 TRAP_IGNORE( UpdateVertScrollBarThumbL() );
 }
 // CEikEdwin::PixelsOutOfBorder
 // ---------------------------------------------------------------------------
 //
 TInt CEikEdwin::PixelsOutOfBorder() const
 {
-return iEdwinExtension->iPixelsOutOfBorder;
+TInt ret = 0;
+if ( iEdwinExtension )
+{
+ret = iEdwinExtension->iPixelsOutOfBorder;
+}
+return ret;
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::EnableRateScrolling
 // ---------------------------------------------------------------------------
 // Use this function to change scrolling mode.
 // If aEnable is EFalse, Position scrolling mode is in use.
 // If aEnable is ETrue, Rate scrolling mode is in use.
-iEdwinExtension->iUseRateScroll = aEnable;
+	if ( iEdwinExtension )
+		{
+		iEdwinExtension->iUseRateScroll = aEnable;
+		}
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::StoreCursorState
 // ---------------------------------------------------------------------------
 //
 void CEikEdwin::StoreCursorState()
 {
 CAknEdwinState* state( EditorState() );
-if ( state && state->Flags() & EAknEditorFlagTextCursorVisible )
+if ( iEdwinExtension && state && state->Flags() & EAknEditorFlagTextCursorVisible )
 {
 TRAP_IGNORE( SetCursorVisibilityL( EFalse ) );
 iEdwinExtension->iCursorWasVisible = ETrue;
 }
 }
 // CEikEdwin::RestoreCursorState
 // ---------------------------------------------------------------------------
 //
 void CEikEdwin::RestoreCursorState()
 {
-if ( iEdwinExtension->iCursorWasVisible )
+if ( iEdwinExtension && iEdwinExtension->iCursorWasVisible )
 {
 TRAP_IGNORE( SetCursorVisibilityL( ETrue ) );
 iEdwinExtension->iCursorWasVisible = EFalse;
 }
 }
 {
 return iEdwinExtension && iEdwinExtension->iPhysicsHandler;
 }
+// ---------------------------------------------------------------------------
+// CEikEdwin::DrawViewBackground
+// ---------------------------------------------------------------------------
+//
+void CEikEdwin::DrawViewBackground( TBool aStart ) const
+{
+CWindowGc& gc = SystemGc();
+RWindow& window = Window();
+if ( aStart )
+{
+TRect viewRect( iTextView->ViewRect() );
+window.Invalidate( viewRect );
+window.BeginRedraw( viewRect );
+gc.Activate( window );
+if ( iEdwinExtension &&
+		!AknsDrawUtils::DrawBackground(
+iEdwinExtension->iSkinInstance,
+SkinBackgroundControlContext(),
+this,
+gc,
+viewRect.iTl,
+viewRect,
+KAknsDrawParamNoClearUnderImage ) )
+{
+gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+gc.SetPenStyle( CGraphicsContext::ESolidPen );
+TRgb dummyColor;
+TRgb backgroundColor = EditorBackgroundColor( dummyColor );
+gc.SetBrushColor( backgroundColor );
+gc.SetPenColor( backgroundColor );
+gc.DrawRect( iTextView->ViewRect() );
+}
+}
+else
+{
+gc.Deactivate();
+window.EndRedraw();
+}
+}
 void CEikEdwin::HandleSelectionForSmiley( TCursorSelection aSelect )
 {
-if ( !iEdwinExtension->iSmiley )
+	if ( iEdwinExtension )
-{
+		{
-return;
+		if ( !iEdwinExtension->iSmiley )
-}
+	        {
-if ( iCustomDrawer )
+	        return;
-{
+	        }
-iEdwinExtension->iSmiley->SetHighlightColor(
+	    if ( iCustomDrawer )
-iCustomDrawer->SystemColor( TLogicalRgb::ESystemSelectionBackgroundIndex,
+	        {
-KRgbWhite ) );
+	        iEdwinExtension->iSmiley->SetHighlightColor(
-}
+	            iCustomDrawer->SystemColor( TLogicalRgb::ESystemSelectionBackgroundIndex,
-iEdwinExtension->iSmiley->HandleSelection( aSelect.LowerPos(),
+	                KRgbWhite ) );
-aSelect.Length() );
+	        }
+	    iEdwinExtension->iSmiley->HandleSelection( aSelect.LowerPos(),
+	        aSelect.Length() );
+		}
 }
 // ---------------------------------------------------------------------------
 // CEikEdwin::SkipBackgroundDrawer
 // ---------------------------------------------------------------------------
 TBool CEikEdwin::SkipBackgroundDrawer() const
 {
 return iEdwinInternalFlags & ESkipBackgroundDrawer;
 }
-TBool CEikEdwin::IsValidNumericCharL( TChar aChar )
-{
+// ---------------------------------------------------------------------------
-TBool ret(ETrue);
+// CEikEdwin::ContentFitsToViewRect
-CAknEdwinState* state = static_cast<CAknEdwinState*>( iEdwinFepSupport->State( KNullUid ) );
+// ---------------------------------------------------------------------------
-if (state && state->CurrentInputMode() == EAknEditorNumericInputMode )
+//
-	{
+TBool CEikEdwin::ContentFitsToViewRect() const
-HBufC* allowedChars = GetAllowedCharsLC();
+{
-if ( (*allowedChars).Length() > 0 && (*allowedChars).Locate( aChar ) == KErrNotFound )
+if ( iLayout && !iLayout->IsFormattingBand() )
 {
-ret = EFalse;
+if ( iLayout->FormattedHeightInPixels()
-}
+<= AdjustedViewRect().Height() + KContentThreshold )
-CleanupStack::PopAndDestroy(1);//allowedChars
+{
-}
+return ETrue;
-return ret;
+}
 }
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// ReadSpecialCharFromSCTL
+// ---------------------------------------------------------------------------
+//
+void ReadSpecialCharFromSCTL( TPtr& ptr, TInt sctResourceId )
+	{
+	TResourceReader aReader;
+	CCoeEnv::Static()->CreateResourceReaderLC( aReader, sctResourceId );
+	aReader.Advance( KTInt32Length ); // Diaog Flag
+	HBufC* titleBar = aReader.ReadHBufCL(); // title bar
+	// for titleBar useless, release it.
+	delete titleBar;
+	titleBar = NULL;
+	// Page Selector Resource Id, Button Group Container Resource Id
+	aReader.Advance( KTInt32Length + KTInt32Length );
+	TInt lineCount = aReader.ReadInt16(); // line Count
+	for ( TInt ii = 0; ii < lineCount; ii++ )
+		{
+TInt controlType = aReader.ReadInt16(); // control Type
+	    if ( controlType == EAknCtPopupHeadingPane )
+	    	{
+	        // read HeadPane
+	    	ReadSCTHeadPane( aReader );
+	    	}
+	    else if ( controlType == EAknCtSpecialCharacterMap )
+	    	{
+	        aReader.ReadTPtrC(); // caption text
+			aReader.Advance( KTInt16Length + KTInt32Length ); // captioned control ID, item flags
+			TInt component_count = aReader.ReadInt16();
+			for ( TInt jj = 0; jj < component_count; jj++ )
+				{
+				TInt component_id = aReader.ReadInt16();
+				if ( component_id == EAknSCTLowerCase || component_id == EAknSCTUpperCase ||
+					component_id == EAknSCTNumeric )
+					{
+					HBufC* specialChar = aReader.ReadHBufCL();
+					ptr.Append( specialChar->Des() );
+					delete specialChar;
+					}
+				}
+	    	}
+	    else
+	    	{
+	        break;
+	    	}
+		}
+	CleanupStack::PopAndDestroy(); // aReader
+	}
+// ---------------------------------------------------------------------------
+// ReadSCTHeadPane
+// ---------------------------------------------------------------------------
+//
+void ReadSCTHeadPane( TResourceReader& aReader )
+	{
+	aReader.ReadTPtrC(); // caption text
+	// captioned control ID, item flags
+	aReader.Advance( KTInt16Length + KTInt32Length );
+	aReader.ReadTPtrC(); // text of head pane
+	aReader.ReadTPtrC(); // bitmap File Name of head pane
+	// bitmap Id, bitmap Mask Id,animation Id, layout of head pane
+	aReader.Advance( KTInt16Length + KTInt16Length + KTUint32Length + KTUint32Length );
+	aReader.ReadTPtrC(); // trailer
+	aReader.ReadTPtrC(); // bitmap File Name of captioned control
+	// bitmap Id, bitmap Mask Id of captioned control
+	aReader.Advance( KTInt16Length + KTInt16Length );
+	aReader.ReadTPtrC(); // Process ToolTip
+	}
 // End of File

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