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

equal deleted inserted replaced

-:d48ab3b357f1
+:978afdc0236f
 #include <eikrted.h>
 #include <NumberGroupingCRKeys.h>
 #include <aknpointereventsuppressor.h>
 #include <aknnotedialog.h>
 #include <AknFepGlobalEnums.h>
+#include <AknSmileyUtils.h>
 #include "smileymanager.h"
 #include "smileycustomwrap.h"
 #include <touchfeedback.h>
 // declare function
 void ReadSpecialCharFromSCTL( TPtr& ptr, TInt sctResourceId );
 void ReadSCTHeadPane( TResourceReader& aReader );
+// for supporting TapToWrite
+#include <AvkonInternalCRKeys.h>
+#include <e32property.h>
+#include <AknFepInternalPSKeys.h>
+#include <AknFontAccess.h>
 GLDEF_C void Panic(TEikEdwinPanic aPanic)
 {
 _LIT(KPanicCat,"EIKON-EDWIN");
 User::Panic(KPanicCat,aPanic);
 const TInt KNmericSCTLimit( 256 );
 const TInt KTInt16Length( sizeof( TInt16 ) );
 const TInt KTInt32Length( sizeof( TInt32 ) );
 const TInt KTUint32Length( sizeof( TUint32 ) );
+const TInt KBlackMap( 179 );
+const TInt KWhiteMap( 76 );
+_LIT( KParagraphSeparator, "\x2029" );
+TRgb FadeRgb( TRgb aColor, TUint8 aBlackMap, TUint8 aWhiteMap );
 //
 // class CEikEdwin::CUndoBuffer
 //
 }
 }
 }
 iEdwin.iTextView->HandleInsertDeleteL( select, aNumberOfCharactersSuccessfullyDeleted,
 aParagraphContainingStartPositionOfInlineTextHasChangedFormat );
+// try to draw "tap to write"
+iEdwin.TryToDrawT2W();
 User::LeaveIfError(aError);
 iEdwin.SetScrollBarsL();
 iEdwin.DoReportEventL(MCoeControlObserver::EEventStateChanged);
 if (aParagraphContainingStartPositionOfInlineTextHasChangedFormat)
 {
 // 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 ( aEditorContent[i] == CAknSmileyManager::KCompensateChar )
 {
 // 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
 // function to decide.
 if ( ( i > 0 && i < smileyEndPos ) ||
 ( i == 0 && smiley->SmileyCodeByPos( aDocumentPosition ) > 0 ) )
 {
-aEditorContent[i] = CSmileyManager::KPlaceHolder;
+aEditorContent[i] = CAknSmileyManager::KPlaceHolder;
 }
 }
 else if ( smiley->IsSmileyCode( aEditorContent[i] ) )
 {
 smileyEndPos = i + smiley->SmileyLength( aDocumentPosition + i );
 {
 // Mark the object as destroyed.
 *iDestroyedPtr = ETrue;
 iDestroyedPtr = NULL;
 }
+delete iT2WBuf;
 delete iSmiley;
 delete iSmileyWrap;
 }
 EXPORT_C CAknEdwinFormAccessor* CEikEdwin::CEikEdwinExtension::FormAccessor() const
 DeleteHighlightL(formatHasChanged,code==EKeyBackspace);
 const TInt lower=toDelete.LowerPos();
 const TCursorSelection sel(lower,lower);
 iTextView->SetPendingSelection(sel);
 iTextView->HandleInsertDeleteL(sel,toDelete.Length(),formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 cursorPos = lower;
 reportChange=ETrue;
 }
 else if ( replaceSelection ) // All neutral protection cases
 {
 TCursorSelection selection=(isPicture? TCursorSelection(cursorPos,cursorPos+1) : TCursorSelection(cursorPos,cursorPos));
 DeleteL(formatHasChanged,selection,code==EKeyBackspace,isPicture);
 if (!isPicture)
 ClearUndo();
 iTextView->HandleCharEditL(charEditType,formatHasChanged);
+TryToDrawT2W();
 reportChange=ETrue;
 formatChange=formatHasChanged;
 }
 }
 if ( reportChange && iEdwinExtension && iEdwinExtension->iSmiley )
 pending.iAnchorPos=pending.iCursorPos;
 iTextView->SetPendingSelection(pending);
 selection=pending;
 --selection.iAnchorPos;
 iTextView->HandleInsertDeleteL(selection,selectionLength,formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 User::LeaveIfError(err);
 reportChange=ETrue;
 formatChange=formatHasChanged;
 break;
 }
 iEdwinExtension->iSmiley->HandleInsertL( cursorPos, 1 );
 ConvertTextForSmileyL( TCursorSelection( cursorPos, cursorPos ),
 ETrue );
 }
 iTextView->HandleCharEditL(charEditType);
