/*

* Copyright (c) 2008 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:           

 *      Provides the CAknFepUICtrlPinyinEEP definition 

 *

*/

#include <eikenv.h>

#include <eikappui.h>

#include <AknsSkinInstance.h> 

#include <AknsUtils.h> 

#include <AknsDrawUtils.h> 

#include <skinlayout.cdl.h>

#include "aknlayoutscalable_avkon.cdl.h"

#include "aknfepuictrlpinyineep.h"

#include "aknfepuilayoutdatamgr.h"

#include "aknfepchineseuidataconv.h"

_LIT(KFullStop, "\x002E");

_LIT( KToneMark1, "\x0020");

_LIT( KToneMark2, "\x02CA");

_LIT( KToneMark3, "\x02C7");

_LIT( KToneMark4, "\x02CB");

_LIT( KToneMark5, "\x02D9");

_LIT( KLeftBracket, "\x0028");

const TInt KControlNum = 1;

const TInt KMaxCharNum = 200;

const TInt KMaxDispNum = 200;

// ---------------------------------------------------------

// NewL function.

// ---------------------------------------------------------

//

CAknFepUICtrlPinyinEEP* CAknFepUICtrlPinyinEEP::NewL( RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr )

    {

    CAknFepUICtrlPinyinEEP* self=CAknFepUICtrlPinyinEEP::NewLC( aParent, aLafDataMgr );

    CleanupStack::Pop(self); // self;

    return self;

    }

// ---------------------------------------------------------

// NewLC function.

// ---------------------------------------------------------

//

CAknFepUICtrlPinyinEEP* CAknFepUICtrlPinyinEEP::NewLC( RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr )

    {

    CAknFepUICtrlPinyinEEP* self = new(ELeave)CAknFepUICtrlPinyinEEP( aLafDataMgr );

    CleanupStack::PushL( self );

    self->ConstructL( aParent, aLafDataMgr);

    return self;

    }

// ---------------------------------------------------------

// Destructor.

// ---------------------------------------------------------

//

CAknFepUICtrlPinyinEEP::~CAknFepUICtrlPinyinEEP()

    {

    if ( iEditableEntryPane )

        {

        delete iEditableEntryPane;

        iEditableEntryPane = NULL;

        }

//    if ( iBgContext )

//        {

//        delete iBgContext;

//        iBgContext = NULL;

//        }

    if ( iAbsoluteBuffer )

        {

        delete iAbsoluteBuffer;

        iAbsoluteBuffer = NULL;

        }

    if ( iVisualBuffer )

        {

        delete iVisualBuffer;

        iVisualBuffer = NULL;

        }

    iArray.ResetAndDestroy();

    delete iKeystrokeArray;

    delete iShowKeystrokeArray;

    delete iPhraseArray;

    delete iPhraseShowKeyStrokeArray;

    delete iTempArray;

    }

// ---------------------------------------------------------

// From CCoeControl.

// ---------------------------------------------------------

//

TInt CAknFepUICtrlPinyinEEP::CountComponentControls() const

    {

    return KControlNum;

    }

// ---------------------------------------------------------

// From CCoeControl.

// ---------------------------------------------------------

//

CCoeControl* CAknFepUICtrlPinyinEEP::ComponentControl( TInt aIndex ) const

    {

    switch ( aIndex )

        {

        case EEditableEntryPane:

            return iEditableEntryPane;

        default:

            return NULL;

        }

    }

// ---------------------------------------------------------

// From CCoeControl.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::Draw( const TRect& /*aRect*/) const

    {

    }

// ---------------------------------------------------------

// From CCoeControl.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SizeChanged()

    {

    LayoutContainedControls();

    }

// ---------------------------------------------------------

