/*

* Copyright (c) 2002-2005 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:  vkb conposition field implementation

*

*/

#include <peninputlayoutbasecontrol.h>

#include <AknsDrawUtils.h> 

#include <barsread.h>

#include "peninputvkbcompositionfield.h"

#include "peninputvkbevent.h"

#include "peninputvkb.hrh"

#include "peninputvkbdataprovider.h"

#include "AknFepVkbPinyinAnalyser.h"

#include "AknFepVkbPinyinAnalyserDb.h"

#include "peninputvkbdatamgr.h"

//Tone make

const TUint16 KCharToneMarkZhuyin1 = 0x0020;

const TUint16 KCharToneMarkPinyin1 = 0x02C9;

const TUint16 KCharToneMark2 = 0x02CA;

const TUint16 KCharToneMark3 = 0x02C7;

const TUint16 KCharToneMark4 = 0x02CB;

const TUint16 KCharToneMark5 = 0x02D9;

const TInt32 KInvalidResId = -1;

const TInt KInvalidImg = -1 ;

//Manual stroke separator char

const TUint16 KStrokeManuSeparator = 0x2022;

//Manul separator char       

const TUint KManulSeparator = 0x0027; // "'"

//Manul separator char       

const TUint KAutoSeparator = 0x002e;   //"."

_LIT(KWildChar, "\xFF1F");

_LIT(KInternalWildChar, "\x002B");

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

// Helper function

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

//

//Don't test aKey's length, treat as programming error!

inline TBool IsKeyToneMark(const TDesC& aKey)

    {

    return   (aKey[0] == KCharToneMarkZhuyin1 ||

              aKey[0] == KCharToneMarkPinyin1 ||

              aKey[0] == KCharToneMark2 ||

              aKey[0] == KCharToneMark3 ||

              aKey[0] == KCharToneMark4 ||

              aKey[0] == KCharToneMark5 );

    }

inline TBool IsKeyAutoSeparator(const TDesC& aKey)

    {

    return (aKey[0] == KAutoSeparator );

    }

inline TBool IsKeyManualSeparator(const TDesC& aKey)

    {

    return (aKey[0] == KManulSeparator || aKey[0] == KStrokeManuSeparator);

    }

inline TBool IsKeyInternalWildChar(const TDesC& aKey)

    {

    return (aKey[0] == KInternalWildChar()[0] );

    }

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

// Constructor

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

//

CCompositionElement* CCompositionElement::NewLC(const TDesC& aKey)

    {

    TInt keyType = EElementTypeCompositionChar;   

    if( IsKeyAutoSeparator(aKey) )

        {

        keyType = EElementTypeAutoSeparator;

        }

    else if( IsKeyManualSeparator(aKey) )

        {

        keyType = EElementTypeManualSeparator;

        }

    else if( IsKeyToneMark(aKey) )

        {

        keyType = EElementTypeTonemark;

        }

    CCompositionElement* self = new (ELeave) CCompositionElement(keyType);

    CleanupStack::PushL(self);

    if( IsKeyInternalWildChar(aKey) )

        {

        self->BaseConstructL(KWildChar);

        }

    else

        {

        self->BaseConstructL(aKey);

        }

    return self;

    }

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

// Constructor

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

//

CCompositionElement::CCompositionElement(TInt aKeyType)

:iKeyType(aKeyType)

    {

    }

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

// Constructor

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

//

void CCompositionElement::BaseConstructL(const TDesC& aKey)

    {

    iKey = aKey.AllocL();

    }

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

// Destructor

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

//

CCompositionElement::~CCompositionElement()

    {

    delete iKey;

    }

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

// Get original input length

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

//

TInt CCompositionElement::OriginalCount() const

    {

    TInt result = (IsAutoSeparator() || !iKey)? 0 : iKey->Length();

    return result;

    }

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

// UnConvert and insert the original elements back

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

//

TInt CCompositionElement::UndoConvertL(CAknFepVkbCompositionField* /*aField*/, TInt /*aStartPos*/)

    {

    return 0;

    }

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

// Get the content  of original input

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

//

const CCompositionElement* CCompositionElement::OriginalContent( TInt /*aIndex*/ ) const

    {

    return NULL;

    }

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

// Constructor

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

//

CCompositionConvertedElement* CCompositionConvertedElement::NewLC(const TDesC& aKey)

    {

    CCompositionConvertedElement* self = new (ELeave) CCompositionConvertedElement();

    CleanupStack::PushL(self);

    self->ConstructL(aKey);

    return self;

    }

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

// Constructor

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

//

CCompositionConvertedElement::CCompositionConvertedElement()

:CCompositionElement(EElementTypeConvertedChar)

    {

    }

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

// Constructor

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

//

void CCompositionConvertedElement::ConstructL(const TDesC& aKey)

    {

    BaseConstructL(aKey);

    }

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

// Destructor

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

//

CCompositionConvertedElement::~CCompositionConvertedElement()

    {

    iOriginalElements.ResetAndDestroy();

    iOriginalElements.Close();

    }

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

// UnConvert and insert the original elements back

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

//

TInt CCompositionConvertedElement::UndoConvertL(CAknFepVkbCompositionField* aField, 

                                               TInt aStartPos)

    {

    ASSERT(aStartPos >=0 && aStartPos < aField->Length());

    TInt length = iOriginalElements.Count();

    for (TInt i = length -1 ; i >= 0 ; i --)

        {

        aField->InsertL(aStartPos, iOriginalElements[i] );

        //ownership transfer to CAknFepVkbCompositionField

        iOriginalElements.Remove(i);

        }

    return length;

    }

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

// Append an original element

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

//

void CCompositionConvertedElement::AppendOriginal(const CCompositionElement* aElements)

    {

    iOriginalElements.Append(aElements);

    }

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

// Get original input length

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

//

TInt CCompositionConvertedElement::OriginalCount() const

    {

    return iOriginalElements.Count();

    }

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

// Get the content  of original input

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

//

const CCompositionElement* CCompositionConvertedElement::OriginalContent( TInt aIndex ) const

    {

    if( aIndex < 0 || aIndex > iOriginalElements.Count() - 1 )

        {

        return NULL;

        }

    return iOriginalElements[aIndex];

    }

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

// Constructor

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

//

CAknFepVkbCompositionField* CAknFepVkbCompositionField::NewL(TInt aMaxLength,

                                                            TRect aRect,

                                                            CFepUiLayout* aUiLayout,

                                                            TInt aControlId,

                                                            MAknFepVkbDataProvider* aDataProvider )

    {

    CAknFepVkbCompositionField* self = new (ELeave) CAknFepVkbCompositionField(aMaxLength,

                                                                              aRect,

                                                                              aUiLayout,

                                                                              aControlId,

                                                                              aDataProvider );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// C++ Constructor

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

//

CAknFepVkbCompositionField::CAknFepVkbCompositionField(TInt aMaxLength,

                                                      TRect aRect,

                                                      CFepUiLayout* aUiLayout,

                                                      TInt aControlId,

                                                      MAknFepVkbDataProvider* aDataProvider)

: CFepLayoutEditAreaBase(aRect,aUiLayout,aControlId)

    {

    //iMaxLength <=0 means no max length limited

    iMaxLength = aMaxLength;

    iCurrentPos = 0;

    iFirstSegment = NULL;

    iDataProvider = aDataProvider;

    iIsValidSpells = EFalse;

    }

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

// 2nd Constructor

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

//

void CAknFepVkbCompositionField::ConstructL()

    {

    //No cursor in construction

    BaseConstructL();

    //iBufferForCommit = HBufC::NewL(KDefaultLen);

    CPinyinAnalyserDbFeed* pZhuyinDb = CPinyinAnalyserDbFeed::NewL( EPinyinAnalyserTypeZhuyin );

    CleanupStack::PushL( pZhuyinDb );

    iZhuyinAnalyser = CAknFepVkbPinyinAnalyser::NewL( pZhuyinDb );

    CleanupStack::Pop( pZhuyinDb );

    CPinyinAnalyserDbFeed* pPinyinDb = CPinyinAnalyserDbFeed::NewL( EPinyinAnalyserTypePinyin );

    CleanupStack::PushL( pPinyinDb );

    iPinyinAnalyser = CAknFepVkbPinyinAnalyser::NewL( pPinyinDb );

    CleanupStack::Pop( pPinyinDb );

    }

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

// Destructor

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

//

CAknFepVkbCompositionField::~CAknFepVkbCompositionField()

    {

    iElements.ResetAndDestroy();

    iElements.Close();

    //delete iBufferForCommit;

    delete iFirstSegment;

    delete iZhuyinAnalyser;

    delete iPinyinAnalyser;

    }

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

// Handle events in

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

//

void CAknFepVkbCompositionField::HandleControlEvent(TInt aEventType, 

                                                             CFepUiBaseCtrl* /*aCtrl*/, 

                                                             const TDesC& aEventData)

    {

    TBuf<4> buf;    

    switch (aEventType)

        {

        case EEventVirtualKeyUp:

            {

            TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();

            buf.Append(TChar(event->iScanCode));	

            //assume keys are insertable

            TRAP_IGNORE(HandleInsertL(buf));

            break;

            }

        case EVkbEventKeySpace:

            {

            TInt imLayout = iDataProvider->RequestData(EAknFepDataTypeIMLayout);

            if (imLayout == EAknFepVkbImCnCangjie)

                {

                if(!IsValidSpell())

                    {

                    break;

                    }

                RBuf firstCandidate(static_cast<CAknFepVkbDataMgr*>(iDataProvider)->Candidates()[0]); 

                firstCandidate.AppendNum( 0 );

                TRAP_IGNORE(HandleConvertedResultL(firstCandidate));

                }

            else

                {

                TKeyEvent* event = (TKeyEvent*) aEventData.Ptr();

                buf.Append(TChar(event->iCode));	

                //assume keys are insertable

                TRAP_IGNORE(HandleInsertL(buf));

                }

            break;

            }        

        case EVkbEventKeyEnter:

            TRAP_IGNORE(HandleFlushL());        

            break;

        case EPeninputLayoutEventBack:

            TRAP_IGNORE(HandleBackL());

            break;

		case EVkbEventLeftArrow:

			{

		    TCursorSelection currentCursorSelection;

		    currentCursorSelection = Selection();

		    if (ETrue)

		        {

	            if (currentCursorSelection.iCursorPos == 0)

	                {

	                currentCursorSelection.iCursorPos = TextLength();

	                }

	            else 

	                {

	                currentCursorSelection.iCursorPos--;

	                if(currentCursorSelection.iCursorPos > 0 &&

						iElements[currentCursorSelection.iCursorPos - 1]->IsAutoSeparator())

	                    {

	                    currentCursorSelection.iCursorPos--;		                

		                }

	                }

		        }

		    TCursorSelection movedCursor(currentCursorSelection.iCursorPos, 

                                     currentCursorSelection.iCursorPos);

		    UpdateCursorSelection(movedCursor);

		    break;

			}

		case EVkbEventRightArrow:

			{

			TCursorSelection currentCursorSelection;

			currentCursorSelection = Selection();

		    if (currentCursorSelection.iCursorPos == TextLength())

		        {

		        currentCursorSelection.iCursorPos = 0;

		        }

		    else 

		        {

		        currentCursorSelection.iCursorPos++;

				if(currentCursorSelection.iCursorPos < TextLength() &&

					iElements[currentCursorSelection.iCursorPos - 1]->IsAutoSeparator())

                  {

                  currentCursorSelection.iCursorPos++;

                  }

		        }	        

			TCursorSelection movedCursor(currentCursorSelection.iCursorPos, 

                                   currentCursorSelection.iCursorPos);

			UpdateCursorSelection(movedCursor);

			break;

			}

        case EEventControlFocusLost:

            SetFocus(EFalse);

            break;

        case EEventControlFocusGained:

            SetFocus();

            break;

        case EVkbEventCompFieldAnalysisResponse:

            TRAP_IGNORE(HandleAnalysisResponseL(aEventData));

            break;

        case EVkbEventCandidateSelected:

            TRAP_IGNORE(HandleConvertedResultL(aEventData));

            break;

        case EVkbEventWindowClose:

        case EVkbEventClearContent:

            TRAP_IGNORE(ClearTextL());

            break;

        default:

            break;

        }

    }

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

// Count of elements

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

//

TInt CAknFepVkbCompositionField::Length() const

    {

    return iElements.Count();

    }

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

// Set warning color

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

//

void CAknFepVkbCompositionField::SetWarningColor(const TRgb& aColor) 

    {

    iWarningColor = aColor;

    }

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

// Set normal color

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

//

void CAknFepVkbCompositionField::SetNormalColor(const TRgb& aColor) 

    {

    iNormalColor = aColor;

    }    

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

// Insert a key

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

//

void CAknFepVkbCompositionField::HandleInsertL(const TDesC& aKey)

    {

    CCompositionElement *element = CCompositionElement::NewLC(aKey);

    iCurrentPos = DisplayPosToInternaPos( iSelectedCompositionText.iCursorPos );              

    TBool updateText = EFalse;  

    //remove selection first

    if( iSelectedCompositionText.Length() > 0)

        {

        RemoveSelection();

        updateText = ETrue;

        }