/*
* 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 <peninputlayout.h>
#include <peninputcontextfieldjp.h>
#include <peninputlayoutinsertionpoint.h>
#include <peninputcmd.h>
#include <aknenv.h>
#include <peninputeventjp.h>
#include <txtetext.h>  // 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<CFbsBitGc*>( 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<CFepInputContextFieldJp*>( aPtr );
    self->PictographCallBack();
    return KErrNone;
    }

void CFepInputContextFieldJp::PictographCallBack()
    {
    Draw();
    //UpdateArea(Rect(),EFalse);
    }

//  End of File