// Copyright (c) 1994-2010 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:

// Client handling

// 

//

#include "CLIENT.H"

#include "ANIM.H"

#include "Direct.H"

#include "EVENT.H"

#include "KEYCLICK.H"

#include "server.h"

#include "gc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "wstop.h"

#include "panics.h"

#include "../CLIENT/w32comm.h"

#include "password.h"

#include "pointer.h"

#include <u32hal.h> // EHalGroupEmulator

#include "WsMemMgr.h"

GLREF_C void HeapDump();

GLREF_D CDebugLogBase *wsDebugLog;

GLREF_D TPtr nullDescriptor;

TWsCmdHeaderBase CWsClient::iCurrentCommand;

TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;

TUint CWsClient::iConnectionId=CDebugLogBase::EDummyConnectionId+1;

CArrayFixFlat<TWsCursorArrayItem> *CWsClient::iSystemPointerCursors=NULL;

TInt CWsClient::iDefaultSystemPointerCursorIndex=0;		//Negative when there isn't one

CWsPointerCursor *CWsClient::iDefaultSystemPointerCursor;

CWsClient *CWsClient::iSystemPointerCursorListOwner=NULL;

CArrayFixFlat<TWsCursorArrayItem> *CWsClient::iTextCursorArray=NULL;

TInt CWsClient::iReply;

TInt CWsClient::iReplyOffset;

CWsClient *CWsClient::iCurrentClient;

/**

Used for enforcing the redraw calling convention (in preparation for BR2412) in emulator builds.

When enabled this will panic any client calling a CWindowGc draw operation outside a 

RWindow::BeginRedraw() / RWindow::EndRedraw() pair (known as non-redraw drawing).

Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini 

where X is either 0 (zero) for "off" or 1 (one) for "on". 

Then enable globaly in WServ AutoFlush by defining __AUTO_FLUSH in ../client/client.h 

or locally by calling RWsSession::SetAutoFlush(ETrue) for a specific client programatically, 

or locally pressing Ctrl-Alt-Shift-F in the emulator.

*/

TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;

_LIT(KWSERVSessionPanicCategory,"WSERV");

TKeyArrayFix CursorKey(_FOFF(TWsCursorArrayItem,iIndex),ECmpTInt);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);

CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iIsInitialised(EFalse)

#if defined(__WINS__)

	,iRemoveKeyCode(ETrue)

#endif

	{

	iScreen=CWsTop::Screen();		//## Need to find better way to set this

	}

CWsClient::~CWsClient()

	{

	WindowServer().RemoveAllGraphicDrawers(*this); // deindexes all graphic drawers owned by this client

	delete iTempCustomTextCursor.iCursor;

	FreeSystemPointerCursorList();

	CWsTop::ClientDestroyed(this);

	if (wsDebugLog)

		{

		_LIT(ClientDestuct,"Client %d destructing");

		wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,ClientDestuct, iConnectionHandle);

		}

	iInternalFlags|=EClientIsClosing;

	delete iObjectIndex;

	delete iEventQueue;

	delete iRedrawQueue;

	delete iPriorityKeyEvent;

	CWsTop::SessionExited(this);

	iScreen->Update();	/*	Mathias: Don't care about multiple screens yet

	CWsTop::UpdateAllScreens(EFalse);

*/

	iClient.Close();

	}

void CWsClient::CompleteInitializationL()

	{

	iObjectIndex=new(ELeave) CWsObjectIx();

	iObjectIndex->ConstructL();

    iEventQueue=new(ELeave) CEventQueue(this);

	iEventQueue->ConstructL();

    iRedrawQueue=new(ELeave) CRedrawQueue(this);

	iRedrawQueue->ConstructL();

    iPriorityKeyEvent=new(ELeave) CPriorityKey(this);

	CWsCliObj::NewL(this);

	iComputeMode=RWsSession::EPriorityControlComputeOff;

	CWsTop::NewSession(this);

#ifdef __WINS__

	TBool halValue = EFalse;

	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, 

		(TAny*)"debug_wserv_exe_EnforceRedrawCallingConvention", &halValue) == KErrNone)

		{

		iDebug_EnforceRedrawCallingConvention = halValue;

		}

#endif

	iIsInitialised = ETrue;

	}

TBool CWsClient::DebugEnforceRedrawCallingConvention()

	{

	return iDebug_EnforceRedrawCallingConvention;

	}

