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

	{