/*

* Copyright (c) 2005-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 peninput client

*

*/

#include "peninputclientserver.h"

#include "peninputclientimpl.h"

#include "peninputcmd.h"

#include "peninputsrvobserver.h"

#include <apgtask.h>

#include <w32std.h>

#include <apacmdln.h>

#include <apgcli.h>

#include <s32mem.h>

#include <coemain.h>

#include <apgwgnam.h>

#include "peninputclient.h"

#ifndef FIX_FOR_NGA

#define FIX_FOR_NGA

#endif

const TUint KDefaultMessageSlots = 4;

const TInt KMaxSupportLanguages = 100;

const TInt KMaxImeImplementations = 10;

const TUid KSingletonClientId = 

    {

    0x10281854

    };

TUid GetAppUidByWndGroupIdL( RWsSession &aWs, TInt aWndGroupId )

    {

    CApaWindowGroupName* wg = CApaWindowGroupName::NewLC(aWs,aWndGroupId);

    TUid id = wg->AppUid();

    CleanupStack::PopAndDestroy(wg);    	

    return id;

    }

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 AppUidFromWndGroupId(TInt aWndGrpId)

    {

    TUid id = {0x00000000};

    TRAP_IGNORE(id = AppUidFromWndGroupIdL(aWndGrpId));

    return id;

    }

inline TUid GetFocusAppUid()

    { 

    return  AppUidFromWndGroupId(CCoeEnv::Static()->WsSession().GetFocusWindowGroup());

    }

TUid GetCurAppUid()

    {

    return  AppUidFromWndGroupId(CCoeEnv::Static()->RootWin().Identifier());

    }

CPeninputServerWaiter* CPeninputServerWaiter::NewL()

    {

    CPeninputServerWaiter* self = new(ELeave)CPeninputServerWaiter;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CPeninputServerWaiter::ConstructL()    

    {

    iWaitScheduler = new(ELeave) CActiveSchedulerWait;

    }

CPeninputServerWaiter::~CPeninputServerWaiter()

    {

    delete iWaitScheduler;

    }

void CPeninputServerWaiter::Start()

    {

    iWaitScheduler->Start();

    }

void CPeninputServerWaiter::Stop(TInt aFlag)

    {

    //if(aFlag)

    iError = aFlag ? KErrNone : aFlag;

    iWaitScheduler->AsyncStop();

    }

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

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

// RPeninputServerImpl::NewL

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

//

RPeninputServerImpl* RPeninputServerImpl::NewL(TRequestStatus* aStatus)                                  

    {

    //check for singleton existence    

    CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId);

    CPenInputSingletonClient* client = 

                                static_cast<CPenInputSingletonClient*>(obj);

    if(client && client->IsValid())

        {

        RPeninputServerImpl* server = client->GetSingletonServer();

        TInt err = server->ServerReady() ? KErrNone : KErrLaunchingServer;

        if ( aStatus )

            {

            User::RequestComplete( aStatus, err );

            }

        return server;

        }

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

    CleanupStack::PushL(self);

    self->ConstructL(KSingletonClientId,aStatus);

    CleanupStack::Pop(self);

    return self;

    }

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

// RPeninputServerImpl::RPeninputServerImpl

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

//

RPeninputServerImpl::RPeninputServerImpl() : iPosition(0,0),iSize(0,0)

    {

    iObserver = 0;

    iIsForegroundSession = EFalse;

    iServerExit = EFalse;

    iLaunchServer = EFalse;

    iCurPenUiType = -1; 

    iWaitScheduler = NULL; 

    iAppPrefferedUiMode = EPluginInputModeNone;

    iAutoOpenFlag = ETrue;

    iBackgroundCtrl = 0;

    iResourceChange = EFalse;  

    iWaiterAo = NULL;

    iPendingRequest = NULL;

    iServerReady = EFalse;

    }

void RPeninputServerImpl::ConstructL(const TUid& aUid, TRequestStatus* aStatus)

    {

    CCoeStatic * obj = CCoeEnv::Static()->FindStatic(aUid);

    CPenInputSingletonClient* client;

    //__ASSERT_ALWAYS(obj == NULL, User::Leave(KErrAlreadyExists));

    if(obj)

        {

        client = static_cast<CPenInputSingletonClient*>(obj);

        client->ReplaceServer(this);                                

        }

    else

        client = new (ELeave)CPenInputSingletonClient(aUid,this);       

    //Note: The client is destroyed by the control environment automatically    

    //User::LeaveIfError(DoConnectL());

    TRAPD(err, DoConnectL(aStatus));

    if(KErrNone != err)

        {

        client->SetInvalid();

        User::LeaveIfError(err);

        }

    }

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