+TryToDrawT2W();
 reportChange=ETrue;
 }
 else
 {
 ClearUndo();
 paragraph the cursor was on before the edit, EFalse if from the start of the
 line the cursor was on before the edit.
 @return The number of pixels scrolled horizontally and vertically. ( Ignored )
 */
 (void)iTextView->HandleInsertDeleteL( selection, deletedChars, aFormatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 User::LeaveIfError(err);
 }
 EXPORT_C void* CEikEdwin::ExtensionInterface( TUid /*aInterface*/ )
 {
 {
 if (!iTextView)
 return;
 const TBool focused=IsFocused();
 TRAP_IGNORE(SetCursorVisibilityL(focused));
+if ( iEdwinExtension )
+{
+if ( focused )
+{
+iEdwinExtension->iT2WState |= CEikEdwinExtension::EFocusOn;
+TryToDrawT2W();
+}
+else
+{
+TBool change = ( TextLength() == 0 && IsT2WEnabled() );
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::EFocusOn;
+if ( change )
+{
+TryToDrawT2W( ETrue );
+}
+}
+}
 if (!focused && iEdwinUserFlags&EAlwaysShowSelection)
 ;
 else
 {
 TRAP_IGNORE( SetSelectionVisibilityL( focused ) );// !! inefficient
 // Text view may not occupy the whole control area.  So we need to draw in the gaps
 DrawBackgroundAroundTextView( gc, rect, viewRect, backgroundColor );
 }
 TrappedDraw(viewRect);
+// try to draw "tap to write"
+if ( TextLength() == 0 && IsT2WEnabled() )
+{
+TRAP_IGNORE( DrawT2WTextL() );
+}
 #ifdef RD_UI_TRANSITION_EFFECTS_POPUPS
 // Workaround for clipping rect problem in multiline queries with text
 // entries.  Because of differences between CRemoteGc and CWindowGc,
 // parts of the query wouldn't be drawn by CRemoteGc.  The Reset() call
 {
 CFont** fontPtr = (CFont**)aFont;
 CEikonEnv::Static()->ScreenDevice()->ReleaseFont(*fontPtr);
 }
-void CEikEdwin::DrawFirstLineTextL() const
+void CEikEdwin::DrawT2WTextL() const
 {
+if ( iEdwinExtension && iEdwinExtension->iT2WBuf )
-HBufC* clipbuf = GetTextInHBufL();
+{
-CleanupStack::PushL(clipbuf);
+// rect
+TRect edwinRect = RectForFirstLineText();
-TPtrC clipbufPtr = clipbuf->Des();
+// font
+TAknTextLineLayout textLayout =
+AknLayoutScalable_Avkon::data_form_wide_pane_t1(0).LayoutLine();
+const CAknLayoutFont* font = AknLayoutUtils::LayoutFontFromId(
+textLayout.FontId());
+TFontSpec fontSpec = CursorFontSpec();
+fontSpec.iFontStyle.SetStrokeWeight( EStrokeWeightNormal );
+CGraphicsDevice* screenDevice = iEikonEnv->ScreenDevice();
+CFbsFont* customFont( NULL );
+TInt err = screenDevice->GetNearestFontInTwips((CFont*&) customFont,
+fontSpec);
+//color
+TRgb textColor = iEikonEnv->ControlColor(EColorControlText, *this);
+MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+if ( skin && SkinColorId() != KErrNotFound )
+{
+AknsUtils::GetCachedColor( skin, textColor, KAknsIIDQsnTextColors,
+SkinColorId() );
+}
+// reorder the buffer
+TPtrC clipbufPtr = iEdwinExtension->iT2WBuf->Des();
+AknBidiTextUtils::PrepareRunInfoArray( clipbufPtr );
+HBufC* reorderedText = HBufC::NewLC( clipbufPtr.Length() + TBidiLogicalToVisual::KMinCharAvailable);
+TPtr reorderedTextPtr = reorderedText->Des();
+TInt width = edwinRect.Size().iWidth;
+AknBidiTextUtils::ConvertToVisualAndClip( clipbufPtr, reorderedTextPtr, *font, width, width );
+CWindowGc& gc = SystemGc();
+gc.SetBrushStyle(CGraphicsContext::ENullBrush);
+gc.SetPenStyle(CGraphicsContext::ESolidPen);
+gc.SetPenColor( FadeRgb( textColor, KBlackMap , KWhiteMap ) );
+gc.UseFont( customFont );
+gc.DrawText( reorderedTextPtr, edwinRect, font->TextPaneTopToBaseline(),
+AlignForFirstLineText( reorderedTextPtr ) );
+gc.DiscardFont();
+screenDevice->ReleaseFont( customFont );
+CleanupStack::PopAndDestroy( reorderedText );
+}
+}
+TRect CEikEdwin::RectForFirstLineText() const
+{
 TMargins8 margins = Margins();
 const TRect rect(Rect());
 TInt cursorWidth = CursorWidth(); // need to add cursor width to right hand margin
-TRect edwinRect = AknLayoutUtils::RectFromCoords(rect, margins.iLeft, margins.iTop, margins.iRight+cursorWidth, margins.iBottom, ELayoutEmpty, ELayoutEmpty);
+TRect edwinRect = AknLayoutUtils::RectFromCoords(rect, margins.iLeft, margins.iTop, margins.iRight+cursorWidth,
+margins.iBottom, ELayoutEmpty, ELayoutEmpty);
-TAknTextLineLayout textLayout = AknLayoutScalable_Avkon::data_form_wide_pane_t1(0).LayoutLine();
+return edwinRect;
-const CAknLayoutFont* font = AknLayoutUtils::LayoutFontFromId( textLayout.FontId());
+}
-// reorder the text
+CGraphicsContext::TTextAlign CEikEdwin::AlignForFirstLineText( const TPtr & aReorderedTextPtr ) const
-AknBidiTextUtils::PrepareRunInfoArray(clipbufPtr);
+{
-HBufC* reorderedText = HBufC::NewLC(clipbufPtr.Length() + TBidiLogicalToVisual::KMinCharAvailable);
-TPtr reorderedTextPtr = reorderedText->Des();
-TInt width = edwinRect.Size().iWidth;
-AknBidiTextUtils::ConvertToVisualAndClip(clipbufPtr, reorderedTextPtr, *font, width, width);
-AknTextUtils::ReplaceCharacters( reorderedTextPtr, _L("\x2029"), TChar(' ') );
-CleanupStack::Pop(reorderedText);
-CleanupStack::PopAndDestroy(clipbuf);
-CleanupStack::PushL(reorderedText);
 CGraphicsContext::TTextAlign alignment = CGraphicsContext::ELeft;
 switch(CurrentAlignment())
 {
 case EAknEditorAlignLeft:
 alignment = CGraphicsContext::ELeft;
 break;
 case EAknEditorAlignNone: // drop through to default
 case EAknEditorAlignBidi: // drop through to default
 default:
 {
-if (TBidiText::TextDirectionality(reorderedTextPtr) == TBidiText::ELeftToRight)
+if ( TBidiText::TextDirectionality( aReorderedTextPtr ) == TBidiText::ELeftToRight )
 alignment = CGraphicsContext::ELeft;
 else
 alignment = CGraphicsContext::ERight;
 }
 break;
 }
+return alignment;
+}
+void CEikEdwin::DrawFirstLineTextL() const
+{
+// rect
+TRect edwinRect = RectForFirstLineText();
+// font
+TAknTextLineLayout textLayout = AknLayoutScalable_Avkon::data_form_wide_pane_t1(0).LayoutLine();
+const CAknLayoutFont* font = AknLayoutUtils::LayoutFontFromId( textLayout.FontId());
+// reorder the text
+HBufC* clipbuf = GetTextInHBufL();
+CleanupStack::PushL(clipbuf);
+TPtrC clipbufPtr = clipbuf->Des();
+AknBidiTextUtils::PrepareRunInfoArray( clipbufPtr );
+HBufC* reorderedText = HBufC::NewLC( clipbufPtr.Length() + TBidiLogicalToVisual::KMinCharAvailable );
+TPtr reorderedTextPtr = reorderedText->Des();
+TInt width = edwinRect.Size().iWidth;
+AknBidiTextUtils::ConvertToVisualAndClip( clipbufPtr, reorderedTextPtr, *font, width, width );
+AknTextUtils::ReplaceCharacters( reorderedTextPtr, KParagraphSeparator, TChar(' ') );
+CleanupStack::Pop( reorderedText );
+CleanupStack::PopAndDestroy( clipbuf );
+CleanupStack::PushL( reorderedText );
 CWindowGc& gc=SystemGc();
-gc.UseFont(font);
+gc.UseFont( font );
+gc.SetBrushStyle( CGraphicsContext::ENullBrush );
-// Following patching up of the GC are now necessary after calling LafCustomDrawerfor background
+gc.SetPenStyle( CGraphicsContext::ESolidPen );
-gc.SetBrushStyle(CGraphicsContext::ENullBrush);
+gc.SetPenColor( iEikonEnv->ControlColor( EColorControlText, *this ) );  // Text color
-gc.SetPenStyle(CGraphicsContext::ESolidPen);
+gc.DrawText( reorderedTextPtr, edwinRect, font->TextPaneTopToBaseline(),
-TRgb textColor=iEikonEnv->ControlColor(EColorControlText,*this);
+AlignForFirstLineText( reorderedTextPtr ) );
+CleanupStack::PopAndDestroy(reorderedText);
-gc.SetPenColor(textColor);  // Text color
+gc.DiscardFont();
-// Edwin is assumed to be laid out already with LayoutEdwin. In that case
-// the textpane top is the top of the edwin
-TInt ascent = font->TextPaneTopToBaseline();
-gc.DrawText(reorderedTextPtr, edwinRect, ascent, alignment);
-CleanupStack::PopAndDestroy(reorderedText);
-gc.DiscardFont(); // So the GC will not try to use the font.
 }
 EXPORT_C void CEikEdwin::TrappedDraw(const TRect& aViewRect) const
 {
 if ( iEdwinExtension && iEdwinExtension->iDrawInvoked == CEikEdwinExtension::ENotDraw )
 {
 __ASSERT_DEBUG(iText,Panic(EEikPanicEdwinNoText));
 return(iText->DocumentLength());
 }
+TBool CEikEdwin::IsT2WEnabled() const
+{
+/**
+* 1,If the editor is read only or it is display only "tap to write" is disabled
+* 2,If iEdwinExtension->iT2WBuf is NULL, "tap to write" is disabled.
+* 3,If Qwerty key borad is opened, "tap to write" is disabled
+* 4,If focus off, "tap to write" is disabled
+* 5,If split input is enabled, "tap to write" is disabled
+*/
+return iEdwinExtension && !( iEdwinUserFlags & EReadOnly ) &&
+!( iEdwinUserFlags & EDisplayOnly ) && iEdwinExtension->iT2WBuf &&
+( iEdwinExtension->iT2WState & CEikEdwinExtension::EFocusOn ) &&
+!( iEdwinExtension->iT2WState & CEikEdwinExtension::ESplitInputEnabled ) &&
+!( iEdwinExtension->iExtendedInputCapabilities->Capabilities() &
+CAknExtendedInputCapabilities::EInputEditorQwertyInputActive );
+}
 void CEikEdwin::SetCursorVisibilityL(TBool aEmphasis)
 {
 TCursor::TVisibility textCursor=(aEmphasis? TCursor::EFCursorFlashing : TCursor::EFCursorInvisible);
 TCursor::TVisibility lineCursor=((iEdwinUserFlags&ELineCursor && aEmphasis)?
 TCursor::EFCursorVisible : TCursor::EFCursorInvisible);
 {
 textCursor = TCursor::EFCursorInvisible;
 lineCursor = TCursor::EFCursorInvisible;
 }
+if ( iEdwinExtension && ( iEdwinExtension->iT2WState & CEikEdwinExtension::ERecordCursor ) )
+{
+if ( aEmphasis )
+{
+iEdwinExtension->iT2WState |= CEikEdwinExtension::ECursorVisible;
+}
+else
+{
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::ECursorVisible;
+}
+}
+if ( TextLength() == 0 && IsT2WEnabled() )
+{
+textCursor = TCursor::EFCursorInvisible;
+}
 iTextView->SetCursorVisibilityL(lineCursor,textCursor);
 CAknEdwinState*edwinState = EditorState();
 if( !edwinState )
 	return;
 if( textCursor != TCursor::EFCursorInvisible )
 {
 iEdwinExtension->iSmiley->HandleInsertL( lower, undoneLength );
 ConvertTextForSmileyL( TCursorSelection( lower, undoneLength ), ETrue );
 }
 TRAPD(err2,iTextView->HandleInsertDeleteL(TCursorSelection(lower,lower+undoneLength),newText.Length(),changed));
+// try to draw "tap to write"
+TryToDrawT2W();
 ClearUndo();
 if (NeedToChangeFormattingModeL())
 SetAmountToFormatL();
 ForceScrollBarUpdateL();
 User::LeaveIfError(err);
 }
 const TInt newLength=iText->DocumentLength();
 const TInt newCursorPos=cursorPos+newLength-oldLength;
 iTextView->SetPendingSelection(TCursorSelection(newCursorPos,newCursorPos));
 if (NeedToChangeFormattingModeL())
+{
 SetAmountToFormatL();
+}
 else
+{
 iTextView->HandleInsertDeleteL(TCursorSelection(newCursorPos,cursorPos),0,ETrue);
+// try to draw "tap to write"
+TryToDrawT2W();
+}
 DrawContents();
 UpdateScrollBarsL();
 ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 DoReportEventL( MCoeControlObserver::EEventStateChanged );
 iEikonEnv->BusyMsgCancel();
 const TCursorSelection pending(lower,lower);
 iTextView->SetPendingSelection(pending);
 selection.iAnchorPos=lower;
 selection.iCursorPos=lower;
 iTextView->HandleInsertDeleteL(selection,selLength,formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 reportChange=ETrue;
 }
 CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog();
 dlg->SetTimeout( CAknNoteDialog::EShortTimeout );
 dlg->SetTone( CAknNoteDialog::ENoTone );
 {
 SetAmountToFormatL();
 DrawContents();
 }
 else
+{
 iTextView->HandleInsertDeleteL(selection,selLength,formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
+}
 iEikonEnv->BusyMsgCancel();
 User::LeaveIfError(err);
 }
 void CEikEdwin::DoPasteFromStoreL(const CStreamStore& aStore,const CStreamDictionary& aDict)
 selection.iCursorPos=selection.iAnchorPos+aModel->iReplaceText.Length();
 }
 const TCursorSelection pending(selection.iCursorPos,selection.iCursorPos);
 iTextView->SetPendingSelection(pending);
 iTextView->HandleInsertDeleteL(selection,aModel->iText.Length(),formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 if ( NeedToChangeFormattingModeL())
 SetAmountToFormatL();
 ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 DoReportEventL( MCoeControlObserver::EEventStateChanged );
 User::LeaveIfError(err);
 selection.iAnchorPos=anchor;
 selection.iCursorPos=anchor+fieldLength;
 if (iUndoStore)
 iUndoStore->SetNewText(selection);
 iTextView->HandleInsertDeleteL(selection,selectionLength,formatHasChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 ReportEdwinEventL( MEikEdwinObserver::EEventTextUpdate );
 DoReportEventL( MCoeControlObserver::EEventStateChanged );
 User::LeaveIfError(err);
 }
 }
 TInt yPos = ( viewRect.iBr.iY + viewRect.iTl.iY )/2;
 yPosQ.SetMakeLineFullyVisible();
 yPosQ.SetFillScreen();
 TRAP_IGNORE( iTextView->SetViewL( docPos, yPos, yPosQ ) );
 }
+TRAP_IGNORE( MoveViewToCursorLineL() );
 }
 break;
 case KEikMessageVirtualCursorStateChange:
 {
 TEikVirtualCursor& cursor=iEikonEnv->VirtualCursor();
 			EnableSmileySupportL( ETrue );
 			}
 DoAlignment();
 }
 break;
