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

// IPC implementation of client side code

// 

//

#include "../SERVER/w32cmd.h"

#include "w32comm.h"

#include <e32std.h>

#include <w32std.h>

#include "CLIENT.H"

#include "graphics/windowserverconstants.h"

#include "rtfxeffect.h"

#include <wspublishandsubscribedata.h>

const TInt KMaxWSERVMessagesSlot=-1;

class RWsCustomTextCursor : public RWsSpriteBase

	{

	public:

		RWsCustomTextCursor(RWsSession aWs, TInt aHandle) : RWsSpriteBase(aWs)

			{ iWsHandle = aHandle; }

	};

EXPORT_C RWsSession::RWsSession()

/** Default C++ constructor.

Constructs an uninitialised window server session. Note that it does not establish 

a connection to the window server - this must be done explicitly by calling 

the session's Connect() function. Before Connect() is called, no corresponding 

session object exists in the server, and the RWsSession contains no meaningful 

handle. */

	{}

void RWsSession::connectL()

	{

	iBuffer=new(ELeave) RWsBuffer(this);

	iBuffer->SetBufferSizeL(RWsBuffer::EDefBufferSize);

	User::LeaveIfError(CreateSession(KWSERVServerName,Version(),KMaxWSERVMessagesSlot));

	iWsHandle=User::LeaveIfError(SendReceive(EWservMessInit,TIpcArgs()));

	}

EXPORT_C TInt RWsSession::Connect()

/** Connects the client session to the window server.

Connect() should be the first function called on an RWsSession object after 

it is created. The function establishes a connection to the window server, 

creating a corresponding session object in the server. Each session has one 

and only one connection to the server. Attempting to call Connect() when 

a connection has already been made will cause a panic.

After a connection has been successfully established, all events are delivered 

to the client application through the RWsSession object.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

	{

	TInt ret;

	if (iBuffer!=NULL)

		Panic(EW32PanicReConnect);

 	if ((ret=RFbsSession::Connect())==KErrNone)

		{

		TRAP(ret,connectL());

		if (ret!=KErrNone)

			{

			if (!iBuffer)

				RFbsSession::Disconnect();

			Close();

			}

		else

			iBuffer->SetCallBack();

		}

	return(ret);

	}

EXPORT_C TInt RWsSession::Connect(RFs& aFileServer)

/** Connects the client session to the window server using pre constructed file server

session.

Connect() should be the first function called on an RWsSession object after 

it is created. The function establishes a connection to the window server, 

creating a corresponding session object in the server. Each session has one 

and only one connection to the server. Attempting to call Connect() when 

a connection has already been made will cause a panic.

After a connection has been successfully established, all events are delivered 

to the client application through the RWsSession object.

@param aFileServer A fully constructed file server session

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

	{

	TInt ret;

	if (iBuffer!=NULL)

		Panic(EW32PanicReConnect);

 	if ((ret=RFbsSession::Connect(aFileServer))==KErrNone)

		{

		TRAP(ret,connectL());

		if (ret!=KErrNone)

			{

			if (!iBuffer)

				RFbsSession::Disconnect();

			Close();

			}

		else

			iBuffer->SetCallBack();

		}

	return(ret);

	}

EXPORT_C void RWsSession::Close()

/** Closes the window server session. 

This function cleans up all resources in the RWsSession and disconnects it 

from the server. Prior to disconnecting from the window server, the client-side 

window server buffer is destroyed without being flushed. This function should 

be called when the RWsSession is no longer needed - normally just before 

it is destroyed. */

	{

	if (iBuffer)

		{

		__ASSERT_ALWAYS(iBuffer->iDirectAcessCount==0,Panic(EW32PanicDirectMisuse));

		iBuffer->CancelCallBack();

		iBuffer->Destroy();

		iBuffer=NULL;

		RFbsSession::Disconnect();

		}

	RSessionBase::Close();

	}

// Private function(s)

TInt RWsSession::DoSyncMsgBuf(const TIpcArgs& aIpcArgs)

	{

	return (SendReceive(EWservMessSyncMsgBuf,aIpcArgs));

	}

TInt RWsSession::DoFlush(const TIpcArgs& aIpcArgs)

	{

	return (SendReceive(EWservMessCommandBuffer,aIpcArgs));

	}

EXPORT_C TVersion RWsSession::Version() const

/** Gets the window server version.

@return Window server version containing major and minor version numbers, 

and build number. */

	{

	TVersion v(KWservMajorVersionNumber,KWservMinorVersionNumber,KWservBuildVersionNumber);

	return(v);

	}

TInt RWsSession::doSetHotKey(TInt aOpcode, TInt aType, TUint aKeycode, TUint aModifierMask, TUint aModifiers)

	{

	TWsClCmdSetHotKey setHotKey;

	setHotKey.type=aType;

	setHotKey.keycode=(TUint16)aKeycode;

	setHotKey.modifiers=aModifiers;

	setHotKey.modifierMask=aModifierMask;

	return(WriteReply(&setHotKey,sizeof(setHotKey),aOpcode));

	}

EXPORT_C TInt RWsSession::SetHotKey(THotKey aType, TUint aKeycode, TUint aModifierMask, TUint aModifiers)

/** Sets the hot keys.

Hot keys allow standard functions to be performed by application-defined key 

combinations. 

This function maps any key press (with optional modifiers) to one of the hot 

keys defined in THotKey. More than one key combination may be mapped to each 

hot key: a new mapping is added each time the function is called.

Modifier key states are defined in TEventModifier. The modifiers that you 

want to be in a particular state should be specified in aModifierMask and 

the ones of these you want to be set should be specified in aModifiers. For 

example, if you want to capture FN-A and you want the SHIFT modifier unset, 

but you don't care about the state of the other modifiers then set both the 

flags for SHIFT and FN in aModiferMask and only set FN in aModifiers.

Note: default hotkey settings exist, but this function can be used for customisation. 

Typically it might be be used by a shell application or other application 

that controls system-wide settings.

This function always causes a flush of the window server buffer.

@param aType The hot key to be mapped

@param aKeyCode The keycode to be mapped to the hot key

@param aModifierMask Modifier keys to test for a match

@param aModifiers Modifier keys to be tested for "on" state 

@return KErrNone value if successful, otherwise another of the system-wide 

error codes.

@capability SwEvent */

	{

	return(doSetHotKey(EWsClOpSetHotKey, aType, aKeycode, aModifierMask, aModifiers));

	}

EXPORT_C TInt RWsSession::ClearHotKeys(THotKey aType)

/** Clears all mappings for the specified hotkey, including the default mapping.

Hotkeys allow standard functions to be performed by application-defined key 

combinations. 

This function always causes a flush of the window server buffer.

@param aType The hot key to be cleared 

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see SetHotKey()

@see RestoreDefaultHotKey()

@capability SwEvent */

	{

	return(WriteReplyInt(aType,EWsClOpClearHotKeys));

	}

EXPORT_C TInt RWsSession::RestoreDefaultHotKey(THotKey aType)

/** Restores the default mapping for a hot key.

The function clears current mappings for a hot key and restores the default 

mapping. See THotKey for the default.

This function always causes a flush of the window server buffer.

@param aType The hot key to restore to its default value 

@return KErrNone if successful, otherwise another of the system-wide error 

codes. 

@see ClearHotKeys() */

	{

	return(WriteReplyInt(aType,EWsClOpRestoreDefaultHotKey));

	}

EXPORT_C void RWsSession::ComputeMode(TComputeMode aMode)

/** Sets the mode used to control process priorities.

The default window server behaviour is that the application that owns the 

window with keyboard focus gets foreground process priority (EPriorityForeground) 

while all other clients get background priority (EPriorityBackground). This 

function can be used to over-ride this default behaviour, as discussed in 

TComputeMode.

Note:

Unlike real Symbian phones, the Emulator runs on a single process. As a result, 

on the Emulator this function sets the priority of individual threads rather 

than of processes. The values used for thread priorities are EPriorityLess 

instead of EPriorityBackground, and EPriorityNormal instead of EPriorityForeground.

@param aMode The compute mode. */

	{

	WriteInt(aMode,EWsClOpComputeMode);

	}

/**

This method has been deprecated. Shadowing of a window is no longer supported. 

Calling it has no effect.

@param aVector Ignored.

@deprecated

*/

EXPORT_C void RWsSession::SetShadowVector(const TPoint& /*aVector*/)

	{

	}

/**

This method has been deprecated. Shadowing of a window is no longer supported.

Calling it has no effect.

@return TPoint(0, 0)

@deprecated

*/

EXPORT_C TPoint RWsSession::ShadowVector() const

	{

	return TPoint();

	}

void RWsSession::doReadEvent(TRequestStatus *aStat, TInt aOpcode)

	{

	*aStat=KRequestPending;

	if (iBuffer)

		{

		iBuffer->Flush(); //ignore error since this flushing should not return any error

		}

	__ASSERT_DEBUG(EWservMessAsynchronousService>=aOpcode, Assert(EW32AssertIllegalOpcode));

	const TInt function=EWservMessAsynchronousService|aOpcode;

	SendReceive(function,TIpcArgs(),*aStat);

	}

EXPORT_C void RWsSession::EventReady(TRequestStatus* aStat)

/** Requests standard events from the window server.

Standard events include all events except redraws and priority key events.

The client application will typically handle the completed request using the 

RunL() function of an active object, and in this case the request status aStat 

should be the iStatus member of that CActive object.

Notes:

- The active object runs when an event is waiting. You should call GetEvent() 

in the RunL() function to get the event.

- You should not call this function again until you have either called GetEvent() 

or EventReadyCancel().

- Because this function is asynchronous, there is no guarantee that the Window 

Server will process the request before the function returns. However, on single 

core systems it is unusual for this function to return before the Window Server 

has processed the request, because the client generally runs in a lower priority 

thread than the Window Server. You should therefore expect the use of this 

function to give rise to different behaviour between single and multicore systems.

@param aStat Request status. On successful completion contains KErrNone, otherwise 

another of the system-wide error codes.

@see CActive

@see GetEvent() */

	{

	doReadEvent(aStat,EWsClOpEventReady);

	}

EXPORT_C void RWsSession::RedrawReady(TRequestStatus* aStat)

/** Requests redraw events from the window server.

Typically, a client will create an active object for redraw events with a 

lower priority than the active objects for standard events. The client will 

then typically handle completed redraw requests in the active object's RunL() 

function.

As in EventReady(), the request status aStat should be used as the iStatus 

member of an active object. When a redraw event occurs the active object's 

RunL() function is called. The redraw event can be obtained by calling 

GetRedraw() in the RunL().

Notes:

- You should not call this function again until you have either called 

GetRedraw() or RedrawReadyCancel().

- Because this function is asynchronous, there is no guarantee that the Window 

Server will process the request before the function returns. However, on single 

core systems it is unusual for this function to return before the Window Server 

has processed the request, because the client generally runs in a lower priority 

thread than the Window Server. You should therefore expect the use of this 

function to give rise to different behaviour between single and multicore systems.

@param aStat The request status. On successful completion contains KErrNone, 

otherwise another of the system-wide error codes. 

@see RedrawReadyCancel()

@see GetRedraw()

@see CActive */

	{

	doReadEvent(aStat,EWsClOpRedrawReady);

	}

void RWsSession::GraphicMessageReady(TRequestStatus *aStat)

	{

	doReadEvent(aStat,EWsClOpGraphicMessageReady);

	}

void RWsSession::GetGraphicMessage(TDes8& aData) const

	{

	WriteReplyP(TWriteDescriptorType(&aData),EWsClOpGetGraphicMessage);

	}

void RWsSession::GraphicMessageCancel()

	{

	WriteReply(EWsClOpGraphicMessageCancel);

	}

void RWsSession::GraphicAbortMessage(TInt aError)

	{

	WriteReplyInt(aError, EWsClOpGraphicAbortMessage);

	}

TInt RWsSession::GraphicFetchHeaderMessage()

	{

	return WriteReply(EWsClOpGraphicFetchHeaderMessage);

	}

EXPORT_C void RWsSession::PriorityKeyReady(TRequestStatus *aStat)

/** Requests priority key events from the window server. 

Typically, an client will create an active object for priority key events 

with a higher priority than the active objects for standard events. The client 

will then normally handle completed priority key requests in the active object's 

RunL() function.

As in EventReady(), the request status argument should be the set to the iStatus 

member of CActive. When priority key events occur, they are obtained using 

GetPriorityKey().

Notes:

- You should not call this function again until you have either called 

GetPriorityKey() or PriorityKeyReadyCancel().

- Because this function is asynchronous, there is no guarantee that the Window 

Server will process the request before the function returns. However, on single 

core systems it is unusual for this function to return before the Window Server 

has processed the request, because the client generally runs in a lower priority 

thread than the Window Server. You should therefore expect the use of this 

function to give rise to different behaviour between single and multicore systems.

@param aStat Request status. On successful completion contains KErrNone, otherwise 

another of the system-wide error codes. 

@see PriorityKeyReadyCancel()

@see GetPriorityKey()

@see CActive */

	{

	doReadEvent(aStat,EWsClOpPriorityKeyReady);

	}

EXPORT_C void RWsSession::GetEvent(TWsEvent &aEvent) const

/** Gets a standard event from the session for processing.

The type of event returned by GetEvent() may be any of those listed in TEventCode. 

To access the data within an event, the event should be converted to the appropriate 

type, using functions provided by the TWsEvent class. TWsEvent also provides 

a function to find out the type of the event.

Notes:

It is possible that the returned event is of type EEventNull. Clients should 

normally ignore these events.

This function should only be called in response to notification that an event 

has occurred, otherwise the client will be panicked.

This function would normally be called in the RunL() function of an active 

object which completes with the EventReady() function's request status.

This function always causes a flush of the window server buffer.

@param aEvent On return, contains the event that occurred 

@see TEventCode

@see EventReady() */

	{

	TPckgBuf<TWsEvent> event;

	WriteReplyP(&event,EWsClOpGetEvent);

	aEvent=event();

	}

EXPORT_C void RWsSession::PurgePointerEvents()

/** Removes all pointer events waiting to be delivered to this session. 

The events are removed from the event queue without being processed. This 

might occur, for example, at application startup. */

	{

	Write(EWsClOpPurgePointerEvents);

	}

EXPORT_C void RWsSession::GetRedraw(TWsRedrawEvent &aEvent)

/** Gets the redraw event from the session.

This function is similar to GetEvent(), except that the event is returned 

as a TWsRedrawEvent, and hence there is no need to convert it from a TWsEvent.

The function should only be called after notification that a redraw is waiting.

It always causes a flush of the window server buffer.

@param aEvent On return, contains the redraw event that occurred 

@see RedrawReady()

@see GetEvent()

@see CActive */

	{

	TPckgBuf<TWsRedrawEvent> redraw;

	WriteReplyP(&redraw,EWsClOpGetRedraw);

	aEvent=redraw();

	}

EXPORT_C void RWsSession::GetPriorityKey(TWsPriorityKeyEvent &aEvent) const

/** Gets the completed priority key event from the window server session.

Priority key events are typically used for providing "Abort" or "Escape" keys 

for an application.

This function is similar to GetEvent(), except that it returns a TWsPriorityKeyEvent 

instead of a TWsEvent.

Note: this should only be called after notification that a priority key event has 

occurred.

This function always causes a flush of the window server buffer.

@param aEvent On return, contains the priority key event that occurred. 

@see PriorityKeyReady()

@see PriorityKeyReadyCancel() */

	{

	TPckgBuf<TWsPriorityKeyEvent> abortEvent;

	WriteReplyP(&abortEvent,EWsClOpGetPriorityKey);

	aEvent=abortEvent();

	}

EXPORT_C void RWsSession::EventReadyCancel()

/** Cancels a request for standard events from the window server.

This request was made using EventReady().

The client application will typically use an active object to handle standard 

events, and this function should be called from the active object's DoCancel() 

function.

This function always causes a flush of the window server buffer.

@see EventReady() */

	{

	if (iWsHandle)

		WriteReply(EWsClOpEventReadyCancel);

	}

EXPORT_C void RWsSession::RedrawReadyCancel()

/** Cancels a redraw event request. 

If active objects are used, this function should be called from the active 

object's DoCancel() function.