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

equal deleted inserted replaced

-:71dd06cfe933
+:0aa5fbdfbc30
 : 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;
 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 )
 {
 TChar character(code);
 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();
 }
 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;
 }
 }
 }
 }
 } // 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() && !( iEdwinUserFlags&ENoAutoSelection ) && !( kineticScrollingEnabled
+if ( IsReadOnly() && IsSelectionVisible() && IsFocused() && !( kineticScrollingEnabled
 && iEdwinExtension->iPhysicsHandler->DraggingStarted() ) )
 {
 iEdwinFepSupport->iFeedback->InstantFeedback(
 this,
 ETouchFeedbackPopUp,
 }
 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::EEventTextUpdate )
+if ( aEventType == MEikEdwinObserver::EEventTextUpdate && iEdwinExtension )
 {
 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;
 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 )
 {
 CAknEdwinState* edwinState = static_cast<CAknEdwinState*>( iEdwinFepSupport->State(KNullUid) );
 if ( edwinState )
 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 );
 __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();
 }
 }
-iEdwinExtension->iThumbPos = KErrNotFound;
+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();
 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( formattedHeight != iEdwinExtension->iRecordFormattedHeight );
+	const TBool formattedHeightchanged( iEdwinExtension &&
-iEdwinExtension->iRecordFormattedHeight = formattedHeight;
+		( 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 )
+	{
+				aVertModel.iThumbPosition = iEdwinExtension->iThumbPos;
+	}
 if ( aVertModel.iThumbPosition == KErrNotFound || formattedHeightchanged )
 {
 if ( bottomPos == totalChars )
 {
 aVertModel.iThumbPosition = aVertModel.iScrollSpan -
 else
 {
 aVertModel.iThumbSpan = bottomPos - topPos;
 aVertModel.iScrollSpan = totalChars;
 aVertModel.iThumbPosition = topPos;
-iEdwinExtension->iThumbPos = 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->iScrolledByScrollBar = EFalse;
+	}
 }
 EXPORT_C void CEikEdwin::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)
 {
 __ASSERT_DEBUG(iText,Panic(EEikPanicEdwinNoText));
 {
 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:
 {
-if ( KineticScrollingEnabled() )
+if ( KineticScrollingEnabled() && iEdwinExtension )
 {
 iEdwinExtension->iPhysicsHandler->DisableDragging();
 }
+if ( iEdwinExtension )
-iEdwinExtension->iThumbPos = KErrNotFound;
+	{
+			iEdwinExtension->iThumbPos = KErrNotFound;
+	}
 SizeChanged();
 if ( !IsReadOnly() && !IsNonFocusing()
 && !( iEdwinUserFlags & EDisplayOnly )
 && !KineticScrollingEnabled() )
 {
 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 );
 }
 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() & (
 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();
 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 smiley support
 void CEikEdwin::EnableSmileySupportL( TBool aEnableSmiley )
 {
-if ( aEnableSmiley && !AknLayoutUtils::LayoutMirrored() )
+if ( aEnableSmiley && !AknLayoutUtils::LayoutMirrored() && iEdwinExtension )
 {
 if ( !iEdwinExtension->iSmiley )
 {
 iEdwinExtension->iSmiley = CSmileyManager::NewL( *this );
 iEdwinExtension->iSmiley->SetAnimationPlayTimes( KNormalAnimPlayTimes );
 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 )
+{
+ret = ( iEdwinExtension->iSmiley != NULL );
+}
+return ret;
 }
 void CEikEdwin::DrawSmileyInTextL( RRegion& rgn, const TRect& aDrawRect,
 CBitmapContext& aGc, CFont& aFont, const TDesC& aText, const TPoint& aPt )
 {
 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 clipRect( x, aDrawRect.iTl.iY, x + smileyWidth,
 aDrawRect.iBr.iY );
 rgn.SubRect( clipRect, NULL );
 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 );
 }
 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 );
 return EFalse;
 }
 void CEikEdwin::ConvertSmileyForDeleteL( const TCursorSelection &aSelect )
 {
-if ( !iEdwinExtension->iSmiley )
+if ( iEdwinExtension && !iEdwinExtension->iSmiley )
 {
 return;
 }
 TInt lowerPos( aSelect.LowerPos() );
 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;
 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 aIsVisable )
 {
-if ( iEdwinExtension->iSmiley && !aIsVisable )
+if ( iEdwinExtension && iEdwinExtension->iSmiley && !aIsVisable )
 {
 iTextView->SetSelectionVisibilityL( aIsVisable );
 HandleSelectionForSmiley( TCursorSelection( 0, 0 ) );
 }
 else
 {
-if ( iEdwinExtension->iSmiley )
+if ( iEdwinExtension && iEdwinExtension->iSmiley )
 {
 HandleSelectionForSmiley( Selection() );
 }
 iTextView->SetSelectionVisibilityL( aIsVisable );
 }
 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;
 }
 }
 TRect viewRect( iTextView->ViewRect() );
 window.Invalidate( viewRect );
 window.BeginRedraw( viewRect );
 gc.Activate( window );
-if ( !AknsDrawUtils::DrawBackground(
+if ( iEdwinExtension &&
+		!AknsDrawUtils::DrawBackground(
 iEdwinExtension->iSkinInstance,
 SkinBackgroundControlContext(),
 this,
 gc,
 viewRect.iTl,
 }
 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
 // ---------------------------------------------------------------------------

branch	RCL_3
changeset 18	0aa5fbdfbc30
parent 16	71dd06cfe933
child 23	3d340a0166ff