void CWsClient::StartInitializationL(TUint aConnectionHandle)

	{

	if (wsDebugLog)

		wsDebugLog->NewClient(aConnectionHandle);

	if (iObjectIndex)

		{

		PPanic(EWservPanicReInitialise);

		}

	else

		{

		iConnectionHandle=aConnectionHandle;

		CompleteInitializationL();

		}

	}

void CWsClient::HandleToWindow(TInt handle,CWsWindowBase **pWin)

//

// Convert a handle to object checking it is of the correct type.

//

	{

	if ((*pWin=(CWsWindowBase *)HandleToObjUntyped(handle))==NULL ||

		((*pWin)->Type()!=WS_HANDLE_WINDOW && (*pWin)->Type()!=WS_HANDLE_GROUP_WINDOW))

		PPanic(EWservPanicWindow);

	}

void CWsClient::HandleToClientWindow(TInt handle,CWsClientWindow **pWin)

//

// Convert a handle to object checking it is of the correct type.

//

	{

	if ((*pWin=(CWsClientWindow *)HandleToObj(handle, WS_HANDLE_WINDOW))==NULL)

		PPanic(EWservPanicWindow);

	}

void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)

	{

	CWsPointerCursor *pc=new(ELeave) CWsPointerCursor(this);

	CleanupStack::PushL(pc);

	pc->ConstructL(aCmd);

	CleanupStack::Pop();

	}

// Create a new custom text cursor

void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)

	{

	if (!iTextCursorArray)

		{

		const TInt textCursorArrayGranularity = 4;

		iTextCursorArray = new(ELeave) CArrayFixFlat<TWsCursorArrayItem>(textCursorArrayGranularity);

		}

	TInt arrayIndex;

	if (FindCursorArrayItem(iTextCursorArray, aCmd.identifier, arrayIndex))

		User::Leave(KErrAlreadyExists);

	delete iTempCustomTextCursor.iCursor;

	iTempCustomTextCursor.iCursor = NULL;

	iTempCustomTextCursor.iCursor = new(ELeave) CWsCustomTextCursor(this, aCmd.alignment);

	static_cast<CWsCustomTextCursor*>(iTempCustomTextCursor.iCursor)->ConstructL(aCmd.flags);

	iTempCustomTextCursor.iIndex = aCmd.identifier;

	}

// Add new custom text cursor to global list

void CWsClient::CompleteSetCustomTextCursorL(TInt aError)

	{

	if (aError != KErrNone)

		{

		delete iTempCustomTextCursor.iCursor;

		iTempCustomTextCursor.iCursor = NULL;

		User::Leave(aError);

		}

	TWsCursorArrayItem entry = iTempCustomTextCursor;

	iTempCustomTextCursor.iCursor = NULL;

	CleanupStack::PushL(entry.iCursor);

	TInt arrayIndex;

	if (FindCursorArrayItem(iTextCursorArray, entry.iIndex, arrayIndex))

		{

		User::Leave(KErrAlreadyExists);

		}

	else

		{

		iTextCursorArray->InsertIsqL(entry, CursorKey);

		}

	CleanupStack::Pop(entry.iCursor);

	}

CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)

	{

	TInt arrayIndex;

	if (!FindCursorArrayItem(iTextCursorArray, aIdentifier, arrayIndex))

		{

		return NULL;

		}

	return TextCursor(arrayIndex);

	}

void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)

	{

	CWsSprite *sprite=new(ELeave) CWsSprite(this);

	CleanupStack::PushL(sprite);

	sprite->ConstructL(aCmd);

	CleanupStack::Pop();

	}

void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)

	{

	DWsBitmap *bitmap=new(ELeave) DWsBitmap(this);

	CleanupStack::PushL(bitmap);

	bitmap->ConstructL(aCmd);

	CleanupStack::Pop();

	}

/** Creates a new window.

@param aCmd The command received from the client

@internalComponent

@released

*/

void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)

	{

	CWsWindowBase *parent;

	HandleToWindow(aCmd.parent,&parent);

	CWsClientWindow *win=NULL;

	TBool deviceIsInvalid=EFalse;

	CScreen* screen = parent->Screen();

	if (parent->WinType()==EWinTypeGroup)

		{

		__ASSERT_DEBUG(!((CWsWindowGroup*)parent)->ScreenDeviceDeleted(),PPanic(EWservPanicGroupWinScreenDeviceDeleted));

		win=new(ELeave) CWsClientWindow(this, screen);

		deviceIsInvalid=!((CWsWindowGroup *)parent)->ScreenDeviceValid();

		}

	else

		{

		win=new(ELeave) CWsClientWindow(this, screen);

		}

	CleanupStack::PushL(win);

	win->ConstructL(aCmd,parent,deviceIsInvalid);

	CleanupStack::Pop(win);

	}

void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)

	{

	CWsWindowGroup::NewL(this, NULL, aCmd); //Screen is set inside the ConstructL since support for multiple screens was introduced

	}

void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)

	{

	CWsAnimDll *animDll=new(ELeave) CWsAnimDll(this);

	CleanupStack::PushL(animDll);

	animDll->LoadL(BufferTPtr((TText *)(aParams.LoadAnimDll+1),aParams.LoadAnimDll->length));

	CleanupStack::Pop();

	}	

void CWsClient::CreateNewScreenDeviceL( TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer)

	{

	DWsScreenDevice *screenDevice=new(ELeave) DWsScreenDevice( this, aDefaultScreenNumber,aClientScreenDevicePointer);

	CleanupStack::PushL(screenDevice);

	screenDevice->ConstructL();

	CleanupStack::Pop(screenDevice);

	if (iPrimaryScreenDevice==NULL)

		{

		iPrimaryScreenDevice=screenDevice;

		// When client create screen device, change default screen to the one specified.

		// Client should do this immediately after establishing session

		iScreen = iPrimaryScreenDevice->Screen();

		InitialiseScreenDevices();

		}

	}

void CWsClient::InitialiseScreenDevices()

	{

	const TWsObject* ptr=iObjectIndex->FirstObject();

	const TWsObject* end=ptr+iObjectIndex->Length();

	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

	while(++ptr<end)

		{

		if (ptr->iObject && ptr->iObject->Type()==WS_HANDLE_GROUP_WINDOW)

			{

			CWsWindowGroup *gw =STATIC_CAST(CWsWindowGroup*,ptr->iObject);

			if(gw->Device()==NULL)

				{

				gw->SetScreenDevice(iPrimaryScreenDevice);

				}

			}

		}

	}

void CWsClient::CreateNewClickL(const TUid& aUid)

	{

	CClick *click=new(ELeave) CClick(this);

	CleanupStack::PushL(click);

	click->ConstructL(aUid);

	CleanupStack::Pop(click);

	}

void CWsClient::RequestComplete(TRequestStatus * &aStatus, TInt aErr)

	{

	Client().RequestComplete(aStatus,aErr);

	}

void CWsClient::PanicCurrentClient(TClientPanic aPanic)

	{

	iCurrentClient->PPanic(aPanic);

	}

void CWsClient::PPanic(TClientPanic aPanic) const

//This function is allowed to leave with out the 'L' convention for special reasons

	{

	SessionPanic(aPanic);

	User::Leave(EPanicLeave);

	}

void CWsClient::SessionPanic(TClientPanic aReason) const

	{

	if (wsDebugLog)

		wsDebugLog->Panic(iConnectionHandle, aReason);

	if (!iInternalFlags&EPanicClientAsSoonAsPossible) // keep the first error code

		{

		iInternalFlags|=EPanicClientAsSoonAsPossible;

		iPanicReason=aReason;

		}

	}

void CWsClient::SessionTerminate()

	{

	if (wsDebugLog)

		wsDebugLog->Panic(iConnectionHandle, 0);

	const RThread thread=Client();

	RProcess process;

	if (thread.Process(process)==KErrNone)

		{

		process.Terminate(0);

		process.Close();

		}

	}

void CWsClient::ReplyBuf(const TDesC16 &aDes)

	{

	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)

		PanicCurrentClient(EWservPanicDescriptor);

	iReplyOffset+=aDes.Length();

	if (wsDebugLog)

		wsDebugLog->ReplyBuf(aDes);

	}

void CWsClient::ReplyBuf(const TDesC8 &aDes)

	{

	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)

		PanicCurrentClient(EWservPanicDescriptor);

	iReplyOffset+=aDes.Length();

	if (wsDebugLog)

		wsDebugLog->ReplyBuf(aDes);

	}

void CWsClient::ReplyBuf(const TAny *aSource, TInt aLength)

//

// Send a buffer to the client process.

//

	{

	TPtrC8 src(reinterpret_cast<const TUint8*>(aSource),aLength);

	ReplyBuf(src);

	}

void CWsClient::ReplySize(const TSize &aSize)

	{

	ReplyBuf(&aSize,sizeof(aSize));

	}

void CWsClient::ReplyPoint(const TPoint &aPoint)

	{

	ReplyBuf(&aPoint,sizeof(aPoint));

	}

void CWsClient::ReplyRect(const TRect &aRect)

	{

	ReplyBuf(&aRect,sizeof(aRect));

	}

void CWsClient::SetReply(TInt reply)

	{

	iReply=reply;

	if (wsDebugLog)

		wsDebugLog->Reply(reply);

	}

const TUint8 *CWsClient::EndOfCommandBuffer()

	{

	return(iCmdBuf.Ptr()+iCmdBuf.Size());

	}

const TPtrC CWsClient::BufferTPtr(TText *aStart,TInt aLen)

	{

	TPtrC ptr;

	if (!BufferTPtrGc(aStart,aLen,ptr))

		PanicCurrentClient(EWservPanicBufferPtr);

	return(ptr);

	}

TBool CWsClient::BufferTPtrGc(TText* aStart,TInt aLen, TPtrC& aPtr)

	{

	if (iCurrentCommand.iOpcode>0)

		{

		if ((REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

			return(EFalse);

		}

	else

		{

		if (aLen>=iCurrentCommand.iCmdLength)

			return(EFalse);

		}

	aPtr.Set(aStart,aLen);

	return(ETrue);

	}

const TPtrC8 CWsClient::BufferTPtr8(TUint8* aStart,TInt aLen)

	{

	if (iCurrentCommand.iOpcode>0 && (REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

		PanicCurrentClient(EWservPanicBufferPtr);

	return(TPtrC8(aStart,aLen));

	}

/**

Process a command buffer

@internalComponent

@released

*/

void CWsClient::CommandBufL()

	{

	if (wsDebugLog)

		{

		wsDebugLog->CommandBuf(iConnectionHandle);

		RThread client = Client(); 

		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, client.FullName());

		}

	iReplyOffset=0;

	iCurrentClient=this;

	CWsObject *destObj=NULL;

	const TUint8 *nextCmd=iCmdBuf.Ptr();

	const TUint8 *endCmd=nextCmd+iCmdBuf.Length();

	do

		{

		const TWsCmdHeader *pCmd=(TWsCmdHeader *)nextCmd;

		TUint opcode=pCmd->iBase.iOpcode;

		TInt headerLen=sizeof(pCmd->iBase);

		iCurrentCommand=pCmd->iBase;

		// For performance reasons the handle is only included

		// if it is different from the previous command. The EWsOpcodeHandle

		// flag indicates whether a new handle has been included in the

		// current command. If not we use the same handle as the previous

		// command.

		if (opcode&EWsOpcodeHandle)

			{

			opcode&=~EWsOpcodeHandle;

			iCurrentCommand.iOpcode=reinterpret_cast<TUint16&>(opcode);

			destObj=HandleToObjUntyped(pCmd->iDestHandle);

			headerLen=sizeof(*pCmd);

			}

		nextCmd+=headerLen;

		const TAny *cmdParams=nextCmd;

		nextCmd+=pCmd->iBase.iCmdLength;

		if (destObj==NULL || nextCmd>endCmd)		// Invalid handle or Corrupt buffer

			{

			SessionPanic(destObj==NULL ? EWservPanicHandle : EWservPanicBuffer);

			break;

			}

	#if defined(_DEBUG)

		iLastCommand=(nextCmd==endCmd);

	#endif

		// Storing destObj->Type() to a temporary variable objType allows the value of destObj->Type()

		// to be used if destObj is deleted during destObj->CommandL().

  	  	WH_HANDLES objType=destObj->Type(); 

		if (wsDebugLog)

			wsDebugLog->Command(objType, opcode, cmdParams, destObj->LogHandle());

		destObj->CommandL(opcode, cmdParams);

		} while(nextCmd<endCmd);

#if defined(_DEBUG)

	User::Heap().Check();