/*

* 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;