+case KAknSplitInputEnabled:
+	{
+if ( iEdwinExtension )
+{
+TBool change = ( TextLength() == 0 && IsT2WEnabled() );
+iEdwinExtension->iT2WState |= CEikEdwinExtension::ESplitInputEnabled;
+if ( change )
+{
+TryToDrawT2W( ETrue );
+}
+}
+	}
+	break;
+case KAknSplitInputDisabled:
+	{
+if ( iEdwinExtension )
+{
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::ESplitInputEnabled;
+TryToDrawT2W();
+}
+	}
+	break;
 default:
 break;
 }
 }
 iEdwinExtension->iSmiley->HandleInsertL( aInsertPos, aText.Length() );
 ConvertTextForSmileyL( TCursorSelection( aInsertPos,
 aInsertPos + aText.Length() ), ETrue );
 }
 iTextView->HandleInsertDeleteL(TCursorSelection(aInsertPos,aInsertPos+aText.Length()),length,formatChanged);
+// try to draw "tap to write"
+TryToDrawT2W();
 }
 EXPORT_C void CEikEdwin::SetNonPrintingCharsVisibility(TNonPrintingCharVisibility aVisibility)
 {
 __ASSERT_DEBUG(iLayout,Panic(EEikPanicEdwinNoLayout));
 if ( scroll )
 {
 UpdateScrollBarsL();
 }
 }