// RPeninputServerImpl::DoConnectL

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

//

/*TInt RPeninputServerImpl::Connect()

    {

    //do nothing

    return KErrNone;

    }

  */  

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

// RPeninputServerImpl::Close

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

//

void RPeninputServerImpl::Close()

    {

    CCoeStatic * obj = CCoeEnv::Static()->FindStatic(KSingletonClientId);

    CPenInputSingletonClient* client = 

                                static_cast<CPenInputSingletonClient*>(obj);               

    if(client)

        {

        TInt ref = client->DecreaseRef();

        if (ref <= 0)

            {

            // delete the CCoeStatic object of CPenInputSingletonClient when 

            // Peninput server was closed.

            // Basiccaly, all CCoeStatic objects are deleted in CCoeEnv destructor.

            // However, it is necessary to delete the CCoeStatic object when 

            // changing from avkon fep to other fep.

            delete client;

            }

        }

    }

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

// RPeninputServerImpl::DoConnectL

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

//

TInt RPeninputServerImpl::DoConnectL(TRequestStatus* aStatus)

    { 

    iPendingRequest = aStatus;

    TInt error = KErrNone;

    /*************** Note ************************************************/

    // Multi-thread case is not considered here!

    /*************** Note ************************************************/        

     // try to connect to the server

    error = CreateSession( KPeninputServerName,

                           Version(),

                           KDefaultMessageSlots,EIpcSession_Sharable);

    if( error == KErrNotFound || error == KErrServerTerminated )

        {

        // server does not yet exist or it has terminated

        // try to create the server

        if(!aStatus) //sync call

            {

            error = StartThreadL();

            if(KErrNone == error)

                {

                error = CreateSession( KPeninputServerName,

                                           Version(),

                                           KDefaultMessageSlots,EIpcSession_Sharable);

                AddObserver();

                }

            }

        else

            {

            StartThreadAsyncL();  

            return KErrNone;

            }

        }

    else if ( error == KErrNone )//server alreay there

        {

        iServerReady = ETrue;

        AddObserver();	

        if(aStatus)

        	User::RequestComplete(iPendingRequest, error);

        }

    return error;

    }

void RPeninputServerImpl::AddObserver()

    {

    TThreadId srvThreadId;

	TIpcArgs arg;        

	TPckg<TThreadId> msg(srvThreadId);

	arg.Set(KMsgSlot0,&msg);    

	SendReceive(EPeninputRequestServerThreadId,arg);

    iServerExit = EFalse;

    if(iObserver)

        {

        TRAP_IGNORE(iObserver->ReConstructL(srvThreadId));

        }

    else

        {

        TRAP_IGNORE(iObserver = CPeninputServerObserver::NewL(this,srvThreadId));

        }

    }

TBool RPeninputServerImpl::ServerReady() 

	{ 

	return iServerReady;

	}

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

// RPeninputServerImpl::Version

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

//

TVersion RPeninputServerImpl::Version(void) const

    {

    return( TVersion( KPeninputServerMajorVersionNumber,

                      KPeninputServerMinorVersionNumber,

                      KPeninputServerBuildVersionNumber ) );

    }

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

// RPeninputServerImpl::RequestMessageNotification

// Register to require message notification

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

//

void RPeninputServerImpl::RequestMessageNotification( TRequestStatus& aStatus )

    {

    TInt data=0;

    SendReceive( EPeninputServerRequestMessageNotification, TIpcArgs(data), aStatus ); 

    }

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

// RPeninputServerImpl::CancelMessageNotification

// Cancel message notification

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

//

void RPeninputServerImpl::CancelMessageNotification()

    {

    SendReceive( EPeninputServerCancelMessageNotification);   

    }

void RPeninputServerImpl::DimUiLayout(TBool aFlag)

    {

    TRAP_IGNORE(DimUiLayoutL(aFlag));

    }

void RPeninputServerImpl::DimUiLayoutL(TBool aFlag)

    {

    TInt priority = iPriority;

    TPckgC<TBool> msg(aFlag);

    TIpcArgs arg;    

    arg.Set(KMsgSlot0,&msg);

    TPckgC<TInt> prioriryMsg(priority);//p

    arg.Set(KMsgSlot1,&prioriryMsg);

    TInt bmpHandle = -1;

    TPckg<TInt> handleMsg(bmpHandle);

    arg.Set(KMsgSlot2,&handleMsg);

    TRect extend;

    TPckg<TRect> posMsg(extend);  

    arg.Set(KMsgSlot3,&posMsg);

    if (iInternalPopup)

        {

        SendReceive(EPeninputRequestInternalDimLayout,arg);    

        }

    else

        {

        SendReceive(EPeninputRequestDimLayout,arg);    

        }

    if(aFlag)

        {

        //show the background control

        if(!iBackgroundCtrl)

            {

            iBackgroundCtrl = CPenUiBackgroundWnd::NewL(CCoeEnv::Static()->RootWin(),bmpHandle);

            }

        if(iBackgroundCtrl)

            iBackgroundCtrl->Show(extend, iGlobalNotes, 

                iInternalPopup,priority, iResourceChange);    

        }

    else //undim the window

        {

        if(iBackgroundCtrl)

#ifdef FIX_FOR_NGA

            {

            delete iBackgroundCtrl;

            iBackgroundCtrl = 0;

            }

#else            

            {

            iBackgroundCtrl->Hide();

            }

#endif   

        }

    }

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

// RPeninputServerImpl::ActivateLayout

// Activate/Deactivate a ui layout

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

//

void RPeninputServerImpl::ActivateLayout(TBool aFlag)

    {

    if(iBackgroundCtrl && iBackgroundCtrl->IsVisible())

        iBackgroundCtrl->Hide();    

    //inform UI activation handler

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

        {

        if(iPenUiNotificationHandler[i].iType & iCurPenUiType)

            {

            if(aFlag)

                iPenUiNotificationHandler[i].iHandler->OnPeninputUiActivated();

            else

                iPenUiNotificationHandler[i].iHandler->OnPeninputUiDeactivated();

            }

        }

    if ( aFlag || ( !aFlag && IsVisible() ) )        

        {

        TPckgC<TBool> msg(aFlag);

        TIpcArgs arg;    

        arg.Set(KMsgSlot0,&msg);     

        TInt scrMode = CCoeEnv::Static()->ScreenDevice()->CurrentScreenMode();

        TPckgC<TInt> scrMsg(scrMode);         

        arg.Set(KMsgSlot1,&scrMsg);

        SendReceive(EPeninputRequestActivateLayout,arg);

        }           

    }

void RPeninputServerImpl::ActivatePeninputInNotesL()

    {

    SendReceive(EPeninputRequestActivateLayoutInGlobalNotes);    

    }

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

// RPeninputServerImpl::GetServerEventData

// Retrieve server event data

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

//

TInt RPeninputServerImpl::GetServerEventData(TDes& aBuf)

    {

    if(iServerExit)  // ???

      return -1;

    TIpcArgs arg;

    aBuf.Zero();    

    arg.Set(KMsgSlot0,aBuf.MaxLength());

    arg.Set(KMsgSlot1,&aBuf);

    return SendReceive(EPeninputRequestGetServerEventData,arg);

    }

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

// RPeninputServerImpl::ServerEventDfataNum

// Get the number of server event

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

//

TInt RPeninputServerImpl::ServerEventDataNum()

    {  

    TInt num = -1;

    TPckg<TInt> msg(num);

    TIpcArgs arg;

    arg.Set(KMsgSlot0,&msg);

    TInt err = SendReceive(EPeninputRequestGetServerEventDataNumber,arg);

    if(err != KErrNone)

        num = err;//set the error code

    return num;

    }

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

// RPeninputServerImpl::ResourceChanged

// Tell server the client resource changed

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

//

void RPeninputServerImpl::ResourceChanged(TInt aType)

    {

    TIpcArgs arg;    

    TPckgC<TInt> msg(aType);

    arg.Set(KMsgSlot0,&msg);

    SendReceive(EPeninputRequestResourceChanged,arg);

    }

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

// RPeninputServerImpl::SetUiLayoutPos

// Set ui layout position

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

//

TInt RPeninputServerImpl::SetUiLayoutPos(const TPoint& aPos)

    {

    TPckgC<TPoint> msg(aPos);

    TIpcArgs arg;    

    arg.Set(KMsgSlot0,&msg);

    return SendReceive(EPeninputRequestUiSetUiPos,arg);

    }

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

// RPeninputServerImpl::UiLayoutPos

// get ui layout position

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

//

void RPeninputServerImpl::GetUiLayoutPosAndSize()

    {

    TPckg<TPoint> msgPos(iPosition);

    TPckg<TSize> msgSize(iSize);

    TIpcArgs arg;

    arg.Set(KMsgSlot0,&msgPos);

    arg.Set(KMsgSlot1,&msgSize);

    SendReceive(EPeninputRequestUiGetUiPos,arg);

    }

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

// RPeninputServer::UiLayoutPos

// get ui layout position

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

//

TPoint RPeninputServerImpl::UiLayoutPos()

    {

    GetUiLayoutPosAndSize();

    return iPosition;    

    }

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

// RPeninputServer::UiLayoutSize

// get ui layout size

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

//

TSize RPeninputServerImpl::UiLayoutSize()