diff -r 000000000000 -r eb1f2e154e89 textinput/peninputcommonctrlsjp/src/peninputcontextfieldjp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputcommonctrlsjp/src/peninputcontextfieldjp.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,956 @@ +/* +* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0"" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation for CFepInputContextFieldJp +* +*/ + + +#include +#include +#include +#include +#include +#include +#include // CEditableText::EParagraphDelimiter + +const TInt KGapLeftOfEachLine = 2; +const TInt KConversionRectMarginY = 2; +const TInt KConversionLeftMarginX = 1; +const TInt KConversionRightMarginX = 3; +const TInt KConversionSelectingMargin = 1; + +#ifdef _DEBUG +_LIT(KPeninputICFJp, "Peninput ICF JP"); +enum TPanicPeninputICFJp + { + EPanicICFJpStartInlineAlready = 1, + EPanicICFJpCursorPositionNotReady, + EPanicICFJpCommitInlineNotReady, + EPanicICFJpUpdateInlineNotReady, + EPanicICFJpDoUpdateInlineNotReady, + EPanicICFJpEnd + }; +#endif // _DEBUG + +// ======== LOCAL FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Check that target is between TCursorSelection. +// --------------------------------------------------------------------------- +// +TInt PositionInArea( const TInt aTargetVal, const TCursorSelection aArea ) + { + return Max ( Min( aTargetVal, aArea.HigherPos() ), aArea.LowerPos() ); + } + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +EXPORT_C CFepInputContextFieldJp* CFepInputContextFieldJp::NewL( TRect aRect, + CFepUiLayout* aUiLayout,TInt aControlId ) + { + CFepInputContextFieldJp* self = + new (ELeave) CFepInputContextFieldJp( aRect, aUiLayout,aControlId ); + + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return self; + } + + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +EXPORT_C CFepInputContextFieldJp::~CFepInputContextFieldJp() + { + delete iPictoInterface; + delete iDummyControl; + if ( iPreBuffer ) + { + delete iPreBuffer; + iPreBuffer = NULL; + } + } + +// --------------------------------------------------------------------------- +// Gets the text from the current control and puts it into +// the edit area. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::SetTextL( + const TFepInputContextFieldData& aData ) + { + + if ( iConversionOffset >= 0 ) + { + // Nothing is done at conversion. + return; + } + + if ( aData.iCmd == EPeninputICFInitial ) + { + iPreConversionData.iRect = aData.iRect; + iPreConversionData.iCursorVisibility = aData.iCursorVisibility; + iPreConversionData.iCursorSelVisible = aData.iCursorSelVisible; + } + CFepInputContextField::SetTextL( aData ); + } + +// --------------------------------------------------------------------------- +// Start only +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::StartInlineL() + { + __ASSERT_DEBUG( ( iConversionOffset < 0 ), + User::Panic( KPeninputICFJp, EPanicICFJpStartInlineAlready ) ); + + // Set Text and Cursor and Region + const TInt cursorLowPos = iSelectedCompositionText.LowerPos(); + const TInt linehead = iRelativePos; + iConversionOffset = cursorLowPos; + iConversionArea.SetSelection( iConversionOffset, iConversionOffset ); + + if ( iConvertingState == ETransitoryInputAreaNextSegmentWait ) + { + // It exists next transitory input area, + // becase of the multi segment in transitory input area + SetDisplayData( linehead, linehead + iPreDisplayTextOffset ); + iPreDisplayTextOffset = iDisplayTextOffset; + } + + iPreConversionData.iCurSel = iSelectedCompositionText; + iPreConversionData.iLength = iBuffer->Des().Length(); + iPreBuffer = iBuffer->Des().AllocL(); + iPreConversionData.iText.Set( *iPreBuffer ); + iConvertingState = ETransitoryInputAreaStandby; + + const TInt newLinehead = Max( iBuffer->Left( + cursorLowPos ).LocateReverse( + CEditableText::EParagraphDelimiter ) + 1, + 0 ); + if ( linehead != newLinehead ) + { + SetDisplayData( newLinehead, newLinehead ); + } + } + + +// --------------------------------------------------------------------------- +// Update always replace. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::UpdateInlineL( TDesC& aText, + const TInt aDivisionPoint, + const TTransitoryInputAreaState aState + /*=ETransitoryInputAreaConverting*/ ) + { + __ASSERT_DEBUG( ( iConversionOffset >= 0 ), + User::Panic( KPeninputICFJp, EPanicICFJpUpdateInlineNotReady ) ); + + const TInt replaceLen = iConversionArea.Length() + + iSelectedCompositionText.Length(); + const TInt textLen = aText.Length(); + const TInt linehead = iRelativePos; + const TInt cursorPosition = ( aDivisionPoint < 0 ) + ? Max( iSelectedCompositionText.LowerPos() + + textLen - replaceLen, linehead ) + : iConversionOffset + aDivisionPoint; + + // Set Region + iConversionArea.SetSelection( iConversionOffset + textLen, + iConversionOffset ); + + // Set Text + if ( iBuffer ) + { + // Replace + iBuffer->Des().Replace( iConversionOffset, replaceLen, aText ); + } + else + { + // Insert + iBuffer = HBufC::NewL( Max( replaceLen, textLen ) ); + iBuffer->Des().Copy( aText ); + } + + iConvertingState = aState; + DoUpdateInline( cursorPosition, aDivisionPoint ); + } + + +// --------------------------------------------------------------------------- +// Commit +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::CommitInlineL() + { + __ASSERT_DEBUG( ( iConversionOffset >= 0 ), + User::Panic( KPeninputICFJp, EPanicICFJpCommitInlineNotReady ) ); + + // Set next conversion starting position + const TInt nextPosition = ( iDivisionPoint < 0 ) + ? iConversionArea.HigherPos() + : iConversionArea.LowerPos() + iDivisionPoint; + + const TInt nextTransitoryInputLength = ( iDivisionPoint > 0 ) + ? iConversionArea.Length() - iDivisionPoint + : 0; + const TTransitoryInputAreaState state = ( nextTransitoryInputLength > 0 ) + ? ETransitoryInputAreaNextSegmentWait + : ETransitoryInputAreaStandby; + + // Initialize + iPreDisplayTextOffset = iDisplayTextOffset; + ResetConversion( state, nextPosition ); + ResetInputContextFieldDataL( EFalse ); + } + + +// --------------------------------------------------------------------------- +// Complete +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::CompleteInlineL() + { + __ASSERT_DEBUG( ( iConversionOffset >= 0 ), + User::Panic( KPeninputICFJp, EPanicICFJpCommitInlineNotReady ) ); + + // Initialize + ResetConversion( ETransitoryInputAreaStandby, iConversionOffset ); + ResetInputContextFieldDataL( EFalse ); + } + + +// --------------------------------------------------------------------------- +// Cancel +// For synchronization with Edwin, Call SetTextL() after this function. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::CancelInlineL() + { + if ( iConversionOffset < 0 ) + { + return; + } + + ResetConversion( ETransitoryInputAreaStandby, iConversionOffset ); + ResetInputContextFieldDataL( ETrue ); + } + + +// --------------------------------------------------------------------------- +// Set cursor position on context field. +// aPosition is the value when the head of an unconfirmed string is 0. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepInputContextFieldJp::SetCursorPosition( + const TInt aPosition ) + { + __ASSERT_DEBUG( ( iConversionOffset >= 0 ), + User::Panic( KPeninputICFJp, + EPanicICFJpCursorPositionNotReady ) ); + + DoUpdateInline( PositionInArea( aPosition + iConversionOffset, + iConversionArea ), iDivisionPoint ); + } + +// --------------------------------------------------------------------------- +// Return one character before cursor position. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C TChar CFepInputContextFieldJp::CharacterOnCursor() + { + const TInt cursorPos = iSelectedCompositionText.iCursorPos; + + return ( ( iBuffer && cursorPos > 0 ) && ( iConversionOffset < 0 ) ) + ? (TChar)( ( iBuffer->Mid( cursorPos - 1, 1 ) )[0] ) + : TChar( KNoChar ); + } + +// --------------------------------------------------------------------------- +// Return one character before cursor position moving aMovingIndex. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C TChar CFepInputContextFieldJp::CharacterAroundCursor( + const TInt aMovingIndex ) + { + const TInt cursorPos = iSelectedCompositionText.iCursorPos + aMovingIndex; + + return ( ( iBuffer ) + && ( iConversionOffset < 0 ) + && ( cursorPos > 0 ) + && ( cursorPos <= iBuffer->Length() ) ) + ? (TChar)( ( iBuffer->Mid( cursorPos - 1, 1 ) )[0] ) + : TChar( KNoChar ); + } + +// --------------------------------------------------------------------------- +// Return cursor position +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CFepInputContextFieldJp::CursorPosition() const + { + return iSelectedCompositionText.iCursorPos - iConversionOffset; + } + +// --------------------------------------------------------------------------- +// Return dividing position +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CFepInputContextFieldJp::DivisionPoint() const + { + return iDivisionPoint; + } + +// --------------------------------------------------------------------------- +// C++ default constructor can NOT contain any code, that might leave. +// --------------------------------------------------------------------------- +// +CFepInputContextFieldJp::CFepInputContextFieldJp( TRect aRect, + CFepUiLayout* aUiLayout, + TInt aControlId ): + CFepInputContextField(aRect,aUiLayout,aControlId), + iConversionOffset(-1), + iDivisionPoint(-1), + iConversionArea( 0, 0 ), + iConvertingState(ETransitoryInputAreaStandby) + { + SetControlType(ECtrlInputContextArea); + iPreConversionData.iCmd = EPeninputICFInitial; + iPreConversionData.iStartPos = 0; + iPreConversionData.iMidPos = -1; + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave. +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::ConstructL() + { + BaseConstructL(); + + iDummyControl = new (ELeave) CCoeControl(); + iPictoInterface = CAknPictographInterface::NewL( *iDummyControl, *this ); + + TCallBack callback( StaticPictographCallBack, this ); + SetPictographCallBackL( callback ); + } + +// --------------------------------------------------------------------------- +// Draws the text conversion +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::DrawConversion() + { + const TInt displayOffset = iRelativePos + iDisplayTextOffset; + const TInt lowPosition = Max( iConversionArea.LowerPos() - displayOffset, + 0 ); + const TInt highPosition = Min( iConversionArea.HigherPos() - displayOffset, + iDisplayText.Length() ); + const TInt divisionPosition = Max( iConversionArea.LowerPos() + + iDivisionPoint + - displayOffset, + 0 ); + + // Draw + if ( iDivisionPoint > 0 && highPosition > 0 ) + { + // Draw the conversion data. + DoDrawConversion( lowPosition, divisionPosition, + EFirstTargetColors ); + + // Draw the next conversion data. + DoDrawConversion( divisionPosition, highPosition, + ETransitoryInputAreaColors ); + } + else + { + // Draw the conversion data. + DoDrawConversion( lowPosition, highPosition, + ETransitoryInputAreaColors ); + } + } + +// --------------------------------------------------------------------------- +// Draws the text conversion( main frame ) +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::DoDrawConversion( const TInt aStartPos, + const TInt aEndPos, + const TContextFieldDrawColorJp aConversion ) + { + if ( !iFont || iInDragging ) + { + // no draw + return; + } + + CFbsBitGc* gc = static_cast( BitGc() ); + TRect converseRect = Rect(); + const TInt baseLine = iFont->AscentInPixels()/2 + converseRect.Height()/2; + + //The conversion rectangular sets + converseRect.iTl.iX = PositionInWindow( aStartPos ).iX; + converseRect.iBr.iX = + ( PositionInWindow( aEndPos ).iX > converseRect.iBr.iX ) + ? converseRect.iBr.iX : PositionInWindow( aEndPos ).iX; + converseRect.iTl.iY += baseLine - ( iFont->AscentInPixels() + + KConversionRectMarginY ); + converseRect.iBr.iY += baseLine + iFont->DescentInPixels() + + KConversionRectMarginY - Rect().Height(); + const TInt conversionBaseLine = baseLine + Rect().iTl.iY + - converseRect.iTl.iY; + + // draw selection by inverting colors in the selected text rectancle + gc->SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc->SetPenSize( PenSize() ); + + // Draw pen color and brush color select + switch ( aConversion ) + { + case EFirstTargetColors: + { + const TRgb KTargetBgColor = AKN_LAF_COLOR_STATIC(210); + gc->SetPenColor( BkColor() ); + gc->SetBrushColor( KTargetBgColor ); + } + break; + case ETransitoryInputAreaColors: + { + const TRgb KTransitoryBgColor = AKN_LAF_COLOR_STATIC(244); + gc->SetPenColor( PenColor() ); + gc->SetBrushColor( KTransitoryBgColor ); + } + break; + default: + break; + } + + // draw text + TPtrC ptr(iDisplayText.Mid( aStartPos, aEndPos - aStartPos )); + gc->DrawText( ptr, + converseRect, + conversionBaseLine, + CGraphicsContext::ELeft ); + + if (iPictoInterface) + { + iPictoInterface->Interface()->DrawPictographsInText( + *gc, *iFont, ptr, converseRect, + conversionBaseLine, CGraphicsContext::ELeft, KGapLeftOfEachLine ); + } + } + +// --------------------------------------------------------------------------- +// Reculculate offset of context field when cursor position move. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::DoUpdateInline( const TInt aCursorPosition, + const TInt aDivisionPoint ) + { + __ASSERT_DEBUG( ( iConversionOffset >= 0 ), + User::Panic( KPeninputICFJp, + EPanicICFJpDoUpdateInlineNotReady ) ); + + // Set Cursor and Region + SetCursorVisible( EFalse, EFalse ); + iDivisionPoint = aDivisionPoint; + iSelectedCompositionText.SetSelection( aCursorPosition, aCursorPosition ); + + CalculateDisplayTransitoryText(); + + iInsertionPoint->SetPosition( PositionOfInsertionPointOnWindow() ); + if ( iDivisionPoint < 0 ) + { + SetCursorVisible( ETrue, ETrue ); + } + Draw(); + UpdateArea(Rect(),EFalse); + } + +// --------------------------------------------------------------------------- +// Calculate display text offset +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::CalculateDisplayTransitoryText() + { + if( !iBuffer || !iFont || ( iConversionOffset < 0 ) ) + { + // Nothing is done at no-buffer or no-font or non-converting state. + return; + } + + // Check the cursor or dividing point. + // These valid are on Editor, and not using any offset. + const TInt conversionOffset = iConversionOffset; + const TInt divisionPoint = conversionOffset + iDivisionPoint; + const TInt conversionEnd = iConversionArea.HigherPos(); + const TInt icfWidth = iCorrectedRect.Width(); + const TInt linehead = iRelativePos; + const TInt cursorPosition = iSelectedCompositionText.iCursorPos; + + TInt displayOffset = iRelativePos + iDisplayTextOffset; + TInt cursorPos = cursorPosition; + TInt endPos = cursorPos; + TBool leftMarginX = EFalse; + TBool rightMarginX = EFalse; + const TInt pixels = BufferWidthInPixels( displayOffset, conversionEnd ); + + if ( iDivisionPoint < 0 ) + { + // Non conversion + if ( cursorPos == conversionEnd ) + { + // Append to transitory input area + leftMarginX = ETrue; + rightMarginX = EFalse; + } + else + { + // Insert to transitory input area + leftMarginX = ETrue; + rightMarginX = ( pixels > icfWidth ) ? ETrue : EFalse; + } + } + else + { + // Conversion + switch ( iConvertingState ) + { + case ETransitoryInputAreaConverting: + cursorPos = conversionOffset; + endPos = divisionPoint; + leftMarginX = EFalse; + rightMarginX = EFalse; + break; + case ETransitoryInputAreaSwitching: + cursorPos = divisionPoint; + endPos = cursorPos; + leftMarginX = ETrue; + rightMarginX = ( pixels > icfWidth ) ? ETrue : EFalse; + break; + default: + break; + } + } + + TInt cursorPixels = BufferWidthInPixels( displayOffset, endPos ); + const TInt rightMaxPixels = ( rightMarginX ) + ? icfWidth + - iFont->MaxNormalCharWidthInPixels() + * KConversionRightMarginX + : icfWidth; + + // Right Check by Pixels + while ( rightMaxPixels < cursorPixels ) + { + // Too right + ++displayOffset; + cursorPixels = BufferWidthInPixels( displayOffset, endPos ); + } + + const TInt leftMinPos = ( leftMarginX ) + ? displayOffset + KConversionLeftMarginX + : displayOffset; + + // Left Check by Position + if ( cursorPos < leftMinPos ) + { + // Too left + displayOffset = ( leftMarginX ) ? cursorPos - KConversionLeftMarginX + : cursorPos; + } + + displayOffset = Max( displayOffset, linehead ); + TInt lineEnd = iBuffer->Mid( cursorPosition ).Locate( + CEditableText::EParagraphDelimiter ); + lineEnd = lineEnd < 0? iBuffer->Des().Length() : lineEnd + cursorPosition; + + SetDisplayData( linehead, displayOffset ); + iDisplayText.Set( iBuffer->Mid( displayOffset, lineEnd - displayOffset ) ); + } + +// --------------------------------------------------------------------------- +// Calculate width in pixels of selecting area in iBuffer. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CFepInputContextFieldJp::BufferWidthInPixels( TInt aStartPos, + TInt aEndPos ) const + { + const TInt length = Max( aEndPos - aStartPos, 0 ); + + return iFont->TextWidthInPixels( iBuffer->Mid( aStartPos, length ) ); + } + +// --------------------------------------------------------------------------- +// Set member data for display. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::SetDisplayData( TInt aLineHead, + TInt aDisplayOffset ) + { + const TInt cursor = iSelectedCompositionText.iCursorPos - aLineHead; + + iDisplayTextOffset = Max( aDisplayOffset - aLineHead, 0 ); + iRelativePos = aLineHead; + iDisplayTextCurSel.SetSelection( cursor, cursor ); + } + +// --------------------------------------------------------------------------- +// Reset member data of parent class. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::ResetInputContextFieldDataL( TBool aDrawFlag ) + { + + if ( aDrawFlag ) + { + CFepInputContextField::SetTextL( iPreConversionData ); + } + else + { + iSelectedCompositionText = iPreConversionData.iCurSel; + TPtr ptr = iBuffer->Des(); + ptr = iPreConversionData.iText; + SetCursorVisible( iPreConversionData.iCursorVisibility, + iPreConversionData.iCursorSelVisible ); + iInsertionPoint->SetPosition( PositionOfInsertionPointOnWindow() ); + } + delete iPreBuffer; + iPreBuffer = NULL; + } + +// --------------------------------------------------------------------------- +// Reset member data of transitory input area. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::ResetConversion( + TTransitoryInputAreaState aState, + TInt aPosition ) + { + iConversionOffset = -1; + iDivisionPoint = -1; + iConvertingState = aState; + iConversionArea.SetSelection( aPosition, aPosition ); + } + + +// --------------------------------------------------------------------------- +// The argument returns whether it is the right side from transitory input +// area. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CFepInputContextFieldJp::IsRightFromConversion( TInt aX ) const + { + const TInt displayOffset = iRelativePos + iDisplayTextOffset; + const TInt xPosOffset = aX - iCorrectedRect.iTl.iX; + const TInt highPosOffset = iConversionArea.HigherPos() - displayOffset; + const TInt highPosPixel = iFont->TextWidthInPixels( + iDisplayText.Left( highPosOffset ) ); + const TBool pointFlag = ( xPosOffset > highPosPixel ) ? ETrue : EFalse; + const TBool curposFlag = ( CursorPosition() == iConversionArea.Length() ) + ? ETrue : EFalse; + + return ( pointFlag && curposFlag && ( iDivisionPoint < 0 ) ) + ? ETrue + : EFalse; + } + + +// --------------------------------------------------------------------------- +// From class CFepUiBaseCtrl +// Handle pointer up event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepInputContextFieldJp::HandlePointerUpEventL( + const TPoint& aPoint ) + { + if ( iConversionOffset < 0 ) + { + // Non-conversion + // Behave the common function + return ( !CFepInputContextField::HandlePointerUpEventL(aPoint) ) ? + NULL : this; + } + + // Setting of derivation origin + CFepUiBaseCtrl::HandlePointerUpEventL(aPoint); + iScrolling = EFalse; + + // Does Freely pointer event + if( iPreCaptureCtrl ) + { + // In case of not being, it makes and does freely. + iPreCaptureCtrl->CapturePointer(); + } + else + { + // In case of being, it does freely. + CapturePointer( EFalse ); + } + + if ( iAllCompleteFlag ) + { + iAllCompleteFlag = IsRightFromConversion( aPoint.iX ); + } + + const TInt eventType = ( iAllCompleteFlag ) ? EEventIcfCompleteAll + : EEventIcfPointerUp; + TInt cursorPos = PositionInDisplayText( aPoint.iX ); + SetPositionOfInsertionPointInBuffer( cursorPos ); + + // selection was dragged inside visible buffer -> update selection + TCursorSelection area = iConversionArea; + if ( iConvertingState == ETransitoryInputAreaSwitching ) + { + // At least one character are the state that has been selected. + area.iAnchorPos += KConversionSelectingMargin; + } + const TInt newPosition + = PositionInArea( iSelectedCompositionText.iCursorPos, area ); + const TInt pos = newPosition - iConversionOffset; + if ( iDivisionPoint < 0 ) + { + DoUpdateInline( newPosition, + ( iDivisionPoint < 0 ) ? iDivisionPoint : pos ); + } + + TPtrC position((TUint16*) &pos ); + ReportEvent( eventType, position ); + + return this; + } + +// --------------------------------------------------------------------------- +// From class CFepUiBaseCtrl +// Handle pointer down event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepInputContextFieldJp::HandlePointerDownEventL( + const TPoint& aPoint ) + { + if ( iConversionOffset < 0 ) + { + // Non-conversion + // Behave the common function + return ( !CFepInputContextField::HandlePointerDownEventL(aPoint) ) ? + NULL : this; + } + + if ( ( iDivisionPoint >= 0 ) + && ( iConvertingState == ETransitoryInputAreaConverting ) ) + { + // Nothing is done at converting state.. + return this; + } + + // Conversion + CFepUiBaseCtrl::HandlePointerDownEventL( aPoint ); + iAllCompleteFlag = IsRightFromConversion( aPoint.iX ); + iScrolling = EFalse; + + // Set cursor position + iScrolling = EFalse; + iPreCaptureCtrl = CapturePointer(); + + return this; + } + + +// --------------------------------------------------------------------------- +// From class CFepUiBaseCtrl +// Handle pointer move event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepInputContextFieldJp::HandlePointerMoveEventL( + const TPoint& aPoint ) + { + + if ( iConversionOffset < 0 ) + { + // Non-conversion + // Behave the common function + return ( !CFepLayoutEditAreaBase::HandlePointerMoveEventL(aPoint) ) ? + NULL : this; + } + + if( !PointerDown() || iDimmed || ( ( iDivisionPoint >= 0 ) + && ( iConvertingState == ETransitoryInputAreaConverting ) ) ) + { + // Nothing is done at no-pointerdown, no-dimm, converting state.. + return this; + } + + // Updating by the drug operation. + const TInt displayOffset = iRelativePos + iDisplayTextOffset; + const TInt newPos = PositionInArea( PositionInDisplayText( aPoint.iX ) + + displayOffset, + iConversionArea ); + const TBool checkOfPosition = + ( newPos != iSelectedCompositionText.iCursorPos ) + ? ETrue : EFalse; + + if ( iAllCompleteFlag ) + { + iAllCompleteFlag = IsRightFromConversion( aPoint.iX ); + } + + if( checkOfPosition ) + { + // Updating when cursor position or dividing position changes. + // Even if the pointer moves, the cursor position is never changed. + TCursorSelection area = iConversionArea; + if ( iConvertingState == ETransitoryInputAreaSwitching ) + { + // At least one character are the state that has been selected. + area.iAnchorPos += KConversionSelectingMargin; + } + const TInt dividingPoint = PositionInArea( newPos, area ) + - iConversionOffset; + DoUpdateInline( newPos, ( iDivisionPoint < 0 ) + ? iDivisionPoint + : dividingPoint ); + } + + return this; + } + +// --------------------------------------------------------------------------- +// From class CFepLayoutEditAreaBase +// Draws the text into the given graphic context +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepInputContextFieldJp::DrawContent( CBitmapContext* aGc, + const TRect& aRect ) + { + if ( iConvertingState == ETransitoryInputAreaNextSegmentWait ) + { + return; + } + if ( ( iConversionOffset < 0 ) || !iBuffer || !iFont || iInDragging ) + { + // Non-conversion, no-buffer, no-font, no-dragging + // Behave the common function + CFepLayoutEditAreaBase::DrawContent( aGc, aRect ); + + if (iPictoInterface) + { + TRect editRect = Rect(); + aGc->SetBrushStyle( CGraphicsContext::ENullBrush ); + aGc->UseFont( iFont ); + aGc->SetPenColor( iTextColor ); + const TInt baseLine = iFont->AscentInPixels()/2 + editRect.Height()/2; + + iPictoInterface->Interface()->DrawPictographsInText( + *aGc, *iFont, iDisplayText, editRect, + baseLine, CGraphicsContext::ELeft, KGapLeftOfEachLine ); + + aGc->DiscardFont(); + } + return; + } + + TRect editRect = Rect(); + if( aRect.Intersects( editRect ) ) + { + // draw text + // set brush invisible so the background + // of the edit area does not get painted white + const TInt baseLine = iFont->AscentInPixels()/2 + editRect.Height()/2; + aGc->SetBrushStyle( CGraphicsContext::ENullBrush ); + aGc->UseFont( iFont ); + aGc->SetPenColor( iTextColor ); + aGc->DrawText( iDisplayText, + editRect, + baseLine, + CGraphicsContext::ELeft, + KGapLeftOfEachLine ); + if (iPictoInterface) + { + iPictoInterface->Interface()->DrawPictographsInText( + *aGc, *iFont, iDisplayText, editRect, + baseLine, CGraphicsContext::ELeft, KGapLeftOfEachLine ); + } + + if( iConversionOffset >= 0 ) + { + // Draw text conversion + DrawConversion(); + } + + iInsertionPoint->Draw( aGc, ETrue ); + + aGc->DiscardFont(); + } + } + +void CFepInputContextFieldJp::DrawPictographArea() + { + if ( iPictoCallBack.iFunction ) + { + iPictoCallBack.CallBack(); + } + } + +void CFepInputContextFieldJp::SetPictographCallBackL( TCallBack& aCallBack ) + { + iPictoCallBack = aCallBack; + } + +// Callback for doing a redraw when animating pictographs +TInt CFepInputContextFieldJp::StaticPictographCallBack( TAny* aPtr ) + { + CFepInputContextFieldJp* self = static_cast( aPtr ); + self->PictographCallBack(); + return KErrNone; + } + +void CFepInputContextFieldJp::PictographCallBack() + { + Draw(); + //UpdateArea(Rect(),EFalse); + } + +// End of File