+// ---------------------------------------------------------------------------
+// CEikEdwin::MoveViewToCursorLineL
+// ---------------------------------------------------------------------------
+//
+void CEikEdwin::MoveViewToCursorLineL()
+{
+if ( !iTextView )
+{
+return;
+}
+const TInt cursorPos ( CursorPos() );
+const TRect viewRect( AdjustedViewRect() );
+const TPoint startPoint ( viewRect.iTl );
+const TPoint endPoint ( viewRect.iBr );
+TPoint cursorPoint;
+iTextView->DocPosToXyPosL( cursorPos, cursorPoint );
+if ( cursorPoint.iY > endPoint.iY )
+{
+TBool exceed ( EFalse ) ;
+TInt rest ( 0 );
+ScrollView ( endPoint.iY - cursorPoint.iY, exceed, rest );
+}
+else if ( cursorPoint.iY < startPoint.iY )
+{
+TBool exceed ( EFalse ) ;
+TInt rest ( 0 );
+ScrollView ( startPoint.iY - cursorPoint.iY, exceed, rest );
+}
+}
 EXPORT_C void CEikEdwin::SetCursorVisible(TBool aVisible)
 {
 TRAP_IGNORE( SetCursorVisibilityL( aVisible ) );
 }
 	// bitmap Id, bitmap Mask Id of captioned control
 	aReader.Advance( KTInt16Length + KTInt16Length );
 	aReader.ReadTPtrC(); // Process ToolTip
 	}
