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

#include <babitflags.h>

#include <wspublishandsubscribedata.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.