// Set the text buffer and posit the cursor index.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SetText( const TDesC& aDes, TInt aCursorIndex, TBool aMiniQwertyZhuyin )

    {

    iMiniQwertyZhuyin = aMiniQwertyZhuyin;

    iAbsoluteUnderlineBeg = -1;

    iAbsoluteUnderlineEnd = -1;

    iAbsoluteHighlightBeg = -1;

    iAbsoluteHighlightEnd = -1;

    iArray.ResetAndDestroy();

    TInt absoluteBufferLen = iAbsoluteBuffer->Length();

    TInt desLen = aDes.Length();

    if ( aCursorIndex > aDes.Length() )

        {

        aCursorIndex = aDes.Length();

        }

    else if ( aCursorIndex < 0 )

        {

        aCursorIndex = 0;

        }

    // cursor is at the end of buffer and add a character 

    if ( aDes.Left( iAbsoluteBuffer->Length() ) == *iAbsoluteBuffer

        && iAbsoluteCursorPos == iAbsoluteBuffer->Length() && aCursorIndex

        == aDes.Length() )

        {

        Append( aDes.Right( aDes.Length() - iAbsoluteBuffer->Length() ) );

        }

    //    delete one character

    else if ( iAbsoluteBuffer->Left( aCursorIndex ).Compare(aDes.Left(aCursorIndex)) == 0

        && aCursorIndex < iAbsoluteCursorPos

        && iAbsoluteBuffer->Compare( aDes ) != 0

        && 0 == iAbsoluteBuffer->Right( absoluteBufferLen - iAbsoluteCursorPos ).Compare( 

            aDes.Right( desLen - aCursorIndex)) )

        {

        Delete( iAbsoluteCursorPos - (iAbsoluteBuffer->Length()

            - aDes.Length()), iAbsoluteBuffer->Length() - aDes.Length() );

        }

    else if ( iAbsoluteBuffer->Length() < aDes.Length()

        && iAbsoluteBuffer->Left( iAbsoluteCursorPos )

            == aDes.Left( iAbsoluteCursorPos )

        && iAbsoluteBuffer->Right( iAbsoluteBuffer->Length()

            - iAbsoluteCursorPos ) == aDes.Right( iAbsoluteBuffer->Length()

            - iAbsoluteCursorPos ) && aCursorIndex - iAbsoluteCursorPos

        == aDes.Length() - iAbsoluteBuffer->Length() )

        {

        TPtrC tmp = aDes.Mid( iAbsoluteCursorPos, aDes.Length()

            - iAbsoluteBuffer->Length() );

        Insert( iAbsoluteCursorPos, tmp );

        }

    else

        {

        SetText( aDes );

        SetCursor( aCursorIndex );

        }

    }

// ---------------------------------------------------------