+// returns the faded color of aColor
+// aWhiteMap and aBlackMap parameters control the amount of fading
+TRgb FadeRgb(TRgb aColor, TUint8 aBlackMap,TUint8 aWhiteMap)
+{
+TUint8 fadeMapFactor = aWhiteMap - aBlackMap + 1;
+TUint8 fadeMapOffset = aBlackMap;
+TInt value = aColor.Internal();
+TInt b = (((value & 0x000000ff) * fadeMapFactor) >> 8)  + fadeMapOffset;
+TInt g = (((value & 0x0000ff00) * fadeMapFactor) >> 16) + fadeMapOffset;
+//the multiplication by iFadeMapFactor can overflow into the sign bit, so we shift down in two steps
+TInt r = ((((value & 0x00ff0000) >> 16) * fadeMapFactor) >> 8) + fadeMapOffset;
+TInt a = aColor.Alpha();
+return TRgb(r,g,b,a );
+}
+// ---------------------------------------------------------------------------
+// CEikEdwin::EnableT2WL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CEikEdwin::EnableT2WL( TBool aEnable )
+{
+if ( iEdwinExtension )
+{
+if ( !aEnable && iEdwinExtension->iT2WBuf )
+{
+delete iEdwinExtension->iT2WBuf;
+iEdwinExtension->iT2WBuf = NULL;
+if ( iTextView )
+{
+TryToDrawT2W( ETrue );
+}
+}
+else if ( aEnable && !iEdwinExtension->iT2WBuf )
+{
+CRepository* cenrep = NULL;
+TInt supportT2W = 0;
+TRAPD(error, cenrep = CRepository::NewL(KCRUidAvkon));
+if ( error == KErrNone )
+{
+error = cenrep->Get( KAknEdwinTapToWrite, supportT2W );
+}
+delete cenrep;
+if ( supportT2W && !iEdwinExtension->iT2WBuf )
+{
+iEdwinExtension->iT2WBuf = iEikonEnv->AllocReadResourceLC( R_AVKON_TAP_TO_WRITE );
+CleanupStack::Pop( iEdwinExtension->iT2WBuf );
+if ( iTextView )
+{
+TryToDrawT2W();
+}
+}
+}
+}
+}
+// ---------------------------------------------------------------------------
+// CEikEdwin::TryToDrawT2W
+// ---------------------------------------------------------------------------
+//
+void CEikEdwin::TryToDrawT2W( TBool aClean )
+{
+CAknEdwinState* edwinState = EditorState();
+TBool cursorVisible( EFalse );
+if ( edwinState )
+{
+cursorVisible = ( edwinState->Flags() | EAknEditorFlagTextCursorVisible );
+}
+if ( iEdwinExtension )
+{
+// When "tap to write" is enabled( started ) we should record the status of cursor.
+if ( TextLength() == 0 && IsT2WEnabled() )
+{
+SetCursorVisible( EFalse );
+iEdwinExtension->iT2WState |= CEikEdwinExtension::ERecordCursor;
+if ( cursorVisible )
+{
+iEdwinExtension->iT2WState |= CEikEdwinExtension::ECursorVisible;
+}
+else
+{
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::ECursorVisible;
+}
+DrawDeferred();
+}
+// When "tap to write" is disabled ( ended ) we need to recover the status of cursor.
+else if ( IsFocused() &&
+( iEdwinExtension->iT2WState & CEikEdwinExtension::ERecordCursor ) )
+{
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::ERecordCursor;
+SetCursorVisible( iEdwinExtension->iT2WState & CEikEdwinExtension::ECursorVisible );
+}
+// When focus off, we don't need to record the status anymore. So clean it.
+else if ( !IsFocused() )
+{
+iEdwinExtension->iT2WState &= ~CEikEdwinExtension::ERecordCursor;
+}
+}
+if ( aClean && TextLength() == 0 )
+{
+DrawDeferred();
+}
+}
 // End of File

branch	RCL_3
changeset 59	978afdc0236f
parent 56	d48ab3b357f1
child 64	85902f042028