1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Standard window server header file

    15 // 

    16 //

    17 

    18 #ifndef __W32STD_H__

    19 #define __W32STD_H__

    20 

    21 #ifndef __FNTSTORE_H__

    22 #include <fntstore.h>

    23 #endif

    24 #ifndef __BITDEV_H__

    25 #include <bitdev.h>

    26 #endif

    27 #ifndef __BITSTD_H__

    28 #include <bitstd.h>

    29 #endif

    30 #include <e32keys.h>

    31 #include <textcursor.h>

    32 #include <pointerevent.h>

    33 #include <advancedpointerevent.h>

    34 #include <sizemode.h>

    35 

    36 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    37 #include <graphics/windowserverconstants.h>

    38 #include <graphics/pointereventdata.h>

    39 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS

    40 

    41 _LIT(KWSERVThreadName,"Wserv");

    42 

    43 class RWindowBase;

    44 class RWindow;

    45 class RWsBuffer;

    46 class MWsObjectProvider;

    47 class RWsDrawableSource;

    48 class TSizeMode;

    49 

    50 /** Screen mode enforcement flags.

    51 

    52 Screen mode enforcement ensures that windows must meet certain requirements

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

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

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

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

    57 mode.

    58 

    59 @publishedAll

    60 @released

    61 @see CWsScreenDevice::ScreenModeEnforcement()

    62 @see CWsScreenDevice::SetScreenModeEnforcement() */

    63 enum TScreenModeEnforcement

    64 	{

    65 	/** No enforcement.

    66 

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

    68 	of the screen mode.

    69 

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

    71 	ESizeEnforcementNone,

    72 	/** Pixels and rotation enforcement.

    73 

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

    75 	correct size in pixels to be displayed. */

    76 	ESizeEnforcementPixelsAndRotation,

    77 	/** Pixels and Twips enforcement.

    78 

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

    80 	size in pixels and twips to be displayed.

    81 

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

    83 	distort fonts when rotated. */

    84 	ESizeEnforcementPixelsTwipsAndRotation,

    85 	};

    86 

    87 struct TPixelsAndRotation

    88 /** Pixels and rotation struct.

    89 

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

    91 and its rotation.

    92 

    93 @publishedAll

    94 @released

    95 @see CWsScreenDevice::GetScreenModeSizeAndRotation() */

    96 	{

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

    98 	TSize iPixelSize;

    99 	/** The current screen orientation. */

   100 	CFbsBitGc::TGraphicsOrientation iRotation;

   101 	};

   102 

   103 struct TPixelsTwipsAndRotation

   104 /** Pixels, twips and rotation struct.

   105 

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

   107 and pixels, and its rotation.

   108 

   109 @publishedAll

   110 @released

   111 @see CWsScreenDevice::GetScreenModeSizeAndRotation() */

   112 	{

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

   114 	TSize iPixelSize;

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

   116 	TSize iTwipsSize;

   117 	/** The screen rotation. */

   118 	CFbsBitGc::TGraphicsOrientation iRotation;

   119 	};

   120 

   121 /** Log message text length.

   122 

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

   124 which is used in RWsSession::LogMessage().

   125 

   126 @publishedAll

   127 @released */

   128 enum {

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

   130 	KLogMessageLength=0x80

   131 	};

   132 

   133 /** Log message text buffer.

   134 

   135 This is used in RWsSession::LogMessage().

   136 

   137 @publishedAll

   138 @released */

   139 typedef TBuf<KLogMessageLength> TLogMessageText;

   140 

   141 /** Password window group priority.

   142 

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

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

   145 hence password tests cannot be bypassed.

   146 

   147 @publishedAll

   148 @deprecated */

   149 enum

   150 	{

   151 	 /** Password window group priority. */

   152 	KPasswordWindowGroupPriority=1000

   153 	};

   154 

   155 /** Switch ordinal position to owning window.

   156 

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

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

   159 RWindowGroup).

   160 

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

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

   163 window were to die with keyboard focus.

   164 

   165 @publishedAll

   166 @released

   167 @see RWsSession::SetWindowGroupOrdinalPosition()

   168 @see RWindowTreeNode::SetOrdinalPosition() */

   169 enum {

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

   171 	KOrdinalPositionSwitchToOwningWindow=0x80000000

   172 	};

   173 

   174 /** Window corner types.

   175 

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

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

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

   179 to give corners.

   180 

   181 @publishedAll

   182 @released

   183 @see TCornerFlags

   184 @see RWindowBase::SetCornerType() */

   185 enum TCornerType

   186 // Bottom 16 bits available for corner type

   187 	{

   188 	/** Square corner. */

   189 	EWindowCornerSquare,

   190 	/** Corner pixel removed. */

   191 	EWindowCorner1,

   192 	/** Two pixel step.

   193 

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

   195 	EWindowCorner2,

   196 	/** Three pixel step.

   197 

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

   199 	2 pixels above or below it. */

   200 	EWindowCorner3,

   201 	/** Five pixel step.

   202 

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

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

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

   206 	EWindowCorner5,

   207 	EWindowCornerRegion,		// Private

   208 	/** Corner type mask.

   209 

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

   211 	separate TCornerType and TCornerFlags values from a TInt which contains both

   212 	types. */

   213 	ECornerTypeMask=0xFFFF

   214 	};

   215 

   216 /** Corner flags.

   217 

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

   219 are not to have corner types applied to them.

   220 

   221 @publishedAll

   222 @released

   223 @see TCornerType */

   224 enum TCornerFlags

   225 // Top 16 bits available for corner flags

   226 	{

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

   228 	EWindowCornerNotTL=0x10000,

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

   230 	EWindowCornerNotTR=0x20000,

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

   232 	EWindowCornerNotBL=0x40000,

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

   234 	EWindowCornerNotBR=0x80000,

   235 	};

   236 

   237 /** Window backup type flags.

   238 

   239 @publishedAll

   240 @released

   241 @see RWindowBase::EnableBackup() */

   242 enum TWindowBackupType

   243 	{

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

   245 

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

   247 	EWindowBackupAreaBehind=0x0001,

   248 	/** Backup the entire screen.

   249 

   250 	This is provided for windows that require the rest

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

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

   253 	backed up bitmap. */

   254 	EWindowBackupFullScreen=0x0002,

   255 	};

   256 

   257 /** Types of standard events.

   258 

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

   260 to events that the base passes to the window server.

   261 

   262 @publishedAll

   263 @released

   264 @see CClickMaker */

   265 enum TEventCode

   266 	{

   267 	/** Null event.

   268 

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

   270 	EEventNull,

   271 	/** Key event.

   272 

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

   274 	keyboard.

   275 

   276 	If an EEventKey event is associated with an EEventKeyDown or EEventKeyUp

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

   278 	EEventKeyDown/EEventKeyUp event.

   279 

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

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

   282 	EEventKey,

   283 	/** Key up event.

   284 

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

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

   287 	EEventKeyUp,

   288 	/** Key down event.

   289 

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

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

   292 	EEventKeyDown,

   293 	/** Modifier changed event.

   294 

   295 	This is an event generated by the window server when

   296 	the state of one of the modifier keys changes.

   297 	It is not reported unless explicitly requested by a window.

   298 

   299 	@see RWindowTreeNode::EnableModifierChangedEvents(). */

   300 	EEventModifiersChanged,

   301 	/** Pointer event.

   302 

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

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

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

   306 	EEventPointer,			//5

   307 	/** Pointer enter event.

   308 

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

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

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

   312 	the pointer into the window. */

   313 	EEventPointerEnter,

   314 	/** Pointer exit event.

   315 

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

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

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

   319 	the pointer out of the window. */

   320 	EEventPointerExit,

   321 	/** Pointer move buffer ready event.

   322 

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

   324 	EEventPointerBufferReady,

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

   326 	with the TCaptureFlagDragDrop flag set. */

   327 	EEventDragDrop,

   328 	/** Focus lost event.

   329 

   330 	Occurs when a window group loses keyboard focus. */

   331 	EEventFocusLost,		//10

   332 	/** Focus gained event.

   333 

   334 	Occurs when a window group gains keyboard focus. */

   335 	EEventFocusGained,

   336 	/** On event.

   337 

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

   339 

   340 	@see RWindowTreeNode::EnableOnEvents(). */

   341 	EEventSwitchOn,

   342 	/** Password event.

   343 

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

   345 	window of the currently active password window.

   346 

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

   348 	before any further actions can be performed.

   349 

   350 	@deprecated	*/

   351 	EEventPassword,

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

   353 	and whenever a window group's name changes

   354 

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

   356 

   357 	@see RWindowTreeNode::EnableGroupChangeEvents(). */

   358 	EEventWindowGroupsChanged,

   359 	/** Error event.

   360 

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

   362 	of errors.

   363 

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

   365 

   366 	@see RWindowTreeNode::EnableErrorMessages(). */

   367 	EEventErrorMessage,		//15

   368 	/** Message ready event.

   369 

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

   371 	EEventMessageReady,

   372 	EEventMarkInvalid,	// For internal use only

   373 	/** Off event.

   374 

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

   376 	base.

   377 

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

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

   380 

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

   382 	EEventSwitchOff,

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

   384 	EEventKeySwitchOff,

   385 	/** Screen size mode change event.

   386 

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

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

   389 	EEventScreenDeviceChanged, //20

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

   391 

   392 	Requested by RWindowTreeNode::EnableFocusChangeEvents(). */

   393 	EEventFocusGroupChanged,

   394 	/** Case opened event.

   395 

   396 	This event is sent to those windows that have requested EEventSwitchOn

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

   398 	on first. */

   399 	EEventCaseOpened,

   400 	/** Case closed event.

   401 

   402 	This event is sent to those windows that have requested EEventSwitchOff

   403 	events.

   404 

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

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

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

   408 	EEventCaseClosed,

   409 	/** Window group list change event.

   410 

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

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

   413 	reorderings.

   414 

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

   416 	EEventWindowGroupListChanged,

   417 	/** The visibility of a window has changed

   418 

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

   420 	to another window obscuring them.

   421 

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

   423 	EEventWindowVisibilityChanged,

   424 #ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

   425 	/** Restart event.

   426 	

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

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

   429 	

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

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

   432 	

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

   434 	EEventRestartSystem,

   435 #endif

   436 	/** The display state or configuration has changed

   437 	

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

   439 	(mode change) will trigger this event.

   440 	

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

   442 	 */

   443 	EEventDisplayChanged = EEventWindowVisibilityChanged+2,

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

   445 	/** Repeating key event.

   446 

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

   448 	a repeating key event.

   449 

   450 	@see CClickMaker */

   451 	EEventKeyRepeat=100,

   452 	EEventGroupWindowOpen,

   453 	EEventGroupWindowClose,

   454 	EEventWindowClose,

   455 	//Codes for events only passed into anim dlls

   456 	/** Direct screen access begin

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

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

   459 	EEventDirectScreenAccessBegin=200,

   460 	/** Direct screen access end

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

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

   463 	EEventDirectScreenAccessEnd,

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

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

   466 	EEventHeartbeatTimerStateChange,

   467 

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

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

   470 	EEventPowerMgmt = 900,

   471 	EEventReserved = 910,

   472 

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

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

   475 

   476 	/** User defined event.

   477 

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

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

   480 	of different clients.

   481 

   482 	@see RWs::SendEventToWindowGroup(). */

   483 	EEventUser=1000,

   484 

   485 	};

   486 

   487 

   488 /** Window server hot keys.

   489 

   490 @publishedAll

   491 @released

   492 @see RWsSession::SetHotKey() */

   493 enum THotKey

   494 	{

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

   496 

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

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

   499 

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

   501 	EHotKeyEnableLogging,

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

   503 

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

   505 	EHotKeyDisableLogging,

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

   507 	enabled in order to do this.)

   508 

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

   510 	EHotKeyStateDump,

   511 	/** Kills the foreground application.

   512 

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

   514 	EHotKeyOfDeath,

   515 	/** Shuts down the window server.

   516 

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

   518 

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

   520 	EHotKeyShutDown,

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

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

   523 

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

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

   526 

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

   528 	EHotKeyHeapDump,

   529 	/** Increases the LCD contrast.

   530 

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

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

   533 	EHotKeyIncContrast,

   534 	/** Decreases the LCD contrast.

   535 

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

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

   538 	EHotKeyDecContrast,

   539 	/** Switches the machine off.

   540 

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

   542 	EHotKeyOff,

   543 	/** Switches the backlight on.

   544 

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

   546 	in e32keys.h. */

   547 	EHotKeyBacklightOn,

   548 	/** Switches the backlight off.

   549 

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

   551 	in e32keys.h. */

   552 	EHotKeyBacklightOff,

   553 	/** Toggles the backlight.

   554 

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

   556 	enum in e32keys.h. */

   557 	EHotKeyBacklightToggle,

   558 	/** Switches to screen size 0.

   559 

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

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

   562 	EHotKeyScreenDimension0,

   563 	/** Switches to screen size 1.

   564 

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

   566 	flipping. */

   567 	EHotKeyScreenDimension1,

   568 	/** Switches to screen size 2. */

   569 	EHotKeyScreenDimension2,

   570 	/** Switches to screen size 3. */

   571 	EHotKeyScreenDimension3,

   572 	/** Cycles the display though its possible sizes.

   573 

   574 	This is used only for debugging.

   575 

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

   577 	example a phone that supports screen flipping will have different display

   578 	sizes when the cover is opened and closed.

   579 

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

   581 	EHotKeyCycleDisplaySize,

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

   583 	size mode you are in.

   584 

   585 	For example, phones that support screen flipping may

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

   587 

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

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

   590 	many you want.

   591 

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

   593 

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

   595 	EHotKeyCycleOrientation,

   596 	/** Increases the screen's brightness.

   597 

   598 	The brightness wraps around to the minimum

   599 	value after it has reached the maximum. */

   600 	EHotKeyIncBrightness,

   601 	/** Decreases the screen's brightness.

   602 

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

   604 	EHotKeyDecBrightness,

   605 

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

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

   608 	reaches the last screen.

   609 

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

   611 	EHotKeyCycleFocusScreen,

   612 

   613 	/** Value for first hot key.

   614 

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

   616 	through all the different key values. */

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

   618 	/** Value for last hot key.

   619 

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

   621 	through all the different key values. */

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

   623 	};

   624 

   625 

   626 /** Password mode flags.

   627 

   628 @publishedAll

   629 @deprecated */

   630 enum TPasswordMode

   631 	{

   632 	/** Releases ownership of password handling.

   633 

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

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

   636 	window. */

   637 	EPasswordCancel,

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

   639 	can become the password window. */

   640 	EPasswordNone,

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

   642 

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

   644 	before any further actions can be performed. */

   645 	EPasswordOnceADay,

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

   647 	EPasswordAlways,

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

   649 	instant password check. */

   650 	EPasswordAlwaysTriggerNow,

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

   652 	an instant password check. */

   653 	EPasswordOnceADayTriggerNow,

   654 	};

   655 enum TPriorities {

   656            /**

   657            Defines the value EAllPriorities.

   658            */

   659            EAllPriorities=KMinTInt,

   660            };

   661 

   662 /** Sprite flags.

   663 

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

   665 

   666 @publishedAll

   667 @released

   668 @see RWsPointerCursor::Construct()

   669 @see RWsSprite::Construct() */

   670 enum TSpriteFlags

   671 	{

   672 	/** Flash sprite on and off.

   673 

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

   675 	ESpriteFlash=0x1,

   676 	/** This flag no longer has any effect.

   677 	

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

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

   680 	ESpriteNoChildClip=0x2,

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

   682 	screen.

   683 

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

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

   686 	ESpriteNoShadows=0x4

   687 	};

   688 

   689 struct TSpriteMember

   690 /** Sprite member.

   691 

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

   693 can be added to a sprite or pointer cursor.

   694 @publishedAll

   695 @released */

   696 	{

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

   698 	interval specified by iInterval.

   699 

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

   701 	by iInterval. */

   702 	CFbsBitmap *iBitmap;

   703 	/** The bitmap mask.

   704 

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

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

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

   708 	sprite or cursor.

   709 

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

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

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

   713 

   714 	Note:

   715 

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

   717 	out operation becomes inefficient. */

   718 	CFbsBitmap *iMaskBitmap;

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

   720 	is to be inverted. */

   721 	TBool iInvertMask;

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

   723 	CGraphicsContext::TDrawMode iDrawMode;

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

   725 

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

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

   728 	TPoint iOffset;

   729 	/** Time interval for which iBitmap is displayed.

   730 

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

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

   733 	TTimeIntervalMicroSeconds32 iInterval;

   734 	};

   735 

   736 /** Event reporting control.

   737 

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

   739 reported.

   740 

   741 @publishedAll

   742 @released

   743 @see RWindowTreeNode::EnableOnEvents()

   744 @see RWindowTreeNode::EnableModifierChangedEvents()

   745 @see RWindowTreeNode::EnableErrorMessages() */

   746 enum TEventControl

   747 	{

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

   749 	EEventControlAlways,

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

   751 	focus. */

   752 	EEventControlOnlyWithKeyboardFocus,

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

   754 	are visible on the screen. */

   755 	EEventControlOnlyWhenVisible

   756 	};

   757 

   758 /** Pointer event filter types.

   759 

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

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

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

   763 down event.

   764 

   765 @publishedAll

   766 @released

   767 @see RWindowBase::PointerFilter() */

   768 enum TPointerFilter

   769 	{

   770 	//Basic Types

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

   772 	EPointerFilterEnterExit=0x1,

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

   774 	EPointerFilterMove=0x2,

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

   776 	EPointerFilterDrag=0x4,

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

   778 

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

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

   781 	EPointerGenerateSimulatedMove=0x8,

   782 	//Combinations of the above

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

   784 	move event before each pen down event.

   785 

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

   787 	below to turn on simulated moves:

   788 

   789 	@code

   790 	win->PointerFilter(EPointerMoveEvents, EPointerGenerateSimulateMoves)

   791 	@endcode

   792 	@see RWindowBase::PointerFilter() */

   793 	EPointerMoveEvents=EPointerFilterMove|EPointerGenerateSimulatedMove,

   794 	};

   795 

   796 struct TKeyEvent

   797 /** Key event details.

   798 

   799 When processing a TKeyEvent, the TStdScanCode in iScanCode should usually

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

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

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

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

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

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

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

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

   808 

   809 @publishedAll

   810 @released */

   811 	{

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

   813 

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

   815 	TUint iCode;

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

   817 

   818 	Standard scan codes are defined in TStdScanCode. */

   819 	TInt iScanCode;

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

   821 	TUint iModifiers;

   822 	/** Count of auto repeats generated.

   823 

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

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

   826 	TInt iRepeats;

   827 	};

   828 

   829 struct TModifiersChangedEvent

   830 /** Details of changed modifier keys.

   831 

   832 @publishedAll

   833 @released

   834 @see TWsEvent::ModifiersChanged() */

   835 	{

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

   837 	in TEventModifier. */

   838 	TUint iChangedModifiers;

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

   840 	defined in TEventModifier. */

   841 	TUint iModifiers;

   842 	};

   843 

   844 struct TWsVisibilityChangedEvent

   845 /** Visibility changed events.

   846 

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

   848 revealed after being obscured.

   849 @publishedAll

   850 @released

   851 @see RWindowTreeNode::EnableVisibilityChangeEvents() */

   852 		{

   853 	enum

   854 		{

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

   856 		@deprecated Use EPartiallyVisible instead. */

   857 		ECanBeSeen = 0x01,

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

   859 		@deprecated Use ENotVisible instead. */

   860 		ECantBeSeen = 0x02,

   861 		};

   862 	enum

   863 		{

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

   865 		EPartiallyVisible = 0x01,

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

   867 		ENotVisible = 0x02,

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

   869 		EFullyVisible = 0x04,

   870 		};

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

   872 	TUint iFlags;

   873 	};

   874 

   875 struct TWsDisplayChangedEvent

   876 /** Display changed events.

   877 

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

   879 current resolution or backgound (change the current configuration).

   880 @publishedAll

   881 @released

   882 @see MDisplayControl::EnableDisplayChangeEvents() */

   883 	{

   884 	/**

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

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

   887 	

   888 	 @see CWsScreenDevice::Construct(TInt)

   889 	 */

   890 	TInt iDisplayNumber;

   891 	/**

   892 	 Opaque value that changes when the current display configuration

   893 	 has changed.

   894 	 

   895 	 Compare values in subsequent events to determine whether the

   896 	 current resolution has changed since the last event.

   897 	 */

   898 	TInt iConfigurationChangeId;

   899 	/**

   900 	 Opaque value that changes when the resolution list has changed.

   901 	 

   902 	 Compare values in subsequent events to determine whether the list

   903 	 of available resolutions has changed since the last event.

   904 	 

   905 	 @see MDisplayControlBase::GetResolutions

   906 	 */

   907 	TInt iResolutionListChangeId;	

   908 	};

   909 

   910 struct TWsErrorMessage

   911 /** Error event details.

   912 

   913 @publishedAll

   914 @released

   915 @see RWindowTreeNode::EnableErrorMessages() */

   916 	{

   917 	/** Error event types */

   918 	enum TErrorCategory

   919 		{

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

   921 		for a particular window.

   922 

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

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

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

   926 		EDrawingRegion,

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

   928 

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

   930 		EBackLight,

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

   932 		ELogging,

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

   934 		EContrast,

   935 		};

   936 	/** The error category. */

   937 	TErrorCategory iErrorCategory;

   938 	/** The error code */

   939 	TUint iError;

   940 	};

   941 

   942 class TWsRedrawEvent

   943 /** Window server redraw event.

   944 

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

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

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

   948 

   949 @publishedAll

   950 @released

   951 @see RWsSession::GetRedraw() */

   952 	{

   953 public:

   954 	inline TUint Handle() const;

   955 	inline TRect Rect() const;

   956 public:

   957 	void SetHandle(TUint aHandle);

   958 	void SetRect(TRect aRect);

   959 protected:

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

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

   962 	};

   963 

   964 class TWsPriorityKeyEvent

   965 /** Priority key events.

   966 

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

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

   969 

   970 @publishedAll

   971 @released */

   972 	{

   973 public:

   974 	inline TKeyEvent *Key() const;

   975 	inline TUint Handle() const;

   976 	inline void SetHandle(TUint aHandle);

   977 protected:

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

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

   980 	};

   981 

   982 class TWsEvent

   983 /** Window server event.

   984 

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

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

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

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

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

   990 

   991 @publishedAll

   992 @released */

   993 	{

   994 public:

   995 	/** Event data size. */

   996 	enum

   997 		{

   998 		/**

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

  1000 		Note: this value is 32 bytes.*/

  1001 		EWsEventDataSize=sizeof(TAdvancedPointerEvent)

  1002 		};

  1003 public:

  1004 	inline TWsEvent();

  1005 	inline TAdvancedPointerEvent* Pointer() const;

  1006 	inline TKeyEvent* Key() const;

  1007 	inline TModifiersChangedEvent* ModifiersChanged() const;

  1008 	inline TWsVisibilityChangedEvent* VisibilityChanged();

  1009 	inline const TWsVisibilityChangedEvent* VisibilityChanged() const;

  1010 	inline TWsDisplayChangedEvent* DisplayChanged();

  1011 	inline const TWsDisplayChangedEvent* DisplayChanged() const;

  1012 	inline TWsErrorMessage* ErrorMessage() const;

  1013 	inline TUint8* EventData() const;

  1014 	inline TInt Type() const;

  1015 	inline TUint Handle() const;

  1016 	inline TTime Time() const;

  1017 	inline void SetType(TInt aType);

  1018 	inline void SetHandle(TUint aHandle);

  1019 	inline void SetTimeNow();

  1020 	inline TInt* Int() const;

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

  1022 	IMPORT_C void SetPointerNumber(TUint8 aPointerNumber);

  1023 	IMPORT_C void SetPointerZ(TInt aZ);

  1024 protected:

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

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

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

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

  1029 	};

  1030 

  1031 

  1032 class RWsPointerCursor;

  1033 

  1034 /** Pointer cursor mode flags.

  1035 

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

  1037 for the pointer cursor.

  1038 

  1039 @publishedAll

  1040 @released

  1041 @see RWsSession::SetPointerCursorMode()

  1042 @see RWsSession::PointerCursorMode() */

  1043 enum TPointerCursorMode

  1044 	{

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

  1046 	EPointerCursorNone,

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

  1048 	EPointerCursorFixed,

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

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

  1051 	EPointerCursorNormal,

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

  1053 	one. */

  1054 	EPointerCursorWindow,

  1055 	/** First pointer cursor mode.

  1056 

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

  1058 	EPointerCursorFirstMode=EPointerCursorNone,

  1059 	/** The final pointer cursor mode.

  1060 

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

  1062 	updated if more modes are added. */

  1063 	EPointerCursorLastMode=EPointerCursorWindow,

  1064 	};

  1065 

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

  1067 

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

  1069 

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

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

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

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

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

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

  1076 

  1077 @publishedAll

  1078 @released

  1079 @see RWindowGroup::CaptureLongKey() */

  1080 enum TLongCaptureFlags

  1081 	{

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

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

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

  1085 	to generate a long key event). */

  1086 	ELongCaptureShortEventImmediately=0x01,

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

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

  1089 	ELongCaptureRepeatEvents=0x02,

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

  1091 	unset. */

  1092 	ELongCaptureNormal=ELongCaptureShortEventImmediately,

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

  1094 	ELongCaptureWaitShort=0,

  1095 	};

  1096 

  1097 

  1098 class TIpcArgs;

  1099 class TReadDescriptorType;

  1100 class TWriteDescriptorType;

  1101 class CWindowGc;

  1102 class RWsSession;

  1103 

  1104 class TWsGraphicId

  1105 /** Identifies an abstract artwork

  1106 

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

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

  1109 access the pixel representation of that artwork directly.

  1110 

  1111 @publishedAll

  1112 @released */

  1113 	{

  1114 public:

  1115 	enum TUninitialized

  1116 		{

  1117 		EUninitialized

  1118 		};

  1119 	TWsGraphicId(TUninitialized): iFlags(0) {}

  1120 	IMPORT_C TWsGraphicId(TUid aUid);

  1121 	IMPORT_C TWsGraphicId(TInt aId);

  1122 	IMPORT_C TWsGraphicId(const TWsGraphicId& aCopy);

  1123 	IMPORT_C TUid Uid() const;

  1124 	IMPORT_C TBool IsUid() const;

  1125 	IMPORT_C void Set(TUid aUid);

  1126 	IMPORT_C TInt Id() const;

  1127 	IMPORT_C TBool IsId() const;

  1128 	IMPORT_C void Set(TInt aId);

  1129 	IMPORT_C TInt Compare(const TWsGraphicId& aOther) const;

  1130 private:

  1131 	friend class CWsGraphic;

  1132 	TUint iFlags;

  1133 	TInt iId;

  1134 	TInt iWsGraphicIdSpare[2];