// Set the text buffer and posit the cursor index for zhuyin.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SetTextForZhuyin( 

    const TDesC& aDes, 

    TInt aCursor, 

    TInt aChineseCount, 

    const TDesC& aJudgeSeed, 

    TInt aKeystroke, 

    TBool aInvalid,

    TBool aMiniQwertyZhuyin)

    {

    iMiniQwertyZhuyin = aMiniQwertyZhuyin;

    TInt actionType = EZhuyinNULL;

    if ( aKeystroke == 0 && aJudgeSeed.Compare(iJudgeSeed) == 0)

        {

        actionType = EZhuyinMoveCursor;

        }

    else if ( aChineseCount == iChineseCount + 1 )

        {

        actionType = EZhuyinNULL;

        }

    else if ( aKeystroke == 0 && aJudgeSeed.Length() <= iJudgeSeed.Length() - 1)

        {

        actionType = EZhuyinDelete;

        }

    else

        {

        if ( aJudgeSeed.Length() == iJudgeSeed.Length())

            {

            if ( aJudgeSeed.Left(aKeystroke - 1).Compare(iJudgeSeed.Left(aKeystroke - 1)) == 0 

                && aJudgeSeed.Mid(aKeystroke - 1,1).Compare(iJudgeSeed.Mid(aKeystroke - 1,1)) != 0 ) 

                {

                actionType = EZhuyinReplace;

                }

            else if ( aCursor == GetCursor() )

                {

                actionType = EZhuyinReplace;

                }

            else

                {

                actionType = EZhuyinMoveCursor;

                }

            }

        else if ( aJudgeSeed.Length() == iJudgeSeed.Length() + 1)

            {

            actionType = EZhuyinInsert;

            }

        else if ( aJudgeSeed.Length() == iJudgeSeed.Length() - 1)

            {

            actionType = EZhuyinDelete;

            }

        else if ( KErrNotFound != iJudgeSeed.Find( aJudgeSeed ) )

            {

            actionType = EZhuyinDelete;

            }

        else

            {

            actionType = EZhuyinNULL;

            }

        }

    iArray.ResetAndDestroy();

    iJudgeSeed = aJudgeSeed;

    iChineseCount = aChineseCount;

    if ( iLastValid && aInvalid )

        {

        TInt newOffset = 0;

        TPtrC ptr = iAbsoluteBuffer->Des();

        for ( TInt i = 0; i < iOffset; i++ )

            {

            if ( ptr.Mid(i,1).Compare(KFullStop) == 0 )

                {

                continue;

                }

            newOffset++;

            }

        iOffset = newOffset;

        }

    else if ( !iLastValid && !aInvalid )

        {

        TInt newOffset = 0;

        TInt i = 0;

        TPtrC ptr = aDes;

        for ( i = 0; i < iOffset && newOffset < ptr.Length(); )

            {

            if ( ptr.Mid(newOffset,1).Compare(KFullStop) != 0 )

                {

                i++;

                }

            newOffset++;

            }

        iOffset = newOffset;

        }

    iLastValid = !aInvalid;

    switch ( actionType )

        {

        case EZhuyinInsert:

            {

            *iAbsoluteBuffer = aDes;

            iAbsoluteCursorPos = aCursor;

            this->CalculateVisualTextForInsert( 0, aDes );

            this->iEditableEntryPane->SetText( *iVisualBuffer );

            this->CalculateVisualIndex();

            iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos

                - iOffset );

            }

            break;

        case EZhuyinReplace:

            {

            TRect panerect = iEditableEntryPane->Rect();

            TAknTextLineLayout textPaneTextLayout = 

                    CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

            const CFont* font = AknLayoutUtils::FontFromId(

                textPaneTextLayout.iFont, 

                NULL );

            TInt lenToCursor = font->TextWidthInPixels( aDes.Mid( iOffset,

                aCursor - iOffset ) );

            if ( lenToCursor < panerect.Width() - panerect.Width()

                *KLROffset/KDenominator * 2 )

                {

                *iAbsoluteBuffer = aDes;

                iAbsoluteCursorPos = aCursor;

                TInt stride = 0;

                for (stride = 1;; stride ++ )

                    {

                    if ( iOffset + stride > aDes.Length() )

                        {

                        break;

                        }

                    TInt tmpFontLen = font->TextWidthInPixels( aDes.Mid(

                        iOffset, stride ) );

                    if ( tmpFontLen > panerect.Width() - panerect.Width()

                        *KLROffset/KDenominator * 2 )

                        {

                        break;

                        }

                    }

                *iVisualBuffer = aDes.Mid( iOffset, stride - 1 );

                iEditableEntryPane->SetText( *iVisualBuffer );

                iEditableEntryPane->SetCursorPosition( aCursor-iOffset );

                }

            else

                {

                SetText( aDes, aCursor );

                }

            CalculateVisualIndex();

            break;

            }

        case EZhuyinDelete:

            {

            *iAbsoluteBuffer = aDes;

            iAbsoluteCursorPos = aCursor;

            this->CalculateVisualTextForDelete( 0, 0 );

            this->iEditableEntryPane->SetText( *iVisualBuffer );

            this->CalculateVisualIndex();

            iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos

                - iOffset );

            }

            break;

        default:

            SetText( aDes, aCursor );

        }

    }

// ---------------------------------------------------------

// Set the text buffer and maintain the current cursor position.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SetText( const TDesC& aDes )

    {

    iAbsoluteCursorPos = 0;

    iOffset = 0;

    iAbsoluteBuffer->Des().Zero();

    iVisualBuffer->Des().Zero();

    *iAbsoluteBuffer = aDes;

    CalculateVisualTextForMoveRight();

    iEditableEntryPane->SetText( *iVisualBuffer );

    CalculateVisualIndex();

    }

