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

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

@see RedrawReady() */

	{

	if (iWsHandle)

		WriteReply(EWsClOpRedrawReadyCancel);

	}

EXPORT_C void RWsSession::PriorityKeyReadyCancel()

/** Cancels a priority key event request.

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

object's DoCancel() function.

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

@see PriorityKeyReady()

@see CActive */

	{

	if (iWsHandle)

		WriteReply(EWsClOpPriorityKeyReadyCancel);

	}

EXPORT_C void RWsSession::Flush()

/** Sends all pending commands in the buffer to the window server. 

Delivering a command to the window server requires a context switch, and so 

it is more efficient to deliver several commands in one go. Hence all client 

commands are normally first placed into a buffer for delivery to the window 

server. 

The buffer is delivered when it gets full, or when a command that returns a value 

is called (there are a few exceptions to this), or when this function is called.

Note: this function is called when a prompt response is required from the window 

server, e.g. after doing some drawing.

@see RWsSession::SetAutoFlush()

@see RWsSession::SetBufferSizeL()

@see RWsSession::SetMaxBufferSizeL()

*/

	{

	if (iBuffer)

		iBuffer->Flush(NULL,ETrue);

	}

EXPORT_C TBool RWsSession::SetAutoFlush(TBool aState)

/** Sets a session's auto-flush state. 

If auto-flush is set to ETrue, the window server buffer is flushed immediately 

anything is put into it, instead of waiting until it becomes full. This setting 

is normally used only in a debugging environment. 

If the auto-flush state is EFalse, the window server buffer is flushed normally.

@param aState ETrue to set auto-flushing on, EFalse to disable auto-flushing. 

@return Previous auto-flush state

@see RWsSession::Flush()

@see RWsSession::SetBufferSizeL()

@see RWsSession::SetMaxBufferSizeL()

*/

	{

	return(iBuffer->SetAutoFlush(aState));

	}

EXPORT_C TInt RWsSession::NumWindowGroups() const

/** Gets the total number of window groups currently running in the window server. 

This includes all the groups running in all sessions.

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

@return Total number of window groups running in the server */

	{

	return(WriteReply(EWsClOpNumWindowGroupsAllPriorities));

	}

EXPORT_C TInt RWsSession::NumWindowGroups(TInt aPriority) const

/** Gets the number of window groups of a given window group priority running in 

all sessions in the window server.

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

@param aPriority Window group priority 

@return Number of window groups of priority aPriority */

	{

	return(WriteReplyInt(aPriority,EWsClOpNumWindowGroups));

	}

EXPORT_C TInt RWsSession::NumWindowGroups(TInt aScreenNumber,TInt aPriority) const

/** Gets the number of window groups of a given window group priority running on a specified screen

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

@param aScreenNumber specifies the screen. 

@param aPriority Window group priority. EAllPriorities is the enum for all priorities 

@return Number of window groups of priority aPriority on the specified screen */

	{

	TWsClCmdNumWindowGroups params;

	params.screenNumber = aScreenNumber;

	params.priority = aPriority;

	return(WriteReply(&params,sizeof(params),EWsClOpNumWindowGroupsOnScreen));	

	}

TInt RWsSession::doWindowGroupList(TInt aScreenNumber, TInt aPriority, CArrayFixFlat<TInt>* aWindowList, TInt aNumOpcode, TInt aListOpcode) const

/** Gets the id of window groups of specified priority running on a specified screen.

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

@param aScreenNumber specifies the screen.

@param aPriority Window group priority 

@param aWindowList List of identifiers

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

codes.*/

	{

	TWsClCmdWindowGroupList params;

	params.priority = aPriority;		

	params.screenNumber = aScreenNumber;

	if(aScreenNumber!=KDummyScreenNumber)

		{

		TWsClCmdNumWindowGroups numWinGrp;

		numWinGrp.screenNumber = aScreenNumber;

		numWinGrp.priority = aPriority;	

		params.count=WriteReply(&numWinGrp,sizeof(numWinGrp),aNumOpcode);

		}

	else

		params.count=WriteReplyInt(aPriority,aNumOpcode);

	TRAPD(err,aWindowList->ResizeL(params.count));

	if (err!=KErrNone || params.count==0)

		return(err);

	TPtr8 listPtr(reinterpret_cast<TUint8*>(&(*aWindowList)[0]),params.count*sizeof((*aWindowList)[0]));

	TInt actualCount=WriteReplyP(&params, sizeof(params), &listPtr, aListOpcode);

	err=KErrNone;

	if (actualCount<0)

		{

		err=actualCount;

		actualCount=0;

		}

	if (actualCount<params.count)

		aWindowList->ResizeL(actualCount);	// Can't fail, only shrinking it

	return(err);

	}

TInt RWsSession::doWindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowListCh, TInt aNumOpcode, TInt aListOpcode) const

/** Gets the id of window groups and id of its parent window group of specified priority running in 

all sessions in the window server.

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

@param aPriority Window group priority 

@param aWindowList List of identifiers

@return KErrNone if successful else KErrNoMemory if there is insufficient memory to create the array. 

This function will panic if aWindowListCh is Null.*/

	{

	__ASSERT_ALWAYS(aWindowListCh,Panic(EW32PanicNullArray));

	TWsClCmdWindowGroupList params;

	params.priority=aPriority;

	params.count=WriteReplyInt(aPriority,aNumOpcode);

	aWindowListCh->Reset();

	TUint8* WindowList=static_cast<TUint8*>(User::Alloc(params.count*sizeof(TWindowGroupChainInfo)));

	if(WindowList==NULL)

		{

		return KErrNoMemory;

		}	

	TPtr8 listPtr(WindowList,params.count*sizeof(TWindowGroupChainInfo));

	WriteReplyP(&params, sizeof(params), &listPtr, aListOpcode);

	new(aWindowListCh) RArray<TWindowGroupChainInfo>(sizeof(TWindowGroupChainInfo),(TWindowGroupChainInfo*)WindowList,params.count);

	return KErrNone;

	}

EXPORT_C TInt RWsSession::WindowGroupList(CArrayFixFlat<TInt>* aWindowList) const

/** Gets a list of identifiers of all window groups in all window server sessions.

An array buffer must be created to store the resultant list.

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

@param aWindowList List of identifiers of all window groups in the server.

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

codes. */

	{

	return(doWindowGroupList(KDummyScreenNumber,0,aWindowList,EWsClOpNumWindowGroupsAllPriorities,EWsClOpWindowGroupListAllPriorities));

	}

EXPORT_C TInt RWsSession::WindowGroupList(CArrayFixFlat<TInt>* aWindowList,TInt aScreenNumber,TInt aPriority) const

/** Lists the number of window groups of a given window group priority running on a specified screen.

This function is the same as WindowGroupList() described above, but allows 

the application to restrict the list of window groups to those of a particular 

window group priority.

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

@param aScreenNumber specifies the screen

@param aPriority Window group priority . Enum for all priorities is EAllPriorities

@param aWindowList List of identifiers of all window groups on the specified screen with the given priority 

aPriority.

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

codes. */

	{

	return(doWindowGroupList(aScreenNumber,aPriority,aWindowList,EWsClOpNumWindowGroupsOnScreen,EWsClOpWindowGroupList));	

	}

EXPORT_C TInt RWsSession::WindowGroupList(RArray<TWindowGroupChainInfo>* aWindowList) const

/** Gets a list of identifier of window group and parent identifier of window group of

 all window groups in all window server sessions.

An array buffer must be created to store the resultant list.

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

@param aWindowList List of identifiers of all window groups in the server.

@return KErrNone if successful otherwise KErrNoMemory if there is insufficient memory to create the array,

Panics if aWindowList is NULL. */

	{

	return(doWindowGroupList(0,aWindowList,EWsClOpNumWindowGroupsAllPriorities,EWsClOpWindowGroupListAndChainAllPriorities));

	}

EXPORT_C TInt RWsSession::WindowGroupList(TInt aPriority,CArrayFixFlat<TInt>* aWindowList) const

/** Lists the number of window groups of a given window group priority running 

in all window server sessions.

This function is the same as WindowGroupList() described above, but allows 

the application to restrict the list of window groups to those of a particular 

window group priority.

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

@param aPriority Window group priority 

@param aWindowList List of identifiers of all window groups in the server of priority 

aPriority.

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

codes. */

	{

	return(doWindowGroupList(KDummyScreenNumber,aPriority,aWindowList,EWsClOpNumWindowGroups,EWsClOpWindowGroupList));

	}

EXPORT_C TInt RWsSession::WindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowList) const

/** Lists the number of window groups of a given window group priority running 

in all window server sessions.

This function is the same as WindowGroupList() described above, but allows 

the application to restrict the list of window groups to those of a particular 

window group priority.

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

@param aPriority Window group priority 

@param aWindowList List of identifiers of all window groups in the server of priority 

aPriority.

@return KErrNone if successful otherwise KErrNoMemory if there is insufficient memory to create the array, 

Panics if aWindowList is NULL. */	

	{

	return(doWindowGroupList(aPriority,aWindowList,EWsClOpNumWindowGroups,EWsClOpWindowGroupListAndChain));

	}

EXPORT_C TInt RWsSession::GetDefaultOwningWindow() const

/** Gets the identifier of the current default owning window group.

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

@return Identifier of current default owning window group. Returns 0 if there 

isn't one. */

	{

	return GetDefaultOwningWindow(KDummyScreenNumber);

	}

EXPORT_C TInt RWsSession::GetDefaultOwningWindow(TInt aScreenNumber) const

/** Gets the identifier of the current default owning window group on a specified screen.

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

@param aScreenNumber specifies the screen.

@return Identifier of current default owning window group on the specified screen. Returns 0 if there 

isn't one. */

	{

	return(WriteReplyInt(aScreenNumber,EWsClOpGetDefaultOwningWindow));	

	}

EXPORT_C TInt RWsSession::GetFocusWindowGroup() const

/** Gets the identifier of the window group that currently has the keyboard focus.

Note: this might not necessarily be the front-most window group, as window groups 

can disable keyboard focus.

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

@return Identifier of window group with keyboard focus. */

	{

	return GetFocusWindowGroup(KDummyScreenNumber);

	}

EXPORT_C TInt RWsSession::GetFocusWindowGroup(TInt aScreenNumber) const

/** Gets the identifier of the window group on a specified screen that currently has the keyboard focus.

Note: this might not necessarily be the front-most window group, as window groups 

can disable keyboard focus.

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

@param aScreenNumber specifies the screen.

@return Identifier of window group with keyboard focus. */

	{

	return WriteReplyInt(aScreenNumber,EWsClOpGetFocusWindowGroup);	

	}

EXPORT_C TInt RWsSession::SetWindowGroupOrdinalPosition(TInt aIdentifier, TInt aPosition)

/** Sets the ordinal position of a window group.

This function allows the caller to change the ordinal position of an existing 

window group. It would typically be used by a shell application.

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

@param aIdentifier The window group. 

@param aPosition Ordinal position for the window group. 

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

codes. */

	{

	TWsClCmdSetWindowGroupOrdinalPosition params(aIdentifier,aPosition);

	return(WriteReply(&params, sizeof(params),EWsClOpSetWindowGroupOrdinalPosition));

	}

EXPORT_C TInt RWsSession::GetWindowGroupClientThreadId(TInt aIdentifier, TThreadId &aThreadId) const

/** Gets the thread ID of the client that owns the window group specified by the 

window group identifier.

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

@param aIdentifier The window group identifier. 

@param aThreadId On return, contains the thread ID. 

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

codes. */

	{

	TPtr8 ptr(reinterpret_cast<TUint8*>(&aThreadId),sizeof(aThreadId));

	return(WriteReplyIntP(aIdentifier,&ptr,EWsClOpGetWindowGroupClientThreadId));

	}

EXPORT_C TInt RWsSession::GetWindowGroupHandle(TInt aIdentifier) const

/** Gets the handle of the window specified by the window group identifier. 

This is the handle that was passed as an argument to RWindowGroup::Construct().

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

@param aIdentifier The window group identifier.

@return Handle of the window group */

	{

	return(WriteReplyInt(aIdentifier,EWsClOpGetWindowGroupHandle));

	}

EXPORT_C TInt RWsSession::GetWindowGroupOrdinalPriority(TInt aIdentifier) const

/** Gets a window group's priority.

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

@param aIdentifier The window group identifier. 

@return The window group priority. */

	{

	return(WriteReplyInt(aIdentifier,EWsClOpGetWindowGroupOrdinalPriority));

	}

EXPORT_C TInt RWsSession::SendEventToWindowGroup(TInt aIdentifier, const TWsEvent &aEvent)

/** Sends an event to a window group.

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

@param aIdentifier Window group identifier.

@param aEvent Event to send to the window group.

@return KErrNone if successful, KErrPermissionDenied if the client does not have 

the required capability, KErrNoMemory if there is not enough room to add the 

event to the event queue and otherwise another of the system-wide error codes.

@capability SwEvent Required when aEvent.Type() < EEventUser unless the event 

is for a window group owned by this session.

@deprecated */

	{

	TWsClCmdSendEventToWindowGroup params(aIdentifier,aEvent);

	return(WriteReply(&params, sizeof(params),EWsClOpSendEventToWindowGroup));

	}

EXPORT_C TInt RWsSession::SendEventToAllWindowGroups(const TWsEvent &aEvent)

/** Sends the specified event to all existing window groups.

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

@param aEvent The event to be sent to all window groups. 

@return KErrNone if successful, KErrPermissionDenied if the client does not have 

the required capability, KErrNoMemory if there is not enough room to add the 

event to all the required event queues (although it may have been added to some 

of them) and otherwise another of the system-wide error codes.

@capability SwEvent Required when aEvent.Type() < EEventUser

@deprecated */

	{

	TWsClCmdSendEventToWindowGroup params(0,aEvent);

	return(WriteReply(&params, sizeof(params),EWsClOpSendEventToAllWindowGroup));

	}

EXPORT_C TInt RWsSession::SendEventToAllWindowGroups(TInt aPriority, const TWsEvent &aEvent)

/** Sends the specified event to all window groups with the specified priority.

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

@param aPriority The priority which window groups must have to be sent the 

message.

@param aEvent The event to be sent to the specified window groups.

@return KErrNone if successful, KErrPermissionDenied if the client does not have 

the required capability, KErrNoMemory if there is not enough room to add the 

event to all the required event queues (although it may have been added to some 

of them) and otherwise another of the system-wide error codes.

@capability SwEvent Required when aEvent.Type() < EEventUser

@deprecated  */

	{

	TWsClCmdSendEventToWindowGroup params(aPriority,aEvent);

	return(WriteReply(&params, sizeof(params),EWsClOpSendEventToAllWindowGroupPriority));

	}

EXPORT_C TInt RWsSession::SendEventToOneWindowGroupsPerClient(const TWsEvent &aEvent)

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

@capability SwEvent Required when aEvent.Type() < EEventUser 

@deprecated  */

	{

	TWsClCmdSendEventToWindowGroup params(0,aEvent);

	return(WriteReply(&params, sizeof(params),EWsClOpSendEventToOneWindowGroupPerClient));

	}

EXPORT_C TInt RWsSession::GetWindowGroupNameFromIdentifier(TInt aIdentifier, TDes &aWindowName) const

/** Gets the name of a window group from its identifier. 

Using the list of identifiers returned by WindowGroupList(), it is possible 

to get the names of all window groups in the system. Note that window names 

are a zero length string by default.

Note that the window group name must have been previously set using RWindowGroup::SetName() 

to contain a meaningful value.

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

@param aIdentifier The identifier of the window group whose name is to be 

inquired.

@param aWindowName On return, contains the window group name.

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

codes. */

	{

	TWsClCmdGetWindowGroupNameFromIdentifier params(aIdentifier,aWindowName.MaxLength());

	return(WriteReplyP(&params,sizeof(params),&aWindowName,EWsClOpGetWindowGroupNameFromIdentifier));

	}

EXPORT_C TInt RWsSession::FindWindowGroupIdentifier(TInt aPreviousIdentifier,const TDesC& aMatch,TInt aOffset) const

/** Gets all window groups whose names match a given string, which can contain 

wildcards.

An example use of this function might be to find all the currently 

running instances of a particular application, assuming that the window group 

name contains the application name. An optional argument, aOffset, specifies 

the number of characters to be ignored at the beginning of the window group 

name. As several window group names may match the given string, and the function 

can return only one at a time, there is an argument, aPreviousIdentifier, 

which gives the identifier for the previous match that was returned. In other 

words, it means, "get me the next match after this one." The first time the 

function is called, give 0 as the previous identifier.