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

 // Standard window server header file

 // 

 //

 #ifndef __W32STD_H__

 #define __W32STD_H__

 #ifndef __FNTSTORE_H__

 #include <fntstore.h>

 #endif

 #ifndef __BITDEV_H__

 #include <bitdev.h>

 #endif

 #ifndef __BITSTD_H__

 #include <bitstd.h>

 #endif

 #include <e32keys.h>

 #include <textcursor.h>

 #include <pointerevent.h>

 #include <advancedpointerevent.h>

 #include <sizemode.h>

 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <graphics/windowserverconstants.h>

 #include <graphics/pointereventdata.h>

 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS

 _LIT(KWSERVThreadName,"Wserv");

 class RWindowBase;

 class RWindow;

 class RWsBuffer;

 class MWsObjectProvider;

 class RWsDrawableSource;

 class TSizeMode;

 /** Screen mode enforcement flags.

 Screen mode enforcement ensures that windows must meet certain requirements

 if they are to be displayed. When the screen mode changes, window groups that

 are incorrectly set up, according to these requirements, are locked out. The

 windows are notified of the change, and will be displayed if they are updated

 (according to the current enforcement requirement) to match the new screen

 mode.

 @publishedAll

 @released

 @see CWsScreenDevice::ScreenModeEnforcement()

 @see CWsScreenDevice::SetScreenModeEnforcement() */

 enum TScreenModeEnforcement

 	{

 	/** No enforcement.

 	All windows that are the children of window groups will be displayed, irrespective

 	of the screen mode.

 	This is not properly supported and is provided for testing purposes. */

 	ESizeEnforcementNone,

 	/** Pixels and rotation enforcement.

 	Group windows must be set up for the correct rotation and be working in the

 	correct size in pixels to be displayed. */

 	ESizeEnforcementPixelsAndRotation,

 	/** Pixels and Twips enforcement.

 	Group windows must have the correct rotation and be working in the correct

 	size in pixels and twips to be displayed.

 	This setting might be used if the display pixels are not square, and would

 	distort fonts when rotated. */

 	ESizeEnforcementPixelsTwipsAndRotation,

 	};

 struct TPixelsAndRotation

 /** Pixels and rotation struct.

 This is used to define a particular screen mode's screen size in pixels,

 and its rotation.

 @publishedAll

 @released

 @see CWsScreenDevice::GetScreenModeSizeAndRotation() */

 	{

 	/** The screen size, for a given screen mode, in pixels. */

 	TSize iPixelSize;

 	/** The current screen orientation. */

 	CFbsBitGc::TGraphicsOrientation iRotation;

 	};

 struct TPixelsTwipsAndRotation

 /** Pixels, twips and rotation struct.

 This is used to define a particular screen mode's screen size in twips

 and pixels, and its rotation.

 @publishedAll

 @released

 @see CWsScreenDevice::GetScreenModeSizeAndRotation() */

 	{

 	/** The screen size, for a given screen mode, in pixels. */

 	TSize iPixelSize;

 	/** The screen size, for a given screen mode, in twips. */

 	TSize iTwipsSize;

 	/** The screen rotation. */

 	CFbsBitGc::TGraphicsOrientation iRotation;

 	};

 /** Log message text length.

 This defines the length of the log text message buffer TLogMessageText,

 which is used in RWsSession::LogMessage().

 @publishedAll

 @released */

 enum {

 	/** The length of the log message text buffer in characters. */

 	KLogMessageLength=0x80

 	};

 /** Log message text buffer.

 This is used in RWsSession::LogMessage().

 @publishedAll

 @released */

 typedef TBuf<KLogMessageLength> TLogMessageText;

 /** Password window group priority.

 This priority is assigned to the password window group when the window server is displaying the password window.

 This is the highest priority, which ensures that the machine password window is in front of all other windows -

 hence password tests cannot be bypassed.

 @publishedAll

 @deprecated */

 enum

 	{

 	 /** Password window group priority. */

 	KPasswordWindowGroupPriority=1000

 	};

 /** Switch ordinal position to owning window.

 This enum can be specified as the 2nd parameter to RWsSession::SetWindowGroupOrdinalPosition()

 or as the 1st parameter to RWindowTreeNode::SetOrdinalPosition() (if this is being called on an

 RWindowGroup).

 When called with this value, the functions don't change the ordinal position of the group window

 in question, but rather bring to the front the window that would come to the front if that group

 window were to die with keyboard focus.

 @publishedAll

 @released

 @see RWsSession::SetWindowGroupOrdinalPosition()

 @see RWindowTreeNode::SetOrdinalPosition() */

 enum {

 	/** Switch ordinal position to owning window. */

 	KOrdinalPositionSwitchToOwningWindow=0x80000000

 	};

 /** Window corner types.

 Corners may be specified square or stepped, with varying numbers of pixels

 removed to make the stepping. Picturing a corner as the top left corner of

 a window, the numbers denote the number of pixels removed from the top row

 to give corners.

 @publishedAll

 @released

 @see TCornerFlags

 @see RWindowBase::SetCornerType() */

 enum TCornerType

 // Bottom 16 bits available for corner type

 	{

 	/** Square corner. */

 	EWindowCornerSquare,

 	/** Corner pixel removed. */

 	EWindowCorner1,

 	/** Two pixel step.

 	3 pixels are removed: the corner pixel and a single pixel from each side. */

 	EWindowCorner2,

 	/** Three pixel step.

 	5 pixels are removed: the corner pixel, the two pixels next to it and the

 	2 pixels above or below it. */

 	EWindowCorner3,

 	/** Five pixel step.

 	12 pixels are removed: the corner pixel, the four pixels next to it, the

 	four pixels above or below it, the pixel which was diagonal to the corner

 	pixel, and the pixels to both sides of that pixel. */

 	EWindowCorner5,

 	EWindowCornerRegion,		// Private

 	/** Corner type mask.

 	This value is used by the window server, and may be used by developers, to

 	separate TCornerType and TCornerFlags values from a TInt which contains both

 	types. */

 	ECornerTypeMask=0xFFFF

 	};

 /** Corner flags.

 These are used by RWindowBase::SetCornerType() to set which corners of a window

 are not to have corner types applied to them.

 @publishedAll

 @released

 @see TCornerType */

 enum TCornerFlags

 // Top 16 bits available for corner flags

 	{

 	/** Do not apply corner shape to top left corner. */

 	EWindowCornerNotTL=0x10000,

 	/** Do not apply corner shape to top right corner. */

 	EWindowCornerNotTR=0x20000,

 	/** Do not apply corner shape to bottom left corner. */

 	EWindowCornerNotBL=0x40000,

 	/** Do not apply corner shape to bottom right corner. */

 	EWindowCornerNotBR=0x80000,

 	};

 /** Window backup type flags.

 @publishedAll

 @released

 @see RWindowBase::EnableBackup() */

 enum TWindowBackupType

 	{

 	/** Backup the area behind the current window only.

 	This is the default behaviour for the RWindowBase::EnableBackup() function. */

 	EWindowBackupAreaBehind=0x0001,

 	/** Backup the entire screen.

 	This is provided for windows that require the rest

 	of the screen to fade when they are displayed. When the rest of the screen

 	should become unfaded, the window server redraws the whole screen from the

 	backed up bitmap. */

 	EWindowBackupFullScreen=0x0002,

 	};

 /** Types of standard events.

 These are events that the window server passes to its clients, as opposed

 to events that the base passes to the window server.

 @publishedAll

 @released

 @see CClickMaker */

 enum TEventCode

 	{

 	/** Null event.

 	This can be sent, but should be ignored by clients. */

 	EEventNull,

 	/** Key event.

 	This is the event that is sent when a character has been received from the

 	keyboard.

 	If an EEventKey event is associated with an EEventKeyDown or EEventKeyUp

 	event (typically EEventKeyDown), the EEventKey event occurs after the

 	EEventKeyDown/EEventKeyUp event.

 	In practice, the only keys potentially likely to have their EEventKey event

 	generated on the up rather than the down are modifier keys. */

 	EEventKey,

 	/** Key up event.

 	If an EEventKey event is associated with an EEventKeyUp event (which is

 	rarely the case), the EEventKey event occurs after the EEventKeyUp event. */

 	EEventKeyUp,

 	/** Key down event.

 	If an EEventKey event is associated with an EEventKeyDown event (which

 	is typically the case), the EEventKey event occurs after the EEventKeyDown event. */

 	EEventKeyDown,

 	/** Modifier changed event.

 	This is an event generated by the window server when

 	the state of one of the modifier keys changes.

 	It is not reported unless explicitly requested by a window.

 	@see RWindowTreeNode::EnableModifierChangedEvents(). */

 	EEventModifiersChanged,

 	/** Pointer event.

 	This event is sent when the user presses or releases a pointer button (or

 	the equivalent action, depending on the type of pointing device), drags the

 	pointer, moves it or uses the pointer to switch on the device. */

 	EEventPointer,			//5

 	/** Pointer enter event.

 	This occurs when the user moves the pointer into a window with a pointer button

 	pressed (or equivalent action depending on the type of pointing device). If

 	move events are being generated, this event also occurs when the user moves

 	the pointer into the window. */

 	EEventPointerEnter,

 	/** Pointer exit event.

 	Occurs when the user moves the pointer out of a window with a pointer button

 	pressed (or equivalent action depending on the type of pointing device). If

 	move events are being generated, this event also occurs when the user moves

 	the pointer out of the window. */

 	EEventPointerExit,

 	/** Pointer move buffer ready event.

 	Occurs when the pointer move buffer is ready to be retrieved by the client. */

 	EEventPointerBufferReady,

 	/** Occurs as a duplicate of each pointer event if a window sets pointer capture

 	with the TCaptureFlagDragDrop flag set. */

 	EEventDragDrop,

 	/** Focus lost event.

 	Occurs when a window group loses keyboard focus. */

 	EEventFocusLost,		//10

 	/** Focus gained event.

 	Occurs when a window group gains keyboard focus. */

 	EEventFocusGained,

 	/** On event.

 	This event type is not reported unless explicitly requested by a window.

 	@see RWindowTreeNode::EnableOnEvents(). */

 	EEventSwitchOn,

 	/** Password event.

 	Occurs when the window server enters password mode. It is sent to the group

 	window of the currently active password window.

 	This is the window server mode where the user is required to enter a password

 	before any further actions can be performed.

 	@deprecated	*/

 	EEventPassword,

 	/** Window group changed event. This occurs whenever a window group is destroyed,

 	and whenever a window group's name changes

 	This event type is not reported unless explicitly requested by a window.

 	@see RWindowTreeNode::EnableGroupChangeEvents(). */

 	EEventWindowGroupsChanged,

 	/** Error event.

 	Occurs when an error occurs. See TWsErrorMessage::TErrorCategory for the types

 	of errors.

 	This event type is not reported unless explicitly requested by a window.

 	@see RWindowTreeNode::EnableErrorMessages(). */

 	EEventErrorMessage,		//15

 	/** Message ready event.

 	Occurs when a session sends a message to this window group using RWsSession::SendMessageToWindowGroup(). */

 	EEventMessageReady,

 	EEventMarkInvalid,	// For internal use only

 	/** Off event.

 	This is issued when an off event is received by the window server from the

 	base.

 	If for some reason the event can't be delivered, or there is no-one to deliver

 	it to, then a call to the base is made to power down the processor.

 	This event is only delivered if explicitly requested using RWsSession:RequestOffEvent(). */

 	EEventSwitchOff,

 	/** Event issued to off-event requesting windows when the off key is pressed. */

 	EEventKeySwitchOff,

 	/** Screen size mode change event.

 	This is issued when the screen size mode has changed, for instance when

 	the cover on a phone that supports screen flipping is opened or closed. */

 	EEventScreenDeviceChanged, //20

 	/** Event sent whenever the window group with focus changes.

 	Requested by RWindowTreeNode::EnableFocusChangeEvents(). */

 	EEventFocusGroupChanged,

 	/** Case opened event.

 	This event is sent to those windows that have requested EEventSwitchOn

 	events. Unlike with EEventSwitchOn events, the screen will not be switched

 	on first. */

 	EEventCaseOpened,

 	/** Case closed event.

 	This event is sent to those windows that have requested EEventSwitchOff

 	events.

 	Unlike EEventSwitchOff events, which make a call to the base to power down

 	the processor if for some reason the event can't be delivered (or there is

 	no-one to deliver it to), failure to deliver case closed events has no repercussions. */

 	EEventCaseClosed,

 	/** Window group list change event.

 	The window group list is a list of all window groups and their z-order. This

 	event indicates any change in the window group list: additions, removals and

 	reorderings.

 	Notification of this event is requested by calling RWindowTreeNode::EnableGroupListChangeEvents(). */

 	EEventWindowGroupListChanged,

 	/** The visibility of a window has changed

 	This is sent to windows when they change from visible to invisible, or visa versa, usually due

 	to another window obscuring them.

 	Notification of this event is requested by calling RWindowTreeNode::EnableVisibilityChangeEvents(). */

 	EEventWindowVisibilityChanged,

 #ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

 	/** Restart event.

 	This is issued when an restart event is received by the window server from the 

 	base. This event is also an off event, because it might power-cycle the device.

 	If for some reason the event can't be delivered, or there is no-one to deliver 

 	it to, then a call to the base is made to power down the processor.

 	This event is only delivered if explicitly requested using RWsSession:RequestOffEvent(). */

 	EEventRestartSystem,

 #endif

 	/** The display state or configuration has changed

 	Either change of the current resolution list (state change) or current resolution/background

 	(mode change) will trigger this event.

 	Notification of this event is requested by calling MDisplayControl::EnableDisplayChangeEvents() 

 	 */

 	EEventDisplayChanged = EEventWindowVisibilityChanged+2,

 	//Codes for events only passed into Key Click DLL's

 	/** Repeating key event.

 	This is only sent to a key click plug-in DLL (if one is present) to indicate

 	a repeating key event.

 	@see CClickMaker */

 	EEventKeyRepeat=100,

 	EEventGroupWindowOpen,

 	EEventGroupWindowClose,

 	EEventWindowClose,

 	//Codes for events only passed into anim dlls

 	/** Direct screen access begin

 	This is only sent to anim dlls (if they register to be notified). It indicates that

 	the number of direct screen access sessions has increased from zero to one.*/

 	EEventDirectScreenAccessBegin=200,

 	/** Direct screen access end

 	This is only sent to anim dlls (if they register to be notified). It indicates that

 	the number of direct screen access sessions has decreased from one to zero.*/

 	EEventDirectScreenAccessEnd,

 	/** Event to signal the starting or stopping of the wserv heartbeat timer

 	This is only sent to anim dlls (if they register to be notified). */

 	EEventHeartbeatTimerStateChange,

 	//The range 900-999 is reserved for UI Framework events

 	/** 900-909 WSERV protects with PowerMgmt */

 	EEventPowerMgmt = 900,

 	EEventReserved = 910,

 	//Event codes from EEventUser upwards may be used for non-wserv events.

 	//No event codes below this should be defined except by the window server

 	/** User defined event.

 	The client can use this and all higher values to define their own

 	events. These events can be sent between windows of the same client or windows

 	of different clients.

 	@see RWs::SendEventToWindowGroup(). */

 	EEventUser=1000,

 	};

 /** Window server hot keys.

 @publishedAll

 @released

 @see RWsSession::SetHotKey() */

 enum THotKey

 	{

 	/** Enables logging of all messages to and from the window server.

 	Note that the required type of logging must have been specified in the wsini.ini

 	file (using the LOG keyword), and the appropriate logging DLL must be available.

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\>E */

 	EHotKeyEnableLogging,

 	/** Always disables window server logging, if active. Does nothing otherwise.

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\>D */

 	EHotKeyDisableLogging,

 	/** Dumps a list of all windows to the log. (If logging is disabled, it is temporarily

 	enabled in order to do this.)

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\>W */

 	EHotKeyStateDump,

 	/** Kills the foreground application.

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\>K */

 	EHotKeyOfDeath,

 	/** Shuts down the window server.

 	Be cautious! This may mean resetting the machine to re-start the window server.

 	Default key mapping: release (not available), debug (\<Ctrl\>\<Alt\>\<Shift\>X). */

 	EHotKeyShutDown,

 	/** Dumps a list of cells allocated on the window server's heap to the log. (If

 	logging is disabled, it is temporarily enabled in order to do this.)

 	Note that logging requires that the type of logging has been set up in the

 	wsini.ini file, and that the appropriate logging DLL is available.

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\>H */

 	EHotKeyHeapDump,

 	/** Increases the LCD contrast.

 	Default key mapping: EKeyIncContrast. Note that this value is from an enum

 	in e32keys.h. The contrast wraps around when it reaches the maximum. */

 	EHotKeyIncContrast,

 	/** Decreases the LCD contrast.

 	Default key mapping: EKeyDecContrast. Note that this value is from an enum

 	in e32keys.h. The contrast wraps around when it reaches the minimum. */

 	EHotKeyDecContrast,

 	/** Switches the machine off.

 	Default key mapping: EKeyOff. Note that this value is from an enum in e32keys.h. */

 	EHotKeyOff,

 	/** Switches the backlight on.

 	Default key mapping: EKeyBacklightOn. Note that this value is from an enum

 	in e32keys.h. */

 	EHotKeyBacklightOn,

 	/** Switches the backlight off.

 	Default key mapping: EKeyBacklightOff. Note that this value is from an enum

 	in e32keys.h. */

 	EHotKeyBacklightOff,

 	/** Toggles the backlight.

 	Default key mapping: EKeyBacklightToggle. Note that this value is from an

 	enum in e32keys.h. */

 	EHotKeyBacklightToggle,

 	/** Switches to screen size 0.

 	This, and the following 3 keys are used to switch screen sizes on real hardware,

 	for instance when the cover is closed on a phone that supports screen flipping. */

 	EHotKeyScreenDimension0,

 	/** Switches to screen size 1.

 	This might be generated when the cover is opened on a phone that supports screen

 	flipping. */

 	EHotKeyScreenDimension1,

 	/** Switches to screen size 2. */

 	EHotKeyScreenDimension2,

 	/** Switches to screen size 3. */

 	EHotKeyScreenDimension3,

 	/** Cycles the display though its possible sizes.

 	This is used only for debugging.

 	A device may have several screen sizes, each with a default orientation. For

 	example a phone that supports screen flipping will have different display

 	sizes when the cover is opened and closed.

 	Default key mapping: debug : \<Ctrl\>\<Alt\>\<Shift\> U. Release : none. */

 	EHotKeyCycleDisplaySize,

 	/** Cycles the screen orientation through the specified rotations for the particular

 	size mode you are in.

 	For example, phones that support screen flipping may

 	use this feature for changing between right and left handed use.

 	For rectangular display modes you can only specify 2 orientations, 180 degrees

 	apart. For square modes you can specify 4 rotations (90 degrees) or however

 	many you want.

 	Specification of the list of rotations takes place in the WSINI.INI file.

 	Default key mapping: debug : \<Ctrl\>\<Alt\>\<Shift\> O. Release : none. */

 	EHotKeyCycleOrientation,

 	/** Increases the screen's brightness.

 	The brightness wraps around to the minimum

 	value after it has reached the maximum. */

 	EHotKeyIncBrightness,

 	/** Decreases the screen's brightness.

 	The brightness wraps around to the maximum value after it has reached the minimum. */

 	EHotKeyDecBrightness,

 	/** Cycle focus screen from one to another in multiple screen environment. Start

 	from current focused screen, switch to next the screen, and wraps around when it

 	reaches the last screen.

 	Default key mapping: \<Ctrl\>\<Alt\>\<Shift\> I. */

 	EHotKeyCycleFocusScreen,

 	/** Value for first hot key.

 	Used with EHotKeyLastKeyType to make it easy to write a for loop that steps

 	through all the different key values. */

 	EHotKeyFirstKeyType=EHotKeyEnableLogging,		//Must always be set to the first one

 	/** Value for last hot key.

 	Used with EHotKeyFirstKeyType to make it easy to write a for loop that steps

 	through all the different key values. */

 	EHotKeyLastKeyType=EHotKeyCycleFocusScreen,		//Must always be set to the last one

 	};

 /** Password mode flags.

 @publishedAll

 @deprecated */

 enum TPasswordMode

 	{

 	/** Releases ownership of password handling.

 	This allows another window to become the password window. A client will be

 	panicked with code 46 if it sets this mode when it is not the current password

 	window. */

 	EPasswordCancel,

 	/** No password handling is performed by this window, but no other window

 	can become the password window. */

 	EPasswordNone,

 	/** Password mode is enabled only once a day.

 	When enabled, password mode requires the user to enter a password

 	before any further actions can be performed. */

 	EPasswordOnceADay,

 	/** Password mode is enabled every time the machine is switched on. */

 	EPasswordAlways,

 	/** Equivalent to setting the password mode to EPasswordAlways and triggering an

 	instant password check. */

 	EPasswordAlwaysTriggerNow,

 	/** Equivalent to setting the password mode to EPasswordOnceADay and triggering

 	an instant password check. */

 	EPasswordOnceADayTriggerNow,

 	};

 enum TPriorities {

            /**

            Defines the value EAllPriorities.

            */

            EAllPriorities=KMinTInt,

            };

 /** Sprite flags.

 These can be combined using a bit-wise OR operation.

 @publishedAll

 @released

 @see RWsPointerCursor::Construct()

 @see RWsSprite::Construct() */

 enum TSpriteFlags

 	{

 	/** Flash sprite on and off.

 	All flashing is done on the same timer, including the text cursor. */

 	ESpriteFlash=0x1,

 	/** This flag no longer has any effect.

 	If you want a sprite to appear on top of all windows, you can create a floating sprite

 	by specifying a RWindowGroup as parent to the sprite.  */

 	ESpriteNoChildClip=0x2,

 	/** The sprite's appearance will not change when it is on a shadowed part of the

 	screen.

 	(Typically this is used for sprites attached to window groups so that

 	they are perceived to be floating above the windows). */

 	ESpriteNoShadows=0x4

 	};

 struct TSpriteMember

 /** Sprite member.

 This structure is used to define the parameters of a sprite member, which

 can be added to a sprite or pointer cursor.

 @publishedAll

 @released */

 	{

 	/** The bitmap to be displayed in the sprite or pointer cursor during the time

 	interval specified by iInterval.

 	If NULL, the sprite or pointer cursor will be invisible for the time specified

 	by iInterval. */

 	CFbsBitmap *iBitmap;

 	/** The bitmap mask.

 	This defines which areas of iBitmap are drawn to the screen.

 	It enables the bitmap to have a non-rectangular shape on the screen. Areas

 	which are not drawn to, retain the appearance of the window underneath the

 	sprite or cursor.

 	The bits in iBitmap are AND'ed with those in iMaskBitmap before being drawn

 	to the screen. In practice, the mask bitmap is normally white in those areas

 	drawn to by iBitmap, and black in all other areas.

 	Note:

 	This bitmap should be in the same mode as iBitmap, otherwise the masking

 	out operation becomes inefficient. */

 	CFbsBitmap *iMaskBitmap;

 	/** EFalse if the mask bitmap is not to be inverted (the default) or ETrue if it

 	is to be inverted. */

 	TBool iInvertMask;

 	/** Specifies the drawing mode to use when drawing iBitmap if the mask is NULL. */

 	CGraphicsContext::TDrawMode iDrawMode;

 	/** Offset from the sprite's central position.

 	Specifies an offset between the origin of iBitmap and the sprite or pointer

 	cursor's origin. (The origin is the top left corner of the bitmap.) */

 	TPoint iOffset;

 	/** Time interval for which iBitmap is displayed.

 	Note that if only one sprite member is added to a sprite or pointer cursor,

 	it will be displayed continuously, regardless of the value of iInterval. */

 	TTimeIntervalMicroSeconds32 iInterval;

 	};

 /** Event reporting control.

 This enumeration defines flags which can be used to control how events are

 reported.

 @publishedAll

 @released

 @see RWindowTreeNode::EnableOnEvents()

 @see RWindowTreeNode::EnableModifierChangedEvents()

 @see RWindowTreeNode::EnableErrorMessages() */

 enum TEventControl

 	{

 	/** Requested events are sent in all circumstances. */

 	EEventControlAlways,

 	/** Events are delivered only when the requesting window's window group has keyboard

 	focus. */

 	EEventControlOnlyWithKeyboardFocus,

 	/** Events are delivered only when the requesting window or any of its children

 	are visible on the screen. */

 	EEventControlOnlyWhenVisible

 	};

 /** Pointer event filter types.

 These flags are used by RWindowBase::PointerFilter() to define which pointer

 events are filtered out by the window server and not sent to the client session.

 They also allow the window server to simulate a move event prior to each pen

 down event.

 @publishedAll

 @released

 @see RWindowBase::PointerFilter() */

 enum TPointerFilter

 	{

 	//Basic Types

 	/** Filters out both pointer enter and pointer exit events for this window. */

 	EPointerFilterEnterExit=0x1,

 	/** Filters out pointer-move events for this window. */

 	EPointerFilterMove=0x2,

 	/** Filters out pointer-drag events for this window. */

 	EPointerFilterDrag=0x4,

 	/** Simulates a pointer move event before each pen down event.

 	This makes the pen appear more like a mouse, with simulated movement between

 	two pointer events. You can only get these events while you are in pen mode. */

 	EPointerGenerateSimulatedMove=0x8,

 	//Combinations of the above

 	/** Filters move and drag-pointer events from the event stream and simulates the

 	move event before each pen down event.

 	This enum is useful when you want to get simulated move events. Use it as shown

 	below to turn on simulated moves:

 	@code

 	win->PointerFilter(EPointerMoveEvents, EPointerGenerateSimulateMoves)

 	@endcode

 	@see RWindowBase::PointerFilter() */

 	EPointerMoveEvents=EPointerFilterMove|EPointerGenerateSimulatedMove,

 	};

 struct TKeyEvent

 /** Key event details.

 When processing a TKeyEvent, the TStdScanCode in iScanCode should usually

 be ignored in favour of the TKeyCode in iCode. Using iScanCode would bypass

 the keyboard mapping and any FEP that happens to be installed. The exceptions

 to this general rule are games where the positions of the keys are more important

 than their translations, and FEPs that are implementing keyboard maps themselves.

 In these cases, if the iCode is used rather than iScanCode to determine the

 key pressed, there will be two unfortunate consequences. Firstly, the low-level

 keyboard mapping might re-arrange the mapping that you are trying to impose.

 Secondly, you will subvert the CTRL+number method of entering Unicode literals.

 @publishedAll

 @released */

 	{

 	/** The character code generated for an EEventKey, or 0 for a down or up event.

 	Key codes for special keys are defined in TKeyCode. */

 	TUint iCode;

 	/** The scan code of the key that caused the event.

 	Standard scan codes are defined in TStdScanCode. */

 	TInt iScanCode;

 	/** State of modifier keys and pointing device. Modifier keys are defined in TEventModifier. */

 	TUint iModifiers;

 	/** Count of auto repeats generated.

 	0 means an event without repeats. 1 or more means "this many auto repeat events".

 	It is normal to ignore this value and treat it as a single event. */

 	TInt iRepeats;

 	};

 struct TModifiersChangedEvent

 /** Details of changed modifier keys.

 @publishedAll

 @released

 @see TWsEvent::ModifiersChanged() */

 	{

 	/** Contains a set bit for any modifier which has changed. Modifiers are defined

 	in TEventModifier. */

 	TUint iChangedModifiers;

 	/** Current state of all modifiers, combined using a bitwise-OR. Modifiers are

 	defined in TEventModifier. */

 	TUint iModifiers;

 	};

 struct TWsVisibilityChangedEvent

 /** Visibility changed events.

 These events are generated in response to a window being obscured, or being fully or partially

 revealed after being obscured.

 @publishedAll

 @released

 @see RWindowTreeNode::EnableVisibilityChangeEvents() */

 		{

 	enum

 		{

 		/** Some or all of the window is visible, either directly or through a transparent window.

 		@deprecated Use EPartiallyVisible instead. */

 		ECanBeSeen = 0x01,

 		/** None of the window is visible, either directly or through a transparent window.

 		@deprecated Use ENotVisible instead. */

 		ECantBeSeen = 0x02,

 		};

 	enum

 		{

 		/** Some (or all) of the window is visible, either directly or through a transparent window. */

 		EPartiallyVisible = 0x01,

 		/** None of the window is visible, either directly or through a transparent window. */

 		ENotVisible = 0x02,

 		/** All of the window is directly visible. */

 		EFullyVisible = 0x04,

 		};

 	/** A combination of one or more visibility event flags. */

 	TUint iFlags;

 	};

 struct TWsDisplayChangedEvent

 /** Display changed events.

 These events are generated by attaching, detaching the display device, changing the resolution list or change

 current resolution or backgound (change the current configuration).

 @publishedAll

 @released

 @see MDisplayControl::EnableDisplayChangeEvents() */

 	{

 	/**

 	 Number of display that has changed, causing this event. This is

 	 also known as the screen number, and is zero-based.

 	 @see CWsScreenDevice::Construct(TInt)

 	 */

 	TInt iDisplayNumber;

 	/**

 	 Opaque value that changes when the current display configuration

 	 has changed.

 	 Compare values in subsequent events to determine whether the

 	 current resolution has changed since the last event.

 	 */

 	TInt iConfigurationChangeId;

 	/**

 	 Opaque value that changes when the resolution list has changed.

 	 Compare values in subsequent events to determine whether the list

 	 of available resolutions has changed since the last event.

 	 @see MDisplayControlBase::GetResolutions

 	 */

 	TInt iResolutionListChangeId;	

 	};

 struct TWsErrorMessage

 /** Error event details.

 @publishedAll

 @released

 @see RWindowTreeNode::EnableErrorMessages() */

 	{

 	/** Error event types */

 	enum TErrorCategory

 		{

 		/** An error that occurs while the window server is calculating a drawing region

 		for a particular window.

 		When the window server can't calculate a drawing region due to lack of memory

 		it goes into a mode where it draws the whole of a window. Any window that

 		is covering this window is also told to redraw. */

 		EDrawingRegion,

 		/** An error occured while trying to turn the backlight on or off.

 		This would usually only happen when the batteries are low. */

 		EBackLight,

 		/** An error occured while trying to enable logging. */

 		ELogging,

 		/** An error that occured while trying to change the contrast. */

 		EContrast,

 		};

 	/** The error category. */

 	TErrorCategory iErrorCategory;

 	/** The error code */

 	TUint iError;

 	};

 class TWsRedrawEvent

 /** Window server redraw event.

 All redraw events generated by the window server are delivered to the client

 in an object of this type. The class provides a handle to the window which

 generated the redraw event, and the rectangle which should be redrawn.

 @publishedAll

 @released

 @see RWsSession::GetRedraw() */

 	{

 public:

 	inline TUint Handle() const;

 	inline TRect Rect() const;

 public:

 	void SetHandle(TUint aHandle);

 	void SetRect(TRect aRect);

 protected:

 	TUint iHandle;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	TRect iRect;	/**< Rectangle to redraw.  WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	};

 class TWsPriorityKeyEvent

 /** Priority key events.

 These events are configured using RWindowGroup::AddPriorityKey(), and obtained

 by the client using the functions RWsSession::PriorityKeyReady() and RWsSession::GetPriorityKey().

 @publishedAll

 @released */

 	{

 public:

 	inline TKeyEvent *Key() const;

 	inline TUint Handle() const;

 	inline void SetHandle(TUint aHandle);

 protected:

 	TUint iHandle;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	TUint8 iEventData[sizeof(TKeyEvent)];	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	};

 class TWsEvent

 /** Window server event.

 All events generated by the window server, except redraw events and priority

 key events, are delivered to the client in a TWsEvent. The client obtains

 the TWsEvent by calling RWsSession::GetEvent(). The type of data contained

 in the TWsEvent depends on the type of event. The client can inquire the event

 type using Type(), and then retrieve the appropriate type of data.

 @publishedAll

 @released */

 	{

 public:

 	/** Event data size. */

 	enum

 		{

 		/**

 		This is the maximum number of bytes of data that can be returned by EventData().

 		Note: this value is 32 bytes.*/

 		EWsEventDataSize=sizeof(TAdvancedPointerEvent)

 		};

 public:

 	inline TWsEvent();

 	inline TAdvancedPointerEvent* Pointer() const;

 	inline TKeyEvent* Key() const;

 	inline TModifiersChangedEvent* ModifiersChanged() const;

 	inline TWsVisibilityChangedEvent* VisibilityChanged();

 	inline const TWsVisibilityChangedEvent* VisibilityChanged() const;

 	inline TWsDisplayChangedEvent* DisplayChanged();

 	inline const TWsDisplayChangedEvent* DisplayChanged() const;

 	inline TWsErrorMessage* ErrorMessage() const;

 	inline TUint8* EventData() const;

 	inline TInt Type() const;

 	inline TUint Handle() const;

 	inline TTime Time() const;

 	inline void SetType(TInt aType);

 	inline void SetHandle(TUint aHandle);

 	inline void SetTimeNow();

 	inline TInt* Int() const;

 	IMPORT_C void InitAdvancedPointerEvent(TPointerEvent::TType aType, TUint aModifiers, const TPoint3D &aPoint3D, TUint8 aPointerNumber);

 	IMPORT_C void SetPointerNumber(TUint8 aPointerNumber);

 	IMPORT_C void SetPointerZ(TInt aZ);

 protected:

 	TInt iType;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	TUint iHandle;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	TTime iTime;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	TUint8 iEventData[EWsEventDataSize];	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */	

 	};

 class RWsPointerCursor;

 /** Pointer cursor mode flags.

 These flags define the current cursor mode, and hence which sprite to use

 for the pointer cursor.

 @publishedAll

 @released

 @see RWsSession::SetPointerCursorMode()

 @see RWsSession::PointerCursorMode() */

 enum TPointerCursorMode

 	{

 	/** Don't have a pointer cursor. */

 	EPointerCursorNone,

 	/** The default system pointer cursor is used whenever there is a pointer cursor. */

 	EPointerCursorFixed,

 	/** The default system pointer cursor is used unless the window the pointer cursor

 	is above specifies one, in which case that cursor is used. */

 	EPointerCursorNormal,

 	/** There is no pointer cursor unless the pointer is above a window that has specified

 	one. */

 	EPointerCursorWindow,

 	/** First pointer cursor mode.

 	This is used in test code for iterating though available modes. */

 	EPointerCursorFirstMode=EPointerCursorNone,

 	/** The final pointer cursor mode.

 	This is used in test code for iterating though available modes. It will be

 	updated if more modes are added. */

 	EPointerCursorLastMode=EPointerCursorWindow,

 	};

 /** Flags which customise a long key press capture request made by a window group.

 These flags are passed to RWindowGroup::CaptureLongKey().

 Two things can be configured using this enum: the normal key event that is

 generated immediately, and the long key event that is generated after a short

 time interval. The normal key event can be sent immediately (on key down)

 to the application with keyboard focus, or, if the key is not held down long

 enough to generate a long key event, when the key is released. The long key

 event can be customised to generate a single key event only, or to auto repeat.

 @publishedAll

 @released

 @see RWindowGroup::CaptureLongKey() */

 enum TLongCaptureFlags

 	{

 	/** If specified, the normal ("short") key event is sent immediately (on key down)

 	to the application with keyboard focus. If not specified, the normal key event

 	is sent when the key is released (if the key is not held down long enough

 	to generate a long key event). */

 	ELongCaptureShortEventImmediately=0x01,

 	/** If specified, causes the long key press to automatically repeat. If not specified,

 	the long key press will generate a single key event only. */

 	ELongCaptureRepeatEvents=0x02,

 	/** Equivalent to ELongCaptureShortEventImmediately being set and the other flags

 	unset. */

 	ELongCaptureNormal=ELongCaptureShortEventImmediately,

 	/** Equivalent to the first two values being unset. */

 	ELongCaptureWaitShort=0,

 	};

 class TIpcArgs;

 class TReadDescriptorType;

 class TWriteDescriptorType;

 class CWindowGc;

 class RWsSession;

 class TWsGraphicId

 /** Identifies an abstract artwork

 This is a piece of artwork that might be owned and authored by another process.

 A client can draw a piece of artwork, but that doesn't confer the ability to

 access the pixel representation of that artwork directly.

 @publishedAll

 @released */

 	{

 public:

 	enum TUninitialized

 		{

 		EUninitialized

 		};

 	TWsGraphicId(TUninitialized): iFlags(0) {}

 	IMPORT_C TWsGraphicId(TUid aUid);

 	IMPORT_C TWsGraphicId(TInt aId);

 	IMPORT_C TWsGraphicId(const TWsGraphicId& aCopy);

 	IMPORT_C TUid Uid() const;

 	IMPORT_C TBool IsUid() const;

 	IMPORT_C void Set(TUid aUid);

 	IMPORT_C TInt Id() const;

 	IMPORT_C TBool IsId() const;

 	IMPORT_C void Set(TInt aId);

 	IMPORT_C TInt Compare(const TWsGraphicId& aOther) const;

 private:

 	friend class CWsGraphic;

 	TUint iFlags;

 	TInt iId;

 	TInt iWsGraphicIdSpare[2];

 	};

 class CWsGraphic: public CBase

 /** Client representation of a window-server-side piece of artwork owned by this Client

 @publishedAll

 @released

 */

 	{

 protected:

 	IMPORT_C CWsGraphic();

 public:

 	IMPORT_C ~CWsGraphic();

 protected:

 	// 2nd phase construction

 	IMPORT_C void BaseConstructL(TUid aUid,TUid aType,const TDesC8& aData);

 	IMPORT_C void BaseConstructL(TUid aType,const TDesC8& aData);

 	IMPORT_C void BaseConstructL(const TWsGraphicId& aReplace,TUid aType,const TDesC8& aData);

 	// sharing between clients

 	IMPORT_C virtual TInt ShareGlobally();

 	IMPORT_C virtual TInt Share(TSecureId aClientId);

 	IMPORT_C virtual TInt UnShare(TSecureId aClientId);

 	IMPORT_C virtual TInt UnShareGlobally();

 public:

 	IMPORT_C const TWsGraphicId& Id() const;

 	IMPORT_C TBool IsActive() const;

 	IMPORT_C void Destroy();

 protected:

 	IMPORT_C void SendMessage(const TDesC8& aData) const;

 	IMPORT_C TInt SendSynchronMessage(const TDesC8& aData) const;

 	IMPORT_C TInt Flush() const;

 	IMPORT_C void SetGraphicExtension(MWsObjectProvider* aExt);

 	IMPORT_C RWsSession& Session();

 private:

 	// events from wserv, to be implemented by derived classes

 	/**

 	Handles message from this graphic artwork peer on the server.

 	@param aData Message from peer CWsGraphicDrawer.

 	*/

 	virtual void HandleMessage(const TDesC8& aData) = 0;

 	/**

 	Handles custom operation when this graphic artwork is replaced. When this method

 	is invoked, the replaced peer CWsGraphicDrawer on the server has been destroyed.	

 	*/

 	virtual void OnReplace() = 0;

 	IMPORT_C virtual void OnClientClose();

 private:

 	void BaseConstructL();

 	IMPORT_C virtual TInt CWsGraphic_Reserved1();

 	IMPORT_C virtual TInt CWsGraphic_Reserved2();

 	IMPORT_C virtual TInt CWsGraphic_Reserved3();

 public:

 	class CManager;

 private:

 	friend class CManager;

 	class CPimpl;

 	friend class CPimpl;

 	CPimpl* iPimpl;

 	TInt iWsGraphicSpare[2];

 };

 class MWsClientClass

 /** Base class for all classes whose objects are clients of the window server.

 @publishedAll

 @released */

 	{

 public:

 	MWsClientClass();

 	MWsClientClass(RWsBuffer *aBuffer);

 	inline TInt WsHandle() const;

 protected:

 	void Write(const TAny *aData, TInt aLength,const TAny *aData2, TInt aLength2,TUint aOpcode) const;

 	void Write(const TAny *aBuf, TInt aBufLen,TUint aOpcode) const;

 	void Write(TUint aOpcode) const;

 	void WriteInt(TInt aInt, TUint aOpcode) const;

 	void WriteRect(const TRect &aRect, TUint aOpcode) const;

 	void WritePoint(const TPoint &aPoint, TUint aOpcode) const;

 	void WriteSize(const TSize &aSize, TUint aOpcode) const;

 	TInt WriteReply(TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;

 	TInt WriteReplyInt(TInt aInt, TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;

 	TInt WriteReply(const TAny *aBuf, TInt aBufLen,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;

 	TInt WriteReply(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;

 	TInt WriteReplyP(const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;

 	TInt WriteReplyIntP(TInt aInt, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;

 	TInt WriteReplyP(const TAny *aBuf, TInt aBufLen, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;

 	TInt WriteReplyP(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;

 	TInt WriteReplyByProvidingRemoteReadAccess(const TAny* aBuf, TInt aBufLen,const TReadDescriptorType& aRemoteReadBuffer,TUint aOpcode) const;

 	void AddToBitmapArray(const TInt aBitmapHandle)const;

 	void AsyncRequest(TRequestStatus& aStatus, TUint aOpcode) const;

     TBool WindowSizeCacheEnabled() const;

     void MarkWindowSizeCacheDirty();

     void RefreshWindowSizeCache(const TSize& aNewSize) const;

     TInt CachedWindowSize(TSize& aSize) const;

     void DestroyWindowSizeCacheEntry();

 protected:

 	TInt32 iWsHandle;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	RWsBuffer *iBuffer;	/**< WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. */

 	};

 class RWindowTreeNode;

 class CWsScreenDevice;

 class CWsBitmap;

 class RAnimDll;

 class RWsSpriteBase;

 class RDirectScreenAccess;

 class RSoundPlugIn;

 class RWsSession : public MWsClientClass, public RSessionBase

 /** Window server session.

 The session between the client and the window server can be used to mediate

 asynchronous events, for client interface control and for system control.

 A description of each of these capabilities is given below.

 Mediating asynchronous events:

 Primarily, the session mediates asynchronous events to the user. Three event

 streams are available: the standard event stream which all applications must

 use; the redraw event stream which must be used by all applications except

 those which exclusively use backed-up windows; and the priority key event

 stream which may be used for abort keys and the like for specialist applications.

 All these events are mediated as standard asynchronous services. Typical window

 server client programs encapsulate each service they require in an active

 object whose RunL() identifies the event and calls the appropriate member

 function of a class associated with an application framework, or a window.

 Client interface control:

 The client's interface with the window server has several aspects, each of

 which is controlled through the window server session.

 Flushing defines how requests to the window server are handled.

 System control:

 Many system-wide settings may be controlled through the window server session.

 Typically, these functions are only used by the system shell and its associated

 sessions/applications. They include: auto-repeat and double-click, querying

 all window groups in the system, setting the default shadow vector, setting

 the system pointer cursors, counting resources used by the window server

 (this is only useful for debugging checks), getting and setting the state of

 the modifier keys (for instance Shift and Ctrl), setting the window server

 background colour, getting and setting thresholds for window server generated

 pointer events.

 @publishedAll

 @released */

 	{

 	friend class RWsBuffer;

 	friend class RWindowTreeNode;

 	friend class CWsScreenDevice;

 	friend class CWsBitmap;

 	friend class RAnimDll;

 	friend class RWsSpriteBase;

 	friend class RDirectScreenAccess;

 	friend class RSoundPlugIn;

 	friend class CWsGraphic;

 	friend class RWsDrawableSource;

 public:

 	/** Compute mode flags.

 	When a window group takes focus or loses it, the window server can boost its

 	client's thread or process priority to provide a better response to the user.

 	How it alters the priority is determined by the current compute mode of the

 	client.

 	@see ComputeMode() */

 	enum TComputeMode

 		{

 		/** Client priority is permanently set to its current level. It is not altered

 		or set by the windowing system if the focus changes.

 		Thus if ComputeMode() is called with this flag when a client is in the foreground,

 		it will subsequently have foreground priority even if it is in the background. */

 		EPriorityControlDisabled,

 		/** Client process's priority is always set to EPriorityBackground. */

 		EPriorityControlComputeOn,

 		/** Client process's priority is set to EPriorityForeground when the window group

 		takes focus, and set to EPriorityBackground when it loses focus.

 		This is the default behaviour. */

 		EPriorityControlComputeOff

 		};

 	enum {ESystemInfoArraySize=16};

 	/** Window server logging commands passed to LogCommand().

 	@see RWsSession::LogCommand() */

 	enum TLoggingCommand

 		{

 		/** Enables logging. */

 		ELoggingEnable,

 		/** Disables logging. */

 		ELoggingDisable,

 		/** Logs the current status of all the windows in the tree, even if logging is

 		not currently enabled. */

 		ELoggingStatusDump,		//Window Tree Dump

 		/** Logs information about the window server's heap size and usage, even if logging

 		is not currently enabled. */

 		ELoggingHeapDump,

 		};

 	struct TWindowGroupChainInfo

 		{

 		/*Stores id and Parent id window group

 		This is used to define chained window groups's id and it's parent id.

 		An array of these structures is returned by some of the varients of the function WindowGroupList.

 		@publishedAll

 		@released */

 		TInt iId;

 		TInt iParentId;

 		};

 	struct SSystemInfo

 	/** WARNING: Struct for internal use ONLY.  Compatibility is not guaranteed in future releases. */ 

 		{

 		TInt iInfo[ESystemInfoArraySize];

 		};

 	/** The vertical alignment of a custom text cursor sprite.

 	One of these values must be set, see SetCustomTextCursor(). This value also

 	determines which part of each sprite member bitmap is clipped when the cursor's

 	TTextCursor::EFlagClipVertical flag is set. */

 	enum TCustomTextCursorAlignment

 		{

 		/** The y-origin of each sprite member bitmap is aligned with the top of the line. */

 		ECustomTextCursorAlignTop,

 		/** The y-origin of each sprite member bitmap is aligned with the baseline of the

 		line. */

 		ECustomTextCursorAlignBaseline,

 		/** The y-origin of each sprite member bitmap is aligned with the bottom of the

 		line. */

 		ECustomTextCursorAlignBottom

 		};

 //

 public:

 	IMPORT_C RWsSession();

 	IMPORT_C TInt Connect();

 	IMPORT_C TInt Connect(RFs& aFileServer);

 	IMPORT_C void Close();

 	IMPORT_C TVersion Version() const;

 	IMPORT_C TInt SetHotKey(THotKey aType, TUint aKeyCode, TUint aModifierMask, TUint aModifier);

 	IMPORT_C TInt ClearHotKeys(THotKey aType);

 	IMPORT_C TInt RestoreDefaultHotKey(THotKey aType);

 //

 	IMPORT_C void EventReady(TRequestStatus *aStat);

 	IMPORT_C void EventReadyCancel();

 	IMPORT_C void GetEvent(TWsEvent &aEvent) const;

 	IMPORT_C void PurgePointerEvents();

 //

 	IMPORT_C void RedrawReady(TRequestStatus *aStat);

 	IMPORT_C void RedrawReadyCancel();

 	IMPORT_C void GetRedraw(TWsRedrawEvent &aEvent);

 //

 	IMPORT_C void PriorityKeyReady(TRequestStatus *aStat);

 	IMPORT_C void PriorityKeyReadyCancel();

 	IMPORT_C void GetPriorityKey(TWsPriorityKeyEvent &aEvent) const;

 //

 	IMPORT_C void Flush();

 	IMPORT_C TBool SetAutoFlush(TBool aState);

 	IMPORT_C TInt SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);

 	IMPORT_C void GetKeyboardRepeatRate(TTimeIntervalMicroSeconds32 &aInitialTime, TTimeIntervalMicroSeconds32 &aTime) const;

 	IMPORT_C void GetDoubleClickSettings(TTimeIntervalMicroSeconds32 &aInterval, TInt &aDistance) const;

 	IMPORT_C TInt SetDoubleClick(const TTimeIntervalMicroSeconds32 &aInterval, TInt aDistance);

 //

 	IMPORT_C TInt NumWindowGroups() const;

 	IMPORT_C TInt WindowGroupList(CArrayFixFlat<TInt> *aWindowList) const;

 	IMPORT_C TInt WindowGroupList(RArray<TWindowGroupChainInfo>* aWindowList) const;

 	IMPORT_C TInt NumWindowGroups(TInt aPriority) const;

 	IMPORT_C TInt WindowGroupList(TInt aPriority, CArrayFixFlat<TInt> *aWindowList) const;

 	IMPORT_C TInt WindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowList) const;

 	IMPORT_C TInt GetFocusWindowGroup() const;

 	IMPORT_C TInt GetDefaultOwningWindow() const;

 	IMPORT_C TInt SetWindowGroupOrdinalPosition(TInt aIdentifier, TInt aPosition);

 	IMPORT_C TInt GetWindowGroupClientThreadId(TInt aIdentifier, TThreadId &aThreadId) const;

 	IMPORT_C TInt GetWindowGroupHandle(TInt aIdentifier) const;

 	IMPORT_C TInt GetWindowGroupOrdinalPriority(TInt aIdentifier) const;

 	IMPORT_C TInt SendEventToWindowGroup(TInt aIdentifier, const TWsEvent &aEvent);

 	IMPORT_C TInt SendEventToAllWindowGroups(const TWsEvent &aEvent);

 	IMPORT_C TInt SendEventToAllWindowGroups(TInt aPriority, const TWsEvent &aEvent);

 	IMPORT_C TInt SendEventToOneWindowGroupsPerClient(const TWsEvent &aEvent);

 	IMPORT_C TInt GetWindowGroupNameFromIdentifier(TInt aIdentifier, TDes &aWindowName) const;

 	IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,const TDesC& aMatch,TInt aOffset=0) const;

 	IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,TThreadId aThreadId) const;

 	IMPORT_C TInt SendMessageToWindowGroup(TInt aIdentifier, TUid aUid, const TDesC8 &aParams);

 	IMPORT_C TInt SendMessageToAllWindowGroups(TUid aUid, const TDesC8& aParams);

 	IMPORT_C TInt SendMessageToAllWindowGroups(TInt aPriority, TUid aUid, const TDesC8& aParams);

 	IMPORT_C TInt FetchMessage(TUid &aUid, TPtr8 &aParams, const TWsEvent& aMessageEvent) const;

 //

 	IMPORT_C void SetShadowVector(const TPoint &aVector);

 	IMPORT_C TPoint ShadowVector() const;

 //

 	IMPORT_C void SetBackgroundColor(TRgb aColor);

 	IMPORT_C TRgb GetBackgroundColor() const;

 //

 	IMPORT_C TInt RegisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface);

 	IMPORT_C void UnregisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface);

 	IMPORT_C TInt PreferredSurfaceConfigurationSize() const;

 //

 	IMPORT_C TInt SetSystemPointerCursor(const RWsPointerCursor &aPointerCursor,TInt aCursorNumber);

 	IMPORT_C void ClearSystemPointerCursor(TInt aCursorNumber);

 	IMPORT_C TInt ClaimSystemPointerCursorList();

 	IMPORT_C void FreeSystemPointerCursorList();

 //

 	IMPORT_C TInt SetCustomTextCursor(TInt aIdentifier, const TArray<TSpriteMember>& aSpriteMemberArray, TUint aSpriteFlags, TCustomTextCursorAlignment aAlignment);

 //

 	IMPORT_C TInt ResourceCount() const;

 	IMPORT_C void PasswordEntered();

 	IMPORT_C void ComputeMode(TComputeMode aMode);

 //

 	IMPORT_C TInt HeapCount() const;

 	IMPORT_C TInt DebugInfo(TInt aFunction, TInt aParam=0) const;

 	IMPORT_C TInt DebugInfo(TInt aFunction, TDes8& aReturnBuf, TInt aParam=0) const;

 	IMPORT_C void HeapSetFail(TInt aTAllocFail,TInt aValue);

 	IMPORT_C void HeapSetBurstFail(TInt aTAllocFail,TInt aRate,TInt aBurst);

 	IMPORT_C TInt SetModifierState(TEventModifier aModifier,TModifierState aState);

 	IMPORT_C TInt GetModifierState() const;

 //

 	IMPORT_C TInt RequestOffEvents(TBool aOn,RWindowTreeNode *aWin=NULL);

 	IMPORT_C TDisplayMode GetDefModeMaxNumColors(TInt& aColor,TInt& aGray) const;

 	IMPORT_C TInt GetColorModeList(CArrayFixFlat<TInt> *aModeList) const;

 //

 	IMPORT_C void SetPointerCursorArea(const TRect& aArea);

 	IMPORT_C void SetPointerCursorArea(TInt aScreenSizeMode,const TRect& aArea);

 	IMPORT_C TRect PointerCursorArea() const;

 	IMPORT_C TRect PointerCursorArea(TInt aScreenSizeMode) const;

 	IMPORT_C void SetPointerCursorMode(TPointerCursorMode aMode);

 	IMPORT_C TInt SetClientCursorMode(TPointerCursorMode aMode);

 	IMPORT_C TPointerCursorMode PointerCursorMode() const;

 	IMPORT_C void SetDefaultSystemPointerCursor(TInt aCursorNumber);

 	IMPORT_C void ClearDefaultSystemPointerCursor();

 	IMPORT_C TInt SetPointerCursorPosition(const TPoint& aPosition);

 	IMPORT_C TPoint PointerCursorPosition() const;

 	IMPORT_C void SetDefaultFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);

 	IMPORT_C void PrepareForSwitchOff();

 	IMPORT_C void SetBufferSizeL(TInt aBufSize);

 	IMPORT_C void SetMaxBufferSizeL(TInt aMaxBufSize);

 	IMPORT_C TInt SetSystemFaded(TBool aFaded);

 	IMPORT_C TInt SetSystemFaded(TBool aFaded,TUint8 aBlackMap,TUint8 aWhiteMap);

 // Functions for multiple screens

 	IMPORT_C TInt SetFocusScreen(TInt aScreenNumber);

 	IMPORT_C TInt GetFocusScreen() const;

 	IMPORT_C void ClearAllRedrawStores();

 	IMPORT_C TInt NumWindowGroups(TInt aScreenNumber,TInt aPriority) const;

 	IMPORT_C TInt NumberOfScreens() const;

 	IMPORT_C TInt WindowGroupList(CArrayFixFlat<TInt>* aWindowList,TInt aScreenNumber,TInt aPriority=EAllPriorities) const;

 	IMPORT_C TInt GetFocusWindowGroup(TInt aScreenNumber) const;

 	IMPORT_C TInt GetDefaultOwningWindow(TInt aScreenNumber) const;

 	IMPORT_C TDisplayMode GetDefModeMaxNumColors(TInt aScreenNumber,TInt& aColor,TInt& aGray) const;

 	IMPORT_C TInt GetColorModeList(TInt aScreenNumber,CArrayFixFlat<TInt>* aModeList) const;

 #if defined(__WINS__)

 // Function for WINS behaviour only

 	IMPORT_C void SetRemoveKeyCode(TBool aRemove);

 	IMPORT_C void SimulateXyInputType(TInt aInputType);		//Only for testing WSERV

 #endif

 //

 	IMPORT_C void SimulateRawEvent(TRawEvent aEvent);

 	IMPORT_C void SimulateKeyEvent(TKeyEvent aEvent);

 	IMPORT_C void LogCommand(TLoggingCommand aCommand);

 	IMPORT_C void LogMessage(const TLogMessageText &aMessage);

 // Functions for test code use only

 	IMPORT_C void SystemInfo(TInt &aSystemInfoNumber, SSystemInfo &aSystemInfo);

 	IMPORT_C void TestWrite(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);

 	IMPORT_C void TestWriteReply(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);

 	IMPORT_C void TestWriteReplyP(TInt aHandle,TInt aOpcode,const TAny *aData,TInt aLength,TDes8 *aReplyPackage);

 	IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC8& aRemoteReadBuffer);

 	IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC16& aRemoteReadBuffer);

 	IMPORT_C TInt Finish();

 	IMPORT_C void SyncMsgBuf();

 // Getters and setters for pointer event's thresholds

 	IMPORT_C TInt SetCloseProximityThresholds(TInt aEnterCloseProximityThreshold, TInt aExitCloseProximityThreshold);

 	IMPORT_C TInt GetEnterCloseProximityThreshold() const;

 	IMPORT_C TInt GetExitCloseProximityThreshold() const;

 	IMPORT_C TInt SetHighPressureThresholds(TInt aEnterHighPressureThreshold, TInt aExitHighPressureThreshold);

 	IMPORT_C TInt GetEnterHighPressureThreshold() const;

 	IMPORT_C TInt GetExitHighPressureThreshold() const;

 //

     IMPORT_C void EnableWindowSizeCacheL();

 // functions not exported, used by CWsGraphic

 	void GraphicMessageReady(TRequestStatus *aStat);

 	void GetGraphicMessage(TDes8& aData) const;

 	void GraphicMessageCancel();

 	void GraphicAbortMessage(TInt aError);

 	TInt GraphicFetchHeaderMessage();

 private:

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

 	TInt doWindowGroupList(TInt aScreenNumber, TInt aPriority, CArrayFixFlat<TInt>* aWindowListId, TInt aNumOpcode, TInt aListOpcode) const;

 	TInt doSetHotKey(TInt aOpcode, TInt aType, TUint aKeycode, TUint aModifierMask, TUint aModifiers);

 	void doReadEvent(TRequestStatus *aStat, TInt aOpcode);

 private:

 	void connectL();

 	TInt DoFlush(const TIpcArgs& aIpcArgs);

 	TInt DoSyncMsgBuf(const TIpcArgs& aIpcArgs);

 	void DirectAcessActivation(TBool aIsNowActive);

 	};

 class RWindowGroup;

 class RWsSprite;

 class RWindowTreeNode : public MWsClientClass

 /** A handle to a node in the server-side window tree.

 This handle class is used as the base for both window groups and the windows

 within them; it is not intended for user derivation, and may not be directly

 constructed: use one of the standard derived classes instead.

 @publishedAll

 @released */

 	{

 	friend class RWindowGroup;

 	friend class RWindowBase;

 	friend class CWindowGc;

 	friend class RAnimDll;

 	friend class RWsSprite;

 public:

 	/** Fade control flags.

 	These flags define whether fading is applied to all child windows when SetFaded()

 	is called on a window. */

 	enum TFadeControl

 		{

 		/** Include all child windows when fading/un-fading. */

 		EFadeIncludeChildren=ETrue,

 		/** Fade only the parent window.

 		Note that a panic will occur if this value is used when SetFaded() is called

 		on a window group. */

 		EFadeWindowOnly=EFalse,

 		};

 protected:

 	RWindowTreeNode();

 	RWindowTreeNode(RWsSession &aWs);

 public:

 	IMPORT_C void Close();

 	IMPORT_C void Destroy();

 	IMPORT_C TUint32 ClientHandle() const;

 	IMPORT_C TUint32 Parent() const;

 	IMPORT_C TUint32 PrevSibling() const;

 	IMPORT_C TUint32 NextSibling() const;

 	IMPORT_C TUint32 Child() const;

 	IMPORT_C TInt OrdinalPriority() const;

 	IMPORT_C TInt OrdinalPosition() const;

 	IMPORT_C TInt FullOrdinalPosition() const;

 	IMPORT_C void SetOrdinalPosition(TInt aPos);

 	IMPORT_C void SetOrdinalPosition(TInt aPos,TInt aOrdinalPriority);

 	IMPORT_C TInt ScreenNumber() const;	

 	IMPORT_C TInt WindowGroupId() const;

 	IMPORT_C TInt SetPointerCursor(TInt aCursorNumber);

 	IMPORT_C void SetCustomPointerCursor(const RWsPointerCursor &aPointerCursor);

 	IMPORT_C TInt EnableOnEvents(TEventControl aCircumstances=EEventControlOnlyWithKeyboardFocus);

 	IMPORT_C void DisableOnEvents();

 	IMPORT_C TInt EnableGroupChangeEvents();

 	IMPORT_C void DisableGroupChangeEvents();

 	IMPORT_C TInt EnableFocusChangeEvents();

 	IMPORT_C void DisableFocusChangeEvents();

 	IMPORT_C TInt EnableGroupListChangeEvents();

 	IMPORT_C void DisableGroupListChangeEvents();

 	IMPORT_C TInt EnableVisibilityChangeEvents();

 	IMPORT_C void DisableVisibilityChangeEvents();

 	IMPORT_C TInt EnableErrorMessages(TEventControl aCircumstances);

 	IMPORT_C void DisableErrorMessages();

 	IMPORT_C TInt EnableModifierChangedEvents(TUint aModifierMask, TEventControl aCircumstances);

 	IMPORT_C void DisableModifierChangedEvents();

 	IMPORT_C void SetNonFading(TBool aNonFading);

 	IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren);

 	IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren,TUint8 aBlackMap,TUint8 aWhiteMap);

 	IMPORT_C void ClearPointerCursor();

 	IMPORT_C RWsSession* Session() const;

 protected:

 	__DECLARE_TEST;

 	};

 class TSurfaceId;

 class TSurfaceConfiguration;

 class RWindowBase : public RWindowTreeNode

 /** Client-side handle to a server-side window.

 The server-side windows of handles derived from this class can be displayed

 on the device's screen, and associated with pointer events.

 This class is not for user derivation; however derived classes form part of

 the Window Server API.

 @publishedAll

 @released */

 	{

 public:

 	/** Capture behaviour flags.

 	@see SetPointerCapture()

 	@see EEventDragDrop */

 	enum TCaptureFlags

 		{

 // Flags, these can be combined to customise pointer capture

 		/** If set, capture is enabled, disabled otherwise. */

 		TCaptureFlagEnabled=0x01,

 		/** If set, drag-drop events are sent to the window in which the pointer was lifted.

 		Drag-drop is a tap-drag-lift sequence. */

 		TCaptureFlagDragDrop=0x02,

 		/** Capture events from windows belonging to any group, not just the group of the

 		window on which the flag was set */

 		TCaptureFlagAllGroups=0x04,

 // States, made up of a set of flags

 		/** Equivalent to disabling all the above flags. */

 		TCaptureDisabled=0,

 		/** Equivalent to TCaptureFlagEnabled. */

 		TCaptureEnabled=TCaptureFlagEnabled,

 		/** Equivalent to the OR of the first three flags. */

 		TCaptureDragDrop=TCaptureFlagEnabled|TCaptureFlagDragDrop|TCaptureFlagAllGroups,

 		};

 protected:

 	RWindowBase();

 	RWindowBase(RWsSession &aWs);

 public:

 	IMPORT_C void Activate();

 	IMPORT_C void SetPosition(const TPoint &point);

 	IMPORT_C TInt SetSizeErr(const TSize &size);

 	IMPORT_C TInt SetExtentErr(const TPoint &point,const TSize &size);

 	IMPORT_C TSize Size() const;

 	IMPORT_C TPoint InquireOffset(const RWindowTreeNode &aWindow) const;

 	IMPORT_C void PointerFilter(TUint32 aFilterMask, TUint32 aFilter);

 	IMPORT_C void SetPointerGrab(TBool aState);

 	IMPORT_C void ClaimPointerGrab(TBool aSendUpEvent=ETrue);

 	IMPORT_C TInt ClaimPointerGrab(const TUint8 aPointerNumber, const TBool aSendUpEvent=ETrue);

 	IMPORT_C void SetPointerCapture(TInt aFlags);

 	IMPORT_C void SetPointerCapturePriority(TInt aPriority);

 	IMPORT_C TInt GetPointerCapturePriority() const;

 	IMPORT_C void SetVisible(TBool aState);

 	IMPORT_C void SetShadowHeight(TInt aHeight);

 	IMPORT_C void SetShadowDisabled(TBool aState);

 	IMPORT_C TPoint Position() const;

 	IMPORT_C TPoint AbsPosition() const;

 	IMPORT_C TInt SetCornerType(TCornerType aCornerType, TInt aCornerFlags=0);

 	IMPORT_C TInt SetShape(const TRegion &aRegion);

 	IMPORT_C TInt SetRequiredDisplayMode(TDisplayMode aMode);

 	IMPORT_C TDisplayMode DisplayMode() const;

 	IMPORT_C void EnableBackup(TUint aBackupType=EWindowBackupAreaBehind);

 	IMPORT_C void RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32 aTime,const TRect &aRect);

 	IMPORT_C void CancelPointerRepeatEventRequest();

 	IMPORT_C TInt RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32 aTime,const TRect &aRect, const TUint8 aPointerNumber);	//< @prototype

 	IMPORT_C TInt CancelPointerRepeatEventRequest(const TUint8 aPointerNumber);	//< @prototype

 	IMPORT_C TInt AllocPointerMoveBuffer(TInt aMaxPoints, TUint aFlags);

 	IMPORT_C void FreePointerMoveBuffer();

 	IMPORT_C void EnablePointerMoveBuffer();

 	IMPORT_C void DisablePointerMoveBuffer();

 	IMPORT_C TInt RetrievePointerMoveBuffer(TDes8 &aBuf) const;

 	IMPORT_C void DiscardPointerMoveBuffer();

 	IMPORT_C TInt AddKeyRect(const TRect &aRect, TInt aScanCode, TBool aActivatedByPointerSwitchOn);

 	IMPORT_C void RemoveAllKeyRects();

 	IMPORT_C TInt PasswordWindow(TPasswordMode aPasswordMode);

 	IMPORT_C void FadeBehind(TBool aFade);

 	IMPORT_C TBool IsFaded() const;

 	IMPORT_C TBool IsNonFading() const;

 	IMPORT_C TInt MoveToGroup(TInt aIdentifier);

 	IMPORT_C TInt SetBackgroundSurface(const TSurfaceId& aSurface);

 	IMPORT_C TInt SetBackgroundSurface(const TSurfaceConfiguration& aConfiguration, TBool aTriggerRedraw);

 	IMPORT_C void RemoveBackgroundSurface(TBool aTriggerRedraw);

 	IMPORT_C TInt GetBackgroundSurface(TSurfaceConfiguration& aConfiguration) const;

 	IMPORT_C void SetSurfaceTransparency(TBool aSurfaceTransparency);

 	IMPORT_C TRgb KeyColor() const;

 	IMPORT_C void EnableAdvancedPointers();

 protected:

 	TInt construct(const RWindowTreeNode &parent,TUint32 aHandle, TInt aType, TDisplayMode aDisplayMode);

 	};

 class RBlankWindow : public RWindowBase

 /** Blank window.

 A blank window may have its extent and colour changed, but nothing else may

 be drawn to it. Blank windows provide no functionality that is not provided

 by the RWindow class. However, they are useful when the application requires

 a window that cannot be drawn to, for example a container window.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RBlankWindow();

 	IMPORT_C RBlankWindow(RWsSession &aWs);

 	IMPORT_C TInt Construct(const RWindowTreeNode &parent, TUint32 aHandle);

 	IMPORT_C void SetColor(TRgb aColor);

 	IMPORT_C void SetColor();

 	IMPORT_C void SetSize(const TSize &size);

 	IMPORT_C void SetExtent(const TPoint &point,const TSize &size);

 	};

 class RDrawableWindow : public RWindowBase

 /** Handle to a drawable window.

 This class cannot be constructed directly.

 The two concrete derived classes, RWindow and RBackedUpWindow, allow

 drawing but use different protocols because RWindow relies on the client to

 redraw invalid areas.

 @publishedAll

 @released */

 	{

 protected:

 	RDrawableWindow();

 	RDrawableWindow(RWsSession &aWs);

 public:

 	IMPORT_C void Scroll(const TPoint &aOffset);

 	IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset);

 	IMPORT_C void Scroll(const TPoint &aOffset, const TRect &aRect);

 	IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect);

 	IMPORT_C TRect GetDrawRect() const;

 protected:

 	void SetDrawRect(const TRect &aRect);

 private:

 	void doScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect, TInt aOpcode);

 	TRect iDrawRect;

 	};

 /** Transparency policies

 These policies are to control the behaviour of a transparent window.

 @publishedAll

 @released

 @see RWindow::SetTransparencyPolicy() */

 enum TWsTransparencyPolicy {

 	/** Default behaviour. */

 	ETransparencyDefault,

 	/** Freeze the content of underneath the transparent window to prevent redraw everytime

 	the overlying window changes. */

 	ETransparencyFreezeUnder,

 	};

 class RWindow : public RDrawableWindow

 /** Handle to a standard window.

 An RWindow is a handle to a server-side window which can be displayed and

 drawn to, and whose redraws are performed by the application.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RWindow();

 	IMPORT_C RWindow(RWsSession &aWs);

 	IMPORT_C TInt Construct(const RWindowTreeNode &parent,TUint32 aHandle);

 	IMPORT_C void BeginRedraw();

 	IMPORT_C void BeginRedraw(const TRect &aRect);

 	IMPORT_C void EndRedraw();

 	IMPORT_C void Invalidate();

 	IMPORT_C void Invalidate(const TRect &aRect);

 	IMPORT_C void GetInvalidRegion(RRegion &aRegion) const;

 	IMPORT_C void SetBackgroundColor(TRgb aColor);

 	IMPORT_C void SetBackgroundColor();

 	IMPORT_C void SetSize(const TSize &size);

 	IMPORT_C void SetExtent(const TPoint &point,const TSize &size);

 	IMPORT_C void HandleTransparencyUpdate();

 	IMPORT_C TInt SetTransparencyFactor(const TRgb& aTransparencyFactor);

 	IMPORT_C TInt SetTransparencyBitmap(const CFbsBitmap& aTransparencyBitmap);

 	IMPORT_C TInt SetTransparencyWsBitmap(const CWsBitmap& aTransparencyBitmap);

 	IMPORT_C void SetNonTransparent();

 	IMPORT_C void EnableRedrawStore(TBool aEnabled);

 	IMPORT_C TInt SetTransparencyAlphaChannel();

 	IMPORT_C TInt SetTransparentRegion(const TRegion& aRegion);

 	IMPORT_C TInt SetTransparencyPolicy(TWsTransparencyPolicy aPolicy);

 	IMPORT_C TBool IsRedrawStoreEnabled() const;

 	IMPORT_C void EnableOSB(TBool);

 	IMPORT_C void ClearRedrawStore();

 	};

 class RBackedUpWindow : public RDrawableWindow

 /** Client-side handle to a drawable window with a backup bitmap.

 A backed-up window is associated with a backup bitmap which retains the contents

 of the window. When an area of the window is invalidated, the window server

 uses the bitmap directly to update the window without requiring an application

 redraw. The backup bitmap is owned by the font and bitmap server and resides

 on the font and bitmap server's shared heap, which is accessible to all client

 programs: functions are provided to allow the client application to access

 this bitmap directly and perform updates to the window under application control.

 @publishedAll

 @deprecated

 */

 	{

 public:

 	IMPORT_C RBackedUpWindow();

 	IMPORT_C RBackedUpWindow(RWsSession &aWs);

 	IMPORT_C TInt Construct(const RWindowTreeNode &parent,TDisplayMode aDisplayMode, TUint32 aHandle);

 	IMPORT_C TInt BitmapHandle() const;

 	IMPORT_C void UpdateScreen();

 	IMPORT_C void UpdateScreen(const TRegion &aRegion);

 	IMPORT_C void UpdateBackupBitmap();

 	IMPORT_C void MaintainBackup();

 	};

 class RWindowGroup : public RWindowTreeNode

 /** Client-side handle to a server-side window group.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RWindowGroup();

 	IMPORT_C RWindowGroup(RWsSession &aWs);

 	IMPORT_C TInt Construct(TUint32 aClientHandle);

 	IMPORT_C TInt Construct(TUint32 aClientHandle,CWsScreenDevice* aScreenDevice);

 	IMPORT_C TInt Construct(TUint32 aClientHandle,TBool aIsFocusable,CWsScreenDevice* aScreenDevice);

 	IMPORT_C TInt Construct(TUint32 aClientHandle,TBool aIsFocusable);

 	IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle);

 	IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle,TBool aIsFocusable);

 	IMPORT_C void AllowProcessToCreateChildWindowGroups(TUid aProcessSID);

 	IMPORT_C void EnableReceiptOfFocus(TBool aState);

 	IMPORT_C void AutoForeground(TBool aState);

 	IMPORT_C void SetOrdinalPriorityAdjust(TInt aAdjust);

 	IMPORT_C TInt SetOrdinalPositionErr(TInt aPos,TInt aOrdinalPriority);

 	IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);

 	IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier, TInt aPriority);

 	IMPORT_C void CancelCaptureKey(TInt32 aCaptureKey);

 	IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier);

 	IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier, TInt aPriority);

 	IMPORT_C void CancelCaptureKeyUpAndDowns(TInt32 aCaptureKey);

 	IMPORT_C TInt32 CaptureLongKey(TUint aInputKeyCode,TUint aOutputKeyCode,TUint aModifierMask,TUint aModifier

 																										,TInt aPriority,TUint aFlags);

 	IMPORT_C TInt32 CaptureLongKey(TTimeIntervalMicroSeconds32 aRepeatTime,TUint aInputKeyCode,TUint aOutputKeyCode

 																	,TUint aModifierMask,TUint aModifier,TInt aPriority,TUint aFlags);

 	IMPORT_C void CancelCaptureLongKey(TInt32 aCaptureKey);

 	IMPORT_C TInt AddPriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);

 	IMPORT_C void RemovePriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);

 	IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor);

 	IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor, const TRect &aClipRect);

 	IMPORT_C void CancelTextCursor();

 	IMPORT_C void SetOwningWindowGroup(TInt aIdentifier);

 	IMPORT_C void DefaultOwningWindow();

 	IMPORT_C TInt SetName(const TDesC &aName);

 	IMPORT_C TInt Name(TDes &aWindowName) const;

 	IMPORT_C TInt Identifier() const;

 	IMPORT_C void DisableKeyClick(TBool aState);

 	IMPORT_C TInt EnableScreenChangeEvents();

 	IMPORT_C void DisableScreenChangeEvents();

 	IMPORT_C void SimulatePointerEvent(TRawEvent aEvent);

 	IMPORT_C void SimulateAdvancedPointerEvent(TRawEvent aEvent);

 	IMPORT_C TInt ClearChildGroup();

 	IMPORT_C TInt SetChildGroup(TInt aId);

 private:

 	TInt32 doCaptureKey(TUint aKey, TUint aModifierMask, TUint aModifiers, TInt aPriority, TInt aOpcode);

 	void doCancelCaptureKey(TInt32 aCaptureKeyHandle, TInt aOpcode);

 	TInt Construct(TInt aIdOfParentWindowGroup, TUint32 aClientHandle, TBool aIsFocusable, CWsScreenDevice* aScreenDevice);

 	};

 class CWsBitmap : public CFbsBitmap, public MWsClientClass

 /** Window server bitmap.

 This is a bitmap to which the window server already has a handle. Functions

 which take a window server bitmap are faster than equivalent functions which

 take a CFbsBitmap.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C CWsBitmap();

 	IMPORT_C CWsBitmap(RWsSession &aWs);

 	IMPORT_C ~CWsBitmap();

 	IMPORT_C TInt Create(const TSize& aSizeInPixels,TDisplayMode aDispMode);

 	IMPORT_C TInt Duplicate(TInt aHandle);

 	IMPORT_C TInt Load(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded=ETrue);

 	IMPORT_C void InternalizeL(RReadStream& aStream);

 	IMPORT_C void Reset();

 private:

 	TInt createWsBitmap(TInt aErr);

 	};

 class RWsGraphicMsgBuf;

 class TWsGraphicMsgFixedBase

 /** Base class for fixed-size messages to be attached to CWindowGc::DrawWsGraphic commands

 @publishedAll

 @released

 */	{

 public:

 	IMPORT_C TPtrC8 Pckg() const;

 	IMPORT_C TUid TypeId() const;

 	IMPORT_C TInt Size() const;

 protected:

 	IMPORT_C TWsGraphicMsgFixedBase(TUid aTypeId,TInt aSizeOfDerived);

 private:

 	const TUid iTypeId;

 	const TInt iSize;

 	};

 class RWsGraphicMsgBuf: private RBuf8

 /** Utility class for building data buffers to be attached to CWindowGc::DrawWsGraphic commands

 Useful when there is more than one piece of data to be attached to the draw command

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RWsGraphicMsgBuf();

 	using RBuf8::Close;

 	using RBuf8::CleanupClosePushL;

 	IMPORT_C TInt Append(TUid aTypeId,const TDesC8& aData);

 	IMPORT_C TInt Append(TUid aTypeId,const TDesC16& aData);

 	IMPORT_C TInt Append(TUid aTypeId,TInt aLen,TPtr8& aPtr);

 	IMPORT_C TInt Append(const TWsGraphicMsgFixedBase& aMsg);

 	IMPORT_C void Remove(TInt aIndex);

 	IMPORT_C TInt Count() const;

 	IMPORT_C TUid TypeId(TInt aIndex) const;

 	IMPORT_C TPtrC8 Data(TInt aIndex) const;

 	IMPORT_C TPtr8 Data(TInt aIndex);

 	IMPORT_C void GetFixedMsg(TWsGraphicMsgFixedBase& aMsg,TInt aIndex) const;

 	IMPORT_C const TDesC8& Pckg() const;

 private:

 	TInt ExpandForAppend(TInt aDataLen);

 	void WriteHeader(TUid aUid,TInt aLen);

 	TInt IntAt(TInt aOfs) const;

 private:

 	TInt iRMsgBufSpare[2];

 	};

 class CWindowGc : public CBitmapContext, public MWsClientClass

 /** Window graphics context.

 Most window graphics context drawing functions map to equivalent CFbsBitGc

 functions. They are implemented on the screen with any co-ordinates being

 relative to the top left corner of the window. However extra clipping is applied.

 The drawing will always be clipped to the visible part of the window. In addition

 it will be clipped to the non-invalid part if you are not doing a redraw and

 to the region being validated if you are doing a redraw.

 Note:

 In general, server side functions which encounter conditions which would normally

 cause a leave, do not leave but instead return an error value indicating the

 leave condition. In this way the leave can be handled on the appropriate side

 of the client/server boundary. For example, a client can choose to wrap server

 calls with User::LeaveIfError(), which causes a leave with the specified

 error.

 The above advice is true of many functions in this class, and in its derived

 classes.

 @publishedAll

 @released

 @see CGraphicsContext */

 	{

 	friend class CWsScreenDevice;

 public:

 	/** Defines possible clockwise rotation values.

 	WARNING: Enum for internal and partner use ONLY.  Compatibility is not guaranteed in future releases.

 	@prototype

 	*/

 	enum TGraphicsRotation

 		{

 		/** No rotation. */

 		EGraphicsRotationNone,

 		/** A 90 degree rotation. */

 		EGraphicsRotation90,

 		/** A 180 degree rotation. */

 		EGraphicsRotation180,

 		/** A 270 degree rotation. */

 		EGraphicsRotation270

 		};	

 	IMPORT_C CWindowGc(CWsScreenDevice *aDevice);

 	IMPORT_C virtual ~CWindowGc();

 	IMPORT_C virtual TInt Construct();

 	IMPORT_C virtual void Activate(RDrawableWindow &aDevice);

 	IMPORT_C virtual void Deactivate();

 //====================FROM CGraphicsContext.H===============================

 	IMPORT_C virtual CGraphicsDevice* Device() const;

 	IMPORT_C virtual void SetOrigin(const TPoint &aPoint=TPoint(0,0));

 	IMPORT_C virtual void SetDrawMode(TDrawMode aDrawingMode);

 	IMPORT_C virtual void SetClippingRect(const TRect& aRect);

 	IMPORT_C virtual void CancelClippingRect();

 	IMPORT_C virtual void Reset();

 	IMPORT_C virtual void UseFont(const CFont *aFont);

 	IMPORT_C virtual void DiscardFont();

 	IMPORT_C virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle);

 	IMPORT_C virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);

 // Used to do justified text properly

 	IMPORT_C virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps);

 // Used primarily to get accurate WYSIWYG

 	IMPORT_C virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars);

 	IMPORT_C virtual void SetPenColor(const TRgb &aColor);

 	IMPORT_C virtual void SetPenStyle(TPenStyle aPenStyle);

 	IMPORT_C virtual void SetPenSize(const TSize& aSize);

 	IMPORT_C virtual void SetBrushColor(const TRgb &aColor);

 	IMPORT_C virtual void SetBrushStyle(TBrushStyle aBrushStyle);

 	IMPORT_C virtual void SetBrushOrigin(const TPoint &aOrigin);

 	IMPORT_C virtual void UseBrushPattern(const CFbsBitmap *aDevice);

 	IMPORT_C virtual void DiscardBrushPattern();

 //

 // Move the internal position, as used by DrawLineTo & DrawLineBy, and set by MoveTo,

 // MoveBy, DrawLine, DrawLineTo, DrawLineBy and DrawPolyline

 	IMPORT_C virtual void MoveTo(const TPoint &aPoint);

 	IMPORT_C virtual void MoveBy(const TPoint &aPoint);

 	IMPORT_C virtual void Plot(const TPoint &aPoint);

 //

 //  Line drawing subject to pen color, width and style and draw mode

 	IMPORT_C virtual void DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);

 	IMPORT_C virtual void DrawLine(const TPoint &aPoint1,const TPoint &aPoint2);

 	IMPORT_C virtual void DrawLineTo(const TPoint &aPoint);

 	IMPORT_C virtual void DrawLineBy(const TPoint &aPoint);

 	IMPORT_C virtual void DrawPolyLine(const CArrayFix<TPoint> *aPointList);

 	IMPORT_C virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints);

 //

 // Filled outlines

 // Outlines subject to pen color, width and style and draw mode

 // (set pen to ENullPen for no outline)

 // Fill subject to brush style (color, hash or pattern) and origin and

 // drawing mode (set brush to ENullBrush for no fill)

 	IMPORT_C virtual void DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);

 	IMPORT_C virtual void DrawEllipse(const TRect &aRect);

 	IMPORT_C virtual void DrawRect(const TRect &aRect);

 	IMPORT_C virtual void DrawRoundRect(const TRect &aRect,const TSize &aEllipse);

 	IMPORT_C virtual TInt DrawPolygon(const CArrayFix<TPoint> *aPointList,TFillRule aFillRule=EAlternate);

 	IMPORT_C virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate);

 //

 // Uses the bitmap's Twips size and does a "stretch" blit in general

 	IMPORT_C virtual void DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice);

 	IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice);

 	IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect);

 	IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask);

 	IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CWsBitmap* aBitmap, const TRect& aSourceRect, const CWsBitmap* aMaskBitmap, TBool aInvertMask);

 // Required as not all DrawText and DrawTextVertical functions are implemented in CWindowGc

 	using CBitmapContext::DrawText;

 	using CBitmapContext::DrawTextVertical;

 //

 // Text drawing subject to drawing mode

 // Subject to used font, pen color, drawing mode,

 // word and char justification

 	IMPORT_C virtual void DrawText(const TDesC &aBuf,const TPoint &aPos);

 //

 // Subject to same as above plus brush for background

 // (set brush to ENullBrush for no effect on background)

 	IMPORT_C virtual void DrawText(const TDesC &aBuf,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);

 //================Extra functions from CBitmapContext==============

 	IMPORT_C virtual void Clear();

 	IMPORT_C virtual void Clear(const TRect &aRect);

 	IMPORT_C virtual void CopyRect(const TPoint &anOffset,const TRect &aRect);

 	IMPORT_C virtual void BitBlt(const TPoint &aPos, const CFbsBitmap *aBitmap);

 	IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource);

 	IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask);

 	IMPORT_C virtual void BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap);

 	IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CWsBitmap *aBitmap, const TRect &aSource);

 	IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CWsBitmap *aBitmap,const TRect& aSourceRect,const CWsBitmap *aMaskBitmap,TBool aInvertMask);

 	IMPORT_C virtual void MapColors(const TRect& aRect,const TRgb* aColors,TInt aNumPairs=2,TBool aMapForwards=ETrue);

 	IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp);

 	IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);

 //=================Extra functions specific to wserv GDI==============

 	IMPORT_C virtual void SetDitherOrigin(const TPoint& aPoint);

 	IMPORT_C virtual TInt SetClippingRegion(const TRegion &aRegion);

 	IMPORT_C virtual void CancelClippingRegion();

 	IMPORT_C virtual void SetOpaque(TBool aDrawOpaque=ETrue);

 //=================Functions also supplied by CFbsBitGc==============

 	IMPORT_C virtual void SetFaded(TBool aFaded);

 	IMPORT_C virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);

 	IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt);

 	IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp, const TRect& aSrcRect, const CWsBitmap* aAlphaBmp, const TPoint& aAlphaPt);

 //

 	IMPORT_C TAny* Interface(TUid aInterfaceId);

 	IMPORT_C const TAny* Interface(TUid aInterfaceId) const;

 protected:	

 	IMPORT_C TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);

 private:	

 	IMPORT_C void Reserved_CGraphicsContext_2();

 	IMPORT_C void Reserved_CBitmapContext_1();

 	IMPORT_C void Reserved_CBitmapContext_2();

 	IMPORT_C void Reserved_CBitmapContext_3();

 public:

 	IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect);

 	IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect,const TDesC8& aData);

 private:

 	IMPORT_C virtual void Reserved_CWindowGc_3();

 	IMPORT_C virtual void Reserved_CWindowGc_4();

 	IMPORT_C virtual void Reserved_CWindowGc_5();

 //=============================================================

 private: // Private code

 	TRgb Color(TInt aOpcode)const;

 	void SetJustification(TInt aExcessWidth,TInt aNumGaps, TInt aOpcode);

 	void DrawArcOrPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd, TInt aOpcode);

 	void doDrawPolyLine(const CArrayFix<TPoint> *aPointArray, const TPoint* aPointList,TInt aNumPoints);

 	TInt doDrawPolygon(const CArrayFix<TPoint> *aPointArray,const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule);

 	void WriteTextPos(TInt aOpcode,TInt aOpcodePtr,const TPoint &aPos,const TDesC &aBuf) const;

 	void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC &aBuf,TInt aOpcode,TInt aOpcodePtr) const;

 	void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC8 &aBuf,TInt aOpcode,TInt aOpcodePtr) const;

 	TInt APIExGetUnderlineMetrics(TAny*& aOutput);

 	TInt APIExSetShadowColor(TAny* aShadowColor);

 	TInt APIExGetShadowColor(TAny*& aOutput);

 	// New DrawText API's that take in context

 	TInt APIExDrawText(const TDesC &aBuf,const TTextParameters* aParam,const TPoint &aPos);

 	TInt APIExDrawText(const TDesC &aBuf,const TTextParameters* aParam,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);

 	TInt APIExDrawTextVertical(const TDesC& aText,const TTextParameters* aParam,const TPoint& aPos,TBool aUp);

 	TInt APIExDrawTextVertical(const TDesC& aText,const TTextParameters* aParam,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);

 	TInt APIExInterface(TAny*& aInterface, TUid aInterfaceId);

 	void DrawResource(const TPoint& aPos, const RWsDrawableSource& aSource, TGraphicsRotation aRotation=EGraphicsRotationNone);

 	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, TGraphicsRotation aRotation=EGraphicsRotationNone);

 	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TRect& aSrcRect, TGraphicsRotation aRotation=EGraphicsRotationNone);

 	void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TDesC8& aParam);

 private: // Private data

 	class CPimpl;

 	CPimpl* iPimpl;

 	CWsScreenDevice *iDevice;

 	};

 class CWsScreenDevice : public CBitmapDevice, public MWsClientClass

 /** Software device screen.

 An object of this class can be used to enquire or set parameters of the software

 screen, and determine the physical limits of the device.

 CWsScreenDevice gives access to the list of screen modes. These are the combinations

 of screen rotation and screen size supported by the device. One of them is

 selected as the current screen mode. The possible screen modes are initialised

 in wsini.ini.

 @publishedAll

 @released

 @see CFbsScreenDevice */

 	{

 public:

 	/**	Whether or not to include sprites when comparing areas of the screen*/

 	enum TSpriteInCompare

 		{

 		/** This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,

 		const TRect &aRect2,TUint aFlags).

 		When called with the value ERemoveSprite if there are any sprites visible in the areas of the screen being compared then these

 		will not be included in the comparison.

 		The function CWsScreenDevice::RectCompare(const TRect &aRect1,const TRect &aRect2) will not include

 		sprites in the comparison.

 		*/

 		ERemoveSprite=0,

 		/**	This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,

 		const TRect &aRect2,TUint aFlags).

 		When called with the value EIncludeSprite if there are any sprites visible in the areas of the screen being compared then these

 		will be included in the comparison.*/

 		EIncludeSprite=1,

 		/**	This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,

 		const TRect &aRect2,TUint aFlags). 

 		When called with the value EIncludeTextCursor if there are any text cursors visible in the areas of the screen being compared then these 

 		will be included in the comparison.*/

 		EIncludeTextCursor=2

 		};

 public:

 	IMPORT_C CWsScreenDevice();

 	IMPORT_C CWsScreenDevice(RWsSession &aWs);

 	IMPORT_C ~CWsScreenDevice();

 	IMPORT_C TInt Construct();

 	IMPORT_C TInt Construct( TInt aDefaultScreenNumber ) ;

 	IMPORT_C TAny* GetInterface(TUint aInterfaceId);

 	inline const TAny* GetInterface(TUint aInterfaceId) const;

 	IMPORT_C TBool IsModeDynamic(TInt aSizeMode) const;

 	IMPORT_C TBool IsCurrentModeDynamic() const;

 //==== From CGraphicsDevice ====//

 	IMPORT_C TDisplayMode DisplayMode() const;

 	IMPORT_C TSize SizeInPixels() const;

 	IMPORT_C TSize SizeInTwips() const;

 	IMPORT_C TInt HorizontalTwipsToPixels(TInt aTwips) const;

 	IMPORT_C TInt VerticalTwipsToPixels(TInt aTwips) const;

 	IMPORT_C TInt HorizontalPixelsToTwips(TInt aPixels) const;

 	IMPORT_C TInt VerticalPixelsToTwips(TInt aPixels) const;

 	IMPORT_C TRect PointerRect() const;

 	IMPORT_C TInt CreateContext(CGraphicsContext *&aGc);

 	inline TInt CreateContext(CWindowGc*& aGc);

 	IMPORT_C virtual TInt GetNearestFontInTwips(CFont*& aFont,const TFontSpec& aFontSpec);

 	IMPORT_C virtual TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec);

 	IMPORT_C virtual TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);

 	IMPORT_C TInt NumTypefaces() const;

 	IMPORT_C void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const;

 	IMPORT_C TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const;

 // ==== From CBitmapDevice ====//

 	IMPORT_C void GetPixel(TRgb& aColor,const TPoint& aPixel) const;

 	IMPORT_C void GetScanLine(TDes8& aScanLine,const TPoint& aStartPixel,TInt aPixelLength, TDisplayMode aDispMode) const;

 	IMPORT_C TInt AddFile(const TDesC& aName,TInt& aId);

 	IMPORT_C void RemoveFile(TInt aId=0);

 	IMPORT_C virtual TInt GetNearestFontInPixels(CFont*& aFont,const TFontSpec& aFontSpec);

 	IMPORT_C virtual TInt GetNearestFontToDesignHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec);

 	IMPORT_C virtual TInt GetNearestFontToMaxHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);

 	IMPORT_C TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const;

 	IMPORT_C void ReleaseFont(CFont* aFont);

 //===== From CFbsScreenDevice ====//

 	IMPORT_C void PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const;

 	IMPORT_C void SetPalette(CPalette* aPalette);

 	IMPORT_C TInt GetPalette(CPalette*& aPalette) const;

 //===== Extra functions ====//

 	IMPORT_C TInt SetCustomPalette(const CPalette* aPalette);

 	IMPORT_C TInt GetFontById(CFont*& aFont,TUid aUid,const TAlgStyle& aAlgStyle);

 	IMPORT_C TBool RectCompare(const TRect &aRect1,const TRect &aRect2) const;

 	IMPORT_C TBool RectCompare(const TRect& aRect1,const TRect &aRect2,TUint aFlags) const;

 	IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap) const;

 	IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap, const TRect &aRect) const;

 	IMPORT_C TInt SetBackLight(TBool aBackLight);

 //===== Screen Rotation functions ====//

 	IMPORT_C void SetScreenSizeAndRotation(const TPixelsTwipsAndRotation &aSizeAndRotation);

 	IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsTwipsAndRotation &aSizeAndRotation) const;

 	IMPORT_C void SetScreenSizeAndRotation(const TPixelsAndRotation &aSizeAndRotation);

 	IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsAndRotation &aSizeAndRotation) const;

 	IMPORT_C TScreenModeEnforcement ScreenModeEnforcement() const;

 	IMPORT_C void SetScreenModeEnforcement(TScreenModeEnforcement aMode) const;

 	IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsTwipsAndRotation &aSizeAndRotation) const;

 	IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsAndRotation &aSizeAndRotation) const;

 	IMPORT_C void SetCurrentRotations(TInt aMode, CFbsBitGc::TGraphicsOrientation aRotation) const;

 	IMPORT_C TInt GetRotationsList(TInt aMode, CArrayFixFlat<TInt> *aRotationList) const;

 	IMPORT_C TInt NumScreenModes() const;

 	IMPORT_C void SetScreenMode(TInt aMode);

 	IMPORT_C TInt CurrentScreenMode() const;

 	IMPORT_C void SetAppScreenMode(TInt aMode);

 	IMPORT_C TPoint GetDefaultScreenModeOrigin() const;

 	IMPORT_C TPoint GetScreenModeOrigin(TInt aMode) const;

 	IMPORT_C TSize GetCurrentScreenModeScale() const;

 	IMPORT_C TSize GetScreenModeScale(TInt aMode) const;

 	IMPORT_C TPoint GetCurrentScreenModeScaledOrigin() const;

 	IMPORT_C TPoint GetScreenModeScaledOrigin(TInt aMode) const;

 	IMPORT_C TInt GetScreenSizeModeList(RArray<TInt>* aModeList) const;

 	IMPORT_C TDisplayMode GetScreenModeDisplayMode(const TInt &aMode) const;

 //===== Used for testing purpose only ====//

 	IMPORT_C TSizeMode GetCurrentScreenModeAttributes() const;

 	IMPORT_C void SetCurrentScreenModeAttributes(const TSizeMode &aModeAtt);

 	IMPORT_C TInt GetScreenNumber() const;

 private:

 	CFbsTypefaceStore* TypeFaceStore()const;

 	TSize DisplaySizeInPixels()const;

 	TSize PhysicalScreenSizeInTwips()const;

 private: // Private data

 	class CScrDevExtension;				//Implements extension interfaces, including and replacing typeface store

 	CScrDevExtension* iExtension;

 	TSize iPhysicalScreenSizeInTwips;

 	TSize iDisplaySizeInPixels;

 	friend class CWindowGc;

 	};

 class RWsSpriteBase : public MWsClientClass

 // Client side class base class for sprites and pointer cursors

 /** Sprite base class.

 Unless stated otherwise, references to sprites in the documentation for this class also

 apply to pointer cursors.

 @publishedAll

 @released

 @see RWsSprite

 @see RWsPointerCursor */

 	{

 protected:

 	IMPORT_C RWsSpriteBase();

 	IMPORT_C RWsSpriteBase(RWsSession &aWs);

 public:

 	IMPORT_C TInt Activate();

 	IMPORT_C TInt AppendMember(const TSpriteMember &aMemberData);

 	IMPORT_C void UpdateMember(TInt aIndex);

 	IMPORT_C TInt UpdateMember(TInt aIndex, const TSpriteMember &aMemberData);

 	IMPORT_C void Close();

 	};

 class RWsSprite : public RWsSpriteBase

 /** Sprite.

 This class defines functions to create and initialise a sprite, and to set

 its position.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RWsSprite();

 	IMPORT_C RWsSprite(RWsSession &aWs);

 	IMPORT_C TInt Construct(RWindowTreeNode &aWindow, const TPoint &aPos, TInt aFlags);

 	IMPORT_C void SetPosition(const TPoint &aPos);

 	};

 class RWsPointerCursor : public RWsSpriteBase

 /** Pointer cursor.

 The pointer cursor is created in a similar way to a sprite. After creating it,

 one or more sprite members containing the bitmaps to be displayed are added.

 After a pointer cursor has been created and activated, it does not become

 visible until the application calls RWindowTreeNode::SetPointerCursor() or

 RWindowTreeNode::SetCustomPointerCursor(). The pointer cursor's origin automatically

 tracks the position of the pointing device, or position of emulated single pointer if there

 are more pointers in the system (see documentation of RWindowBase::EnableAdvancedPointers()

 for more details), and the origin forms the pointer cursor's "hot spot", i.e., the point 

 whose co-ordinates are sent to the client if a pointer event occurs. 

 If the pointer cursor's bitmap needs to extend to the left or upwards from the pointer 

 position, its sprite member should be given a negative offset in TSpriteMember::iOffset.

 Note:

 Pointer cursors are rarely used in pure pen architectures, but they are supported

 for mouse or tablet use.

 @see RWindowBase::EnableAdvancedPointers()

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C RWsPointerCursor();

 	IMPORT_C RWsPointerCursor(RWsSession &aWs);

 	IMPORT_C TInt Construct(TInt aFlags);

 	};

 class RAnim;

 class RAnimDll : public MWsClientClass

 /** Client-side interface to the server-side animation DLL.

 This is the client side class matching the server side CAnimDLL class. It

 provides functions to create, load, close and destroy a server-side CAnimDll

 object.

 @publishedAll

 @released

 @see CreateCAnimDllL()

 @see CAnimDll */

 	{

 public:

 	IMPORT_C RAnimDll();

 	IMPORT_C virtual ~RAnimDll();

 	IMPORT_C RAnimDll(RWsSession &aWs);

 	IMPORT_C TInt Load(const TDesC &aFileName);

 	IMPORT_C void Destroy();

 	IMPORT_C virtual void Close();

 private:

 	TInt CommandReply(TInt aHandle, TInt aOpcode, const TIpcArgs* aIpcArgs=NULL);

 	TInt CommandReply(TInt aHandle, TInt aOpcode, const TDesC8& aArgs, const TIpcArgs* aIpcArgs=NULL);

 	void Command(TInt aHandle, TInt aOpcode, const TPtrC8 &aArgs);

 	void Command(TInt aHandle, TInt aOpcode);

 	void AsyncCommandReply(TRequestStatus& aStatus, TInt aOpcode, TIpcArgs& aIpcArgs);

 	TInt CreateInstance(TInt32& aHandle, const MWsClientClass &aDevice, TInt aType, const TDesC8 &aArgs, TInt aOpcode, const TIpcArgs* aIpcArgs);

 	void DestroyInstance(TInt aHandle);

 private:

 	friend class RAnim;

 	};

 class RAnim

 /** Client-side handle to a server-side animation class.

 This class should be sub-classed to provide a client side interface to the

 server side animation DLL. The server side animation DLL is derived from CAnim.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C virtual ~RAnim();

 	IMPORT_C virtual void Close();

 	IMPORT_C void Destroy();

 protected:

 	IMPORT_C RAnim();

 	IMPORT_C RAnim(RAnimDll &aDll);

 	IMPORT_C TInt Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams);

 	IMPORT_C TInt Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs);

 	IMPORT_C TInt Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams);

 	IMPORT_C TInt Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs);

 	IMPORT_C TInt CommandReply(TInt aOpcode);

 	IMPORT_C TInt CommandReply(TInt aOpcode, const TPtrC8 &aArgs);

 	IMPORT_C TInt CommandReply(TInt aOpcode, const TDesC8& aArgs, const TIpcArgs& aIpcArgs);

 	IMPORT_C void Command(TInt aOpcode, const TPtrC8 &aArgs);

 	IMPORT_C void Command(TInt aOpcode);

 	IMPORT_C void AsyncCommandReply(TRequestStatus& aRequestStatus,TInt aOpcode, const TIpcArgs& aIpcArgs);

 private:

 	TInt32 iHandle;

 	RAnimDll *iAnimDll;

 	};

 class CDsaMsgQueue;

 class RDirectScreenAccess : public MWsClientClass

 /** The interface between an application that directly accesses the screen and

 the window server.

 Note that most applications that need to access the screen directly should

 use CDirectScreenAccess instead. RDirectScreenAccess only needs to be used

 directly by applications without access to an active scheduler.

 @publishedAll

 @released */

 	{

 public:

 	/** Provides the reason why direct screen access must terminate. This enum is used

 	in the MAbortDirectScreenAccess::AbortNow() and MDirectScreenAccess::Restart()

 	functions.

 	The first value (ETerminateCancel) indicates that direct screen access is

 	being terminated by the application. The final three values indicate that

 	direct screen access is being terminated by the window server. Note that

 	for users of CDirectScreenAccess, the termination code is not important

 	because these issues are dealt with by CDirectScreenAccess::StartL(). */

 	enum TTerminationReasons

 		{

 		/** The application has finished direct screen access. */

 		ETerminateCancel,

 		/** A window is about to come in front of a part of the area that is being used

 		for direct screen access. */

 		ETerminateRegion,

 		/** The screen's color depth (as enumerated by TDisplayMode) is about to change. */

 		ETerminateScreenMode,

 		/** The current screen mode (the combination of screen rotation and screen size)

 		is about to change. */

 		ETerminateRotation,

 		};

 	/** The priority of the active object that responds to notification that direct

 	screen access must stop. */

 	enum TPriority

 		{

 		/** A suggested value for the priority of the active object that responds to notification

 		from the window server that direct screen access must stop. This is also the

 		value used by CDirectScreenAccess for this purpose. */

 		EPriorityVeryHigh=2000,

 		};

 public:

 	IMPORT_C RDirectScreenAccess();

 	IMPORT_C RDirectScreenAccess(RWsSession& aWs);

 	IMPORT_C TInt Construct();

 	IMPORT_C TInt Construct(TBool aRegionTrackingOnly);

 	IMPORT_C TInt Request(RRegion*& aRegion,TRequestStatus& aStatus,const RWindowBase& aWindow);

 	IMPORT_C void Completed();

 	IMPORT_C void Cancel();

 	IMPORT_C void Close();

 private:

 	RWsSession* iWs;

 	CDsaMsgQueue* iMsgQueue;

 	// To maintain BC we need the following

 	RThread iWsThread;

 	TRequestStatus* iDummyRequest;

 	};

 class MAbortDirectScreenAccess

 /** The interface for terminating direct screen access.

 An object of a class which implements this interface should be passed to CDirectScreenAccess::NewL().

 @publishedAll

 @released

 @see MDirectScreenAccess */

 	{

 public:

 	/** This function is called by the window server when direct screen access must

 	stop (for example because a dialogue is moved in front of the area where direct

 	screen access is taking place).

 	In response to this, direct screen access must stop immediately. In simple cases,

 	this will involve cancelling the active object that is driving the drawing to the

 	screen.

 	No attempt to call a Window Server API function can be made from

 	AbortNow(), because then a temporary deadlock will occur. This is because WSERV

 	is waiting to receive the client's acknowledgment that it has aborted, and so will

 	not be able to service the call. As soon as the restriction no longer applies,

 	the function Restart() will be called.

 	@param aReason The reason why direct screen access was terminated. */

 	virtual void AbortNow(RDirectScreenAccess::TTerminationReasons aReason)=0;

 	};

 class MDirectScreenAccess : public MAbortDirectScreenAccess

 /** The interface for restarting direct screen access.

 The Restart() function is called by the window server as soon as direct screen

 access can resume. It is called after the window server has called AbortNow().

 An object of the derived class is passed to CDirectScreenAccess::NewL().

 @publishedAll

 @released

 @see CDirectScreenAccess::NewL() */

 	{

 public:

 	/** This function is called by the window server as soon as direct screen access

 	can resume.

 	This function should call CDirectScreenAccess::StartL() within a trap harness.

 	If this leaves, e.g. through lack of memory, direct screen access cannot be

 	restarted. StartL() re-calculates the clipping region, so that if direct screen

 	access was aborted because another window appeared in front of it, that window

 	will not be overwritten when direct screen access resumes.

 	In this function, you can resume calls to Window Server Client Side API functions.

 	@param aReason Provides the reason why direct screen access was terminated. */

 	virtual void Restart(RDirectScreenAccess::TTerminationReasons aReason)=0;

 	};

 class CDirectScreenAccess : public CActive

 /** An active object used to start direct screen access.

 Direct screen access is a way of drawing to the screen without using the window

 server. As this avoids client-server communication, it is much faster, and

 may be useful for games and video. Note that some interaction with the window

 server is needed in order to prevent the application from drawing over other

 application's data.

 The object's (private) RunL() function is called by the window server in order

 to abort direct screen access. This might occur when another window needs

 to be displayed in front or when the window with direct screen access is moved.

 The active object's priority is RDirectScreenAccess::EPriorityVeryHigh so

 that direct screen access will be aborted as quickly as possible.

 @publishedAll

 @released */

 	{

 public:

 	IMPORT_C static CDirectScreenAccess* NewL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWin,MDirectScreenAccess& aAbort);

 	IMPORT_C static CDirectScreenAccess* NewL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWin,MDirectScreenAccess& aAbort,TBool aRegionTrackingOnly);

 	~CDirectScreenAccess();

 	IMPORT_C void StartL();

 	inline CFbsBitGc* Gc();

 	inline CFbsScreenDevice*& ScreenDevice();

 	inline RRegion* DrawingRegion();

 private:

 	enum TFlags

 		{

 		EDirectCheckModeChange		=	0x01,

 		EDirectCheckSizeModeChange	=	0x02,

 		EDirectRegionTrackingOnly	=	0x04,

 		};

 private:

 	inline CDirectScreenAccess(RWsSession& aWs,CWsScreenDevice* aScreenDevice,RWindowBase& aWindow,MDirectScreenAccess& aAbort);

 	void ConstructL(RWsSession& aWs,TBool aRegionTrackingOnly);

 	void CreateScreenObjectsL(TDisplayMode aCurrentMode);

 	void UpdateSizeAndRotation(CFbsBitGc* aGc);

 	static TInt Restart(TAny* aDirect);

 	void Restart();

 	//Pure virtual functions from CActive

 	void DoCancel();

 	void RunL();

 private:

 	CFbsBitGc* iGc;

 	CFbsScreenDevice* iScreenDevice;

 	RRegion* iDrawingRegion;

 	RWindowBase& iWindow;

 	CWsScreenDevice* iWsScreenDevice;

 	MDirectScreenAccess& iAbort;

 	RDirectScreenAccess iDirectAccess;

 	RDirectScreenAccess::TTerminationReasons iReason;

 	CIdle* iRestart;

 	TSize iScreenSize;

 	TBool iAborting;

 	TUint iFlags;

 	TInt iScreenNumber;

 	};

 class RSoundPlugIn : public MWsClientClass

 /** Client interface to the key or pointer click plug-in DLL.

 The plug-in DLL implements the CClickMaker class.

 @publishedAll

 @released

 @see CClickMaker */

 	{

 public:

 	/** A possible return value for CommandReply(). */

 	enum

 		{

 		/** The value returned by CommandReply() if no plug-in is loaded,

 		or if the plug-in identified by the aUid parameter in Construct() is not loaded.

 		Its value is set to KMinTInt so that it should not clash with any other expected

 		return value from this function. */

 		ESoundWrongPlugIn=KMinTInt

 		};

 public:

 	IMPORT_C RSoundPlugIn();

 	IMPORT_C RSoundPlugIn(RWsSession &aWs);

 	IMPORT_C TInt Construct(TUid aUid=KNullUid);

 	IMPORT_C void Close();

 	IMPORT_C void Destroy();

 	IMPORT_C TBool IsLoaded(TBool& aIsChangeable) const;