// ---------------------------------------------------------

// Set the cursor position.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SetCursor( const TInt aIndex )

    {

    SetCursorForMoveRight( aIndex );

    }

// ---------------------------------------------------------

// get the position index of cursor.The max cursor index must 

// be larger than the length of text buffer by 1.

// ---------------------------------------------------------

//

TInt CAknFepUICtrlPinyinEEP::GetCursor()

    {

    return iAbsoluteCursorPos;

    }

// ---------------------------------------------------------

// move cursor to the left by a 1 stride.

// ---------------------------------------------------------

//

TBool CAknFepUICtrlPinyinEEP::MoveCursorLeft( TInt aStride  )

    {

    if ( iAbsoluteCursorPos - aStride < 0 )

        {

        return EFalse;

        }

    if ( iEditableEntryPane->MoveCursorLeft( aStride ) == 0 )

        {

        iAbsoluteCursorPos = iAbsoluteCursorPos - aStride;

        }

    else

        {

        iAbsoluteCursorPos = iAbsoluteCursorPos - aStride;

        SetCursorForMoveLeft( iAbsoluteCursorPos );

        }

    return ETrue;

    }

// ---------------------------------------------------------

// move cursor to the right by a 1 stride.

// ---------------------------------------------------------

//

TBool CAknFepUICtrlPinyinEEP::MoveCursorRight( TInt aStride )

    {

    if ( iAbsoluteCursorPos + aStride > iAbsoluteBuffer->Length() )

        {

        return EFalse;

        }

    if ( iEditableEntryPane->MoveCursorRight( aStride ) == 0 )

        {

        iAbsoluteCursorPos = iAbsoluteCursorPos + aStride;

        }

    else

        {

        iAbsoluteCursorPos = iAbsoluteCursorPos + aStride;

        SetCursorForMoveRight( iAbsoluteCursorPos );

        }

    return ETrue;

    }

// ---------------------------------------------------------

// active the cursor,the cursor will be black and with a wink

// this cursor state represent this control is focused.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::ActiveCursor()

    {

    iEditableEntryPane->ActiveCursor();

    }

// ---------------------------------------------------------

// deactive the cursor, the cursor will be gray and no wink this cursor

// state represent this control with no focus.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::DeactiveCursor()

    {

    iEditableEntryPane->DeactiveCursor();

    }

// ---------------------------------------------------------

// enable the cursor,the cursor will be drawn.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::EnableCursor()

    {

    iEditableEntryPane->EnableCursor();

    }

// ---------------------------------------------------------

// deactive the cursor, the cursor will not be drawn.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::DisableCursor()

    {

    iEditableEntryPane->DisableCursor();

    }

// ---------------------------------------------------------

// set the beginning and ending index for the underline text.

// ---------------------------------------------------------

//

void CAknFepUICtrlPinyinEEP::SetUnderline( TInt aBeg, TInt aEnd )

    {

    CAknFepUICtrlEEPControl::TSegment* tmp =

        new CAknFepUICtrlEEPControl::TSegment ( aBeg, aEnd, CAknFepUICtrlEEPControl::EUnderline );

    iArray.Append( tmp );

    TInt visualUnderlineBeg = aBeg - iOffset;

    TInt visualUnderlineEnd = aEnd - iOffset;

    if (

        visualUnderlineBeg < 0 &&

        visualUnderlineEnd < 0

        ||

        visualUnderlineBeg> iVisualBuffer->Length() - 1 &&

        visualUnderlineEnd> iVisualBuffer->Length() - 1

    )

        {

        visualUnderlineBeg = -1;

        visualUnderlineEnd = -1;

        }

    else

        {

        if ( visualUnderlineBeg < 0 )

            {

            visualUnderlineBeg = 0;

            }

        if ( visualUnderlineEnd> iVisualBuffer->Length() - 1 )

            {

            visualUnderlineEnd = iVisualBuffer->Length() - 1;

            }

        }