// 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"

#include <e32hashtab.h>  // for RHashMap

#include "registeredsurfacemap.h"

#include <graphics/wselement.h>

#include "windowelementset.h"

#include "drawresource.h"

extern CDebugLogBase* wsDebugLog;

_LIT(KWSERVSessionPanicCategory,"WSERV");

GLREF_D TPtr nullDescriptor;

TWsCmdHeaderBase CWsClient::iCurrentCommand;

TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;

TInt CWsClient::iReply;

TInt CWsClient::iReplyOffset;

CWsClient* CWsClient::iCurrentClient;

CWsObject* CWsClient::iDestObj;

const TUint8* CWsClient::iNextCmd;

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

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

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

CWsPointerCursor* CWsClient::iDefaultSystemPointerCursor;

CWsClient* CWsClient::iSystemPointerCursorListOwner = NULL;

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

TKeyArrayFix CWsClient::iCursorKey(_FOFF(CWsClient::TWsCursorArrayItem,iIndex), ECmpTInt);

/**

Used for enforcing the redraw calling convention 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 globally 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;

// Security policy stings

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);

//

// class CWsClient

// 

CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iInternalFlags(ERemoveKeyCode|EFinishedProcessingCommands)

	{

	iScreen = CWsTop::Screen();

	}

CWsClient::~CWsClient()

	{

	CWsTop::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::ClearSurfaceMap(this);

	CWsTop::SessionExited(this);

	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

	iInternalFlags |= EIsInitialised;

	}

TBool CWsClient::DebugEnforceRedrawCallingConvention()

	{

	return iDebug_EnforceRedrawCallingConvention;

	}

void CWsClient::StartInitializationL(TUint aConnectionHandle)

	{

	if (wsDebugLog)

		wsDebugLog->NewClient(aConnectionHandle);

	if (iObjectIndex)

		PPanic(EWservPanicReInitialise);

	else

		{

		iConnectionHandle = aConnectionHandle;

		CompleteInitializationL();

		}

	}

//

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

//

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

	{

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

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

		PPanic(EWservPanicWindow);

	}

//

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

//

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

	{

	if ((*pWin=(CWsClientWindow*)HandleToObj(aHandle, 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 = KErrNotFound;

	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)

		{

		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, iCursorKey);

	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.

If the parent is a window group then a new CWsTopClientWindow instance is created. If the parent is

a window then a new CWsClientWindow instance is created.

@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) CWsTopClientWindow(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 initialised inside the constructL

	}

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())

				gw->SetScreenDevice(iPrimaryScreenDevice);

			}

		}

	}

void CWsClient::CreateNewClickHandlerL(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();

		}

	}

/**	

Returns the remaining space in the descriptor

*/

TInt CWsClient::ReplyBufSpace() 

	{

	const TInt retVal = iCurrentClient->ClientMessage().GetDesLength(KReplyBufferMessageSlot);

	if (iReplyOffset>=0 && retVal>=iReplyOffset)

		return retVal-iReplyOffset;

	else

		return (retVal<0 ? retVal : KErrBadDescriptor);

	}

void CWsClient::ReplyBuf(const TDesC16 &aDes)	// static

	{

	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)	// static

	{

	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)	// static

//

// Send a buffer to the client process.

//

	{

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

	ReplyBuf(src);

	}

void CWsClient::ReplySize(const TSize &aSize)	// static

	{

	ReplyBuf(&aSize, sizeof(aSize));

	}

void CWsClient::ReplyPoint(const TPoint &aPoint)	// static

	{

	ReplyBuf(&aPoint, sizeof(aPoint));

	}

void CWsClient::ReplyRect(const TRect &aRect)	// static

	{

	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::DispatchCommandsInBufL()	// (step #4)

	{		

	if (wsDebugLog)

		{

 		wsDebugLog->CommandBuf(iConnectionHandle);

 		RThread client = Client(); 

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

		}

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

	do

		{

		const TWsCmdHeader* pCmd=

				reinterpret_cast<const TWsCmdHeader*>(iNextCmd);

		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)

			{

			// Find the WServ object associated with this op code

			opcode &= ~EWsOpcodeHandle;

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

			iDestObj=HandleToObjUntyped(pCmd->iDestHandle);