/*

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

*

*/

// System includes

#include <aknedsts.h> 

#include <AknUtils.h> 

#include <aknappui.h> 

#include <eikccpu.h> 

#include <eikdialg.h> 

#include <eikcapc.h> // CEikCaptionedControl

#include <aknQueryControl.h> 

#include <centralrepository.h> 

#include <StringLoader.h> 

#include <AknFepPluginManager.h>

#include <aknfeppeninputimeplugin.h>

#include <UikonInternalPSKeys.h> // KUikGlobalNotesAllowed

#include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

#include <hlplch.h>

#include <AknFep.rsg>

#include <avkon.rsg>

#include <AknIndicatorContainer.h>  //CAknIndicatorContainer

#include <StringLoader.h>

#include <peninputgenericitutcustomization.h>

#include <eikgted.h> 

#include <txtglobl.h>

#include <eikedwin.h> 

#include <featmgr.h>                 //FeatureManager

#include <aknextendedinputcapabilities.h>

#include <avkon.hrh>

#include <PtiEngine.h>

#include <peninputcommonlayoutglobalenum.h>

#include <PtiCompositionDataIF.h> // MPtiEngineCompositionDataInterface

#include <eikapp.h>

#include <AknFepGlobalEnums.h>

#include <AknFepInternalCRKeys.h>

// User includes

#include "AknFepManagerInterface.h" // MAknFepManagerInterface

#include "AknFepUiManagerBase.h"

#include "aknfepuimanagerfingeritutchinese.h"

// For Spell

#include "aknfepuispellcontainer.h"            

#include "aknfepuispellinputpane.h"

#include <eikgted.h> 

#include <apgwgnam.h>

#include <PtiKeyMappings.h>

// Constants

const TInt KCursorBlinkPerioid = 10000;//300000; // five tenth of a second * 2

const TInt KMaxServerDataLength = 50;

const TUint KVkbParagraphSeparator = 0x2029;

const TUint KVkbTabulator = 0x0009;

const TUid KAknfepUID= { 0x100056de }; 

const TUid KUidtruiApp = { 0x2000B104 }; 

const TInt KAknScreenServerUid = 0x100056cf;

const TInt KAknCapServerUid = 0x10207218;

const TInt KAknNotifySrvUid = 0x10281EF2;

const TInt KAknHelpAppUid = 0x10005234;

const TInt KInvalidValue = -1;

// Paste event for AknCcpuSupport

const TKeyEvent KAknCcpuPasteEvent = {EKeyF18, EEikCmdEditPaste, EModifierCtrl, 1}; 

const TUint KSupportedDeadKeys[] = { 0x005E, 0x0060, 0x00A8, 0x007E, 0x00AF, 

		                             0x00B4, 0x00B8, 0x02C7, 0x02DB, 0x02DD, 

		                             0x00A8, 0x0384, 0x0385 }; 

_LIT(KVkbTabChar, " ");

_LIT(KHWR_HLP_MAIN_VIEW, "HWR_HLP_MAIN_VIEW");

_LIT(KVQWERTY_HLP_MAIN_VIEW, "VQWERTY_HLP_MAIN_VIEW"); 

_LIT(KVITU_HLP_MAIN_VIEW, "VITU_HLP_MAIN_VIEW");

const TInt KDefaultCandidateArraySize = 16;

const TInt KNumberOfCases = 6;

#define iAvkonAppUi ((CAknAppUi*)CEikonEnv::Static()->EikAppUi())

TUid AppUidFromWndGroupIdL(TInt aWndGrpId)

    {

    RWsSession &ws = CCoeEnv::Static()->WsSession();

    //TInt wgId =ws.GetFocusWindowGroup();

    CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(ws,aWndGrpId);

    TUid id = wg->AppUid();

    CleanupStack::PopAndDestroy(wg);    	

    return id;

    }

TUid GetFocusAppUid()

    { 

    TUid id = {0x0};

    TRAP_IGNORE(id = AppUidFromWndGroupIdL(CCoeEnv::Static()->WsSession().GetFocusWindowGroup()));

    return id;

    }

TUid GetCurAppUid()

    {

    TUid id = {0x0};	

    TRAP_IGNORE(id = AppUidFromWndGroupIdL(CCoeEnv::Static()->RootWin().Identifier())); 

    return id;           

    }

TBool IsGlobalNotesApp(TUid& aUid)		  

    {

    const TInt KAknCapServerUid = 0x10207218;

    const TInt KAknNotifySrvUid = 0x10281EF2;      

    if(aUid.iUid == KAknCapServerUid || aUid.iUid == KAknNotifySrvUid)

        return ETrue;

    return EFalse;

    }

#ifdef RD_SCALABLE_UI_V2

inline TBool IsAbleTouseCallBubble()

    {

    const TInt KAknCapServerUid = 0x10207218;    

    return GetCurAppUid().iUid != KAknCapServerUid;

    }

#endif //RD_SCALABLE_UI_V2

RDrawableWindow* GetFocusWindow()

    {

    CCoeControl* focusControl = CCoeEnv::Static()->AppUi()->TopFocusedControl();

    if( focusControl )

        {

        return focusControl->DrawableWindow();

        }

    return NULL;

    }

// ======== MEMBER FUNCTIONS ========

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

// CAknFepPluginManager::NewL

// (other items were commented in a header)

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

//    

CAknFepPluginManager* CAknFepPluginManager::NewL( CAknFepManager& aFepMan,

                                                CAknFepSharedDataInterface& aSharedData,

                                                CAknFepLanguageManager& aLangMan,

                                                CAknFepCaseManager& aCaseMan )

    { 

    CAknFepPluginManager* self = new (ELeave) CAknFepPluginManager

        ( aFepMan, aSharedData, aLangMan, aCaseMan ); 

    CleanupStack::PushL( self );

    self->ConstructL();       

    CleanupStack::Pop(self);

    return self;

    }

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

// CAknFepPluginManager::~CAknFepPluginManager

// (other items were commented in a header)

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

//     

CAknFepPluginManager::~CAknFepPluginManager()

    {  

    delete iAdjustDataQueryTimer;

    iCurrentPluginInputFepUI = NULL; // why not delete????

    delete iPenInputMenu;

    if( iPenInputSvrConnected )

        {

        iPenInputServer.Close();

        iPenInputSvrConnected = EFalse;

        }

    delete iFingerItutChineseUI;

    delete iIcfDataBuf;

    iIcfDataBuf = NULL;

    delete iSpellText;

    iSpellText = NULL;

    delete iSpell;

    iSpell = NULL;

    delete iLastEditorContentBuf;

    delete iAvkonRepository;

    /*    

    for(TInt i = 0; i < iCandidateList.Count(); i++)

        {

        HBufC* buf = iCandidateList[i];

        delete buf;

        }

    iCandidateList.Close();

    */

    iCandidateList.ResetAndDestroy();

    iSendAllList.iCandidates.Reset();

    iOpenWindowList.Close();

    iEventData.Close();    

    iPreCaption.Close();

    }

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

// CAknFepPluginManager::CAknFepPluginManager

// (other items were commented in a header)

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

// 

CAknFepPluginManager::CAknFepPluginManager( CAknFepManager& aFepMan, 

                                          CAknFepSharedDataInterface& aSharedData,

                                          CAknFepLanguageManager& aLangMan,

                                          CAknFepCaseManager& aCaseMan )

    : iFepMan( aFepMan ), iLangMan( aLangMan ), iCaseMan( aCaseMan ),

      iSharedData( aSharedData ), iPluginPrimaryRange( ERangeInvalid ), iCandidateIndex(1),

      iCharStartPostion( KInvalidValue )

    {

    iIndicatorImgID = 0;

    iIndicatorTextID = 0;

    iLastDataQueryWin = NULL;

    iDefaultOrientation = -1;

    iIsInEditWordQueryDlg = EFalse;    

    iClosePluginInputMode = EFalse;

    iDimGainForeground = ETrue;

	// Modify for bug ELZG-7WZC35 begin

    iAlignment = 0;

    // Modify for bug ELZG-7WZC35 end

    }

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

// CAknFepPluginManager::ConstructL

// (other items were commented in a header)

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

// 

void CAknFepPluginManager::ConstructL()

    {

    iPenInputMenu = CAknFepPluginMenuManager::NewL(&iFepMan);

    //here ERangeInvalid means there is no change of plugin input range.

    iFepMan.UiInterface()->TouchPaneSetFepPenSupportInterface(this);

    iEventData.CreateMaxL(KMaxServerDataLength);

    RThread client;

    iHasSWEventCap = client.HasCapability(ECapabilitySwEvent);

    client.Close();

    iAvkonRepository = CRepository::NewL( KCRUidAvkon ); 

    }

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

// CAknFepPluginManager::ActivatePenInputL

// Change to default plugin input mode

// (other items were commented in a header).

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

//

void CAknFepPluginManager::ActivatePenInputL()

    {

    if( !iPenInputSvrConnected || !iPenInputServer.IsVisible() || iPenInputServer.IsDimmed() )

        {

        if( iFepMan.FepAwareTextEditor() )

            {

            TryChangePluginInputModeByModeL((TPluginInputMode)(iSharedData.PluginInputMode()),

                                            EPenInputOpenManually,

                                            ERangeInvalid);

            }

        }    

    iFepMan.PtiEngine()->CancelTimerActivity();    

    }

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

// CAknFepPluginManager::DeactivatePenInputL

// (other items were commented in a header)

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

// 

void CAknFepPluginManager::DeactivatePenInputL()

    {

    ClosePluginInputModeL(ETrue);

    }

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

// CAknFepPluginManager::HandleServerEventL

// Handle pen input server events.

// (other items were commented in a header).

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

//

TBool CAknFepPluginManager::HandleServerEventL(TInt aEventId)

    {

    if(ESignalServerExit == aEventId)

        {

        iPenInputSvrConnected = EFalse; 

        return ETrue;

        }

    if(ESignalServerReady == aEventId)

        {

        //reconnect to server

        iFepMan.SendEventsToPluginManL(EPluginEditorActivate);

        return ETrue;

        }

    TBool bHandled = EFalse;

    if( !iLangMan.CurrentImePlugin())

        {

        return bHandled;

        }

    iEventData.Zero();

    TPtrC pBuf; 

    TInt dataLen = iPenInputServer.GetServerEventData(iEventData);

    if( KErrNone == dataLen )

        {

        pBuf.Set(iEventData);

        }

    else if ( dataLen > 0 )

        {

        iEventData.ReAllocL(dataLen);

        dataLen = iPenInputServer.GetServerEventData(iEventData);

        pBuf.Set(iEventData);

        }

    if( dataLen != KErrNone )

	    {

	    return ETrue;

	    }

    if( !iLangMan.CurrentImePlugin()->HandleServerEventL(aEventId, iEventData) )

        {

        bHandled = ETrue;

        //only handle events which IME plug-in don't handled

        switch( aEventId )

            {

            case ESignalReplacePartText:

            case ESignalReplaceText://Get key event

            case ESignalReplaceTextJp:

                {

                TInt repeatCount = 0;

                TInt len = *(TInt*)pBuf.Ptr();

                TInt stringLength = pBuf.Length();

                TInt midLength = sizeof(TInt)/sizeof(TText);

                if (midLength > stringLength)

                    {

                    break;   

                    }

                iFepMan.SetFlag( CAknFepManager::EFlagSupressAutoUpdate );

                TPtrC s = pBuf.Mid(midLength);//sizeof(TInt)/sizeof(TText)

                //set selection

                MCoeFepAwareTextEditor* edit = iFepMan.FepAwareTextEditor();

                if( iFepMan.IsFepAwareTextEditor() && edit )

                    {

                    TCursorSelection curSor;

                    edit->GetCursorSelectionForFep(curSor);

                    if ( curSor.iAnchorPos == curSor.iCursorPos )

                        {

                        if (ESignalReplaceTextJp == aEventId)

                            {

                            if (curSor.iCursorPos  >= len)

                                {

                                curSor.iAnchorPos = curSor.iCursorPos - len;

                                if (curSor.iAnchorPos<0 || 

                                    curSor.iAnchorPos>edit->DocumentLengthForFep())

                                    {

                                    break;

                                    }

                                }

                            }

                        else

                            {

                            if(ESignalReplacePartText == aEventId)

                                {

                                curSor.iAnchorPos = curSor.iCursorPos - len;

                                }

                            else

                                {

                                if ( iCharStartPostion == KInvalidValue )    

                                    {

                                    curSor.iAnchorPos = curSor.iCursorPos -  

                                        ( iLastSubmitCount<len?iLastSubmitCount:len );

                                    }

                                else

                                    {

                                    curSor.iAnchorPos = iCharStartPostion;  

                                    iLastSubmitCount = curSor.iCursorPos - iCharStartPostion;

                                    //Fixed bug ID SAHN-7JDDC8

                                    }

                                }

                            if (curSor.iAnchorPos<0 || 

                                curSor.iAnchorPos>edit->DocumentLengthForFep())

                                {

                                break;

                                }

                            // check repeated string 

                            if (len >= iLastSubmitCount)

                                {

                                TBuf<CAknFepManager::EMaximumFepWordLength> textToUncommit;

                                textToUncommit.Zero();    

                                 edit->GetEditorContentForFep(textToUncommit, curSor.iAnchorPos, 

                                                           Min(curSor.Length(), 

                                                           CAknFepManager::EMaximumFepWordLength));

                                repeatCount = RepeatStringFromLeft(s,textToUncommit);    

                                curSor.iAnchorPos += repeatCount;

                                if (curSor.iAnchorPos<0 || 

                                    curSor.iAnchorPos>edit->DocumentLengthForFep())

                                    {

                                    break;

                                    }

                                }

                            if (curSor.iCursorPos > curSor.iAnchorPos)

                                {

                                edit->SetCursorSelectionForFepL(curSor);    

                                }

                            }

                        }

                    }

                else

                    {

                    TBuf<1> backSpace;

                    backSpace.Append(TChar(EKeyBackspace));

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

                        {

                        SubmitUiPluginTextL(backSpace, EKeyEvent);

                        }

                    }

                iFepMan.ClearFlag( CAknFepManager::EFlagSupressAutoUpdate );

                if (repeatCount > 0)

                    {

                    OnPenInputServerKeyEventL(s.Right(s.Length() - repeatCount));

                    iLastSubmitCount += repeatCount;   

                    }

                else

                    {

                    OnPenInputServerKeyEventL(s);    

                    }

                }

                break;

            case ESignalKeyEvent:

                {

                TPtr ptr( const_cast<TUint16*>(pBuf.Ptr()), pBuf.Length(), pBuf.Length() );

                if(iFepMan.InputMode() == ELatin && (iPluginInputMode == EPluginInputModeVkb || 

                   iPluginInputMode == EPluginInputModeFSQ))

                    {

                    AdjustDataCase( ptr );

                    }

                OnPenInputServerKeyEventL(pBuf);

              	}

              	break;

            case ESignalNotifyUpdateCba://Update CBA

                {

                TInt* cbaData = (TInt* )(pBuf.Ptr());

                iFepMan.UpdateCbaL(*cbaData);

                }

                break;                    

            case ESignalHwNotifySctPopup:

                iFepMan.LaunchSpecialCharacterTableL( 0,ETrue );//possible?

                break;                      

            case ESignalSetAppEditorCursor:

                {

                TInt8 *ptrData = (TInt8* )(pBuf.Ptr());

                TCursorSelection curSel = *(TCursorSelection* )(ptrData);

                TBool sync = *(TBool *)(ptrData + sizeof(TCursorSelection));

                if ( iFepMan.UncommittedText().Length() > 0 )

                    {

                    iFepMan.PtiEngine()->CancelTimerActivity(); 

                    //using TryCloseUiL() to sync Fep state

                    //iFepMan.CommitInlineEditL();

                    iFepMan.TryCloseUiL();

                    }

                //now change the cursor position

                SetCursorSelectionL(curSel, sync);

                }

                break;

            case ESignalLaunchLanguageMenu:

                LaunchPenInputLanguageSelectionL(ETrue);

                break;                                       

            case ESignalLaunchOptionMenu:

            case ESignalLaunchOptionsMenu:

                {

                if (iInMenu || (!iPenInputMenu) || iPenInputMenu->IsShowing())

                    {

                    break;    

                    }

                iLaunchMenu = ETrue;

                if (PluginInputMode() == EPluginInputModeItut ||

                    PluginInputMode() == EPluginInputModeFSQ ||

                    PluginInputMode() == EPluginInputModeFingerHwr)

                    {

                    SetMenuState();

                    }                

                else

                    {

                    ClosePluginInputUiL(ETrue);

                    }           

                LaunchPenInputMenuL(R_AVKON_PENINPUT_OPTION_MENU_BAR);

                }