--- a/epoc32/include/w32std.h Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/w32std.h Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,2967 @@
-w32std.h
+// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.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
+
+_LIT(KWSERVThreadName,"Wserv");
+
+/**
+@internalAll
+*/
+_LIT(KWSERVServerName,"!Windowserver");
+
+class RWindowBase;
+class RWindow;
+class RWsBuffer;
+class MWsObjectProvider;
+
+/** Used for testing purpose.
+
+@internalComponent
+@released
+*/
+class TSizeMode
+ {
+public:
+ inline TSizeMode(){}
+ inline TSizeMode(TSize& aSize);
+ static inline TInt ScaledCord(TInt aOrigin,TInt aScale);
+ inline TPoint ScaledOrigin();
+public:
+ CFbsBitGc::TGraphicsOrientation iRotation;
+ TPoint iOrigin;
+ TSize iScreenSize;
+ TSize iScreenTwipsSize;
+ TUint iAlternativeRotations;
+ TRect iPointerCursorArea;
+ TSize iScreenScale;
+ TDisplayMode iDefaultDisplayMode;
+ };
+
+/** 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, or uses the pointer to switch on the device. If the current input
+ type (see TXYInputType) is "mouse" or "relative mouse", i.e. it generates
+ pointer move events as well as drag events, then this event type is also
+ generated whenever the pointer is moved. */
+ 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
+ //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,
+ };
+struct TTextCursor
+/** Text cursor parameter information.
+
+A text cursor is a rectangular area which can be set to flash. It is normally
+only visible when the window group which owns it has the keyboard focus. This
+structure is used to define the parameters of a text cursor, which can be
+selected for use through the window group using RWindowGroup::SetTextCursor().
+
+Custom (non-rectangular) text cursors are supported from v7.0s. They are added
+to the window server using RWsSession::SetCustomTextCursor(), after which
+they can be selected for use through the window group, in the same way as
+standard rectangular cursors. They have a unique identifier, stored in the
+iType member, which must be greater than ETypeLastBasic. Custom text cursors
+are clipped to their iHeight and iWidth values. Their iColour member is not
+used.
+
+@publishedAll
+@released */
+ {
+ // The different normal text cursors
+ // A Text cursor can either be a predefined one
+ // or a general sprite. Cursors between ETypeFirst
+ // and ETypeLastBasic are predefined ones (even though
+ // the ones above ETypeLast do not exist and are
+ // for future use)
+ /** Cursor type values.
+
+ The values between ETypeFirst and ETypeLastBasic are reserved for predefined
+ cursors. Custom text cursors must have a value greater than ETypeLastBasic.
+
+ The values not listed below are for internal use only. */
+ enum ENamedCursors
+ {
+ /** @internalAll */
+ ETypeNone,
+ /** Standard filled rectangular cursor. */
+ ETypeRectangle,
+ /** Standard hollow rectangular cursor. */
+ ETypeHollowRectangle,
+ /** The first predefined cursor type.
+
+ Equivalent to ETypeRectangle. This can be used for iterating through the predefined
+ cursor types. */
+ ETypeFirst=ETypeRectangle,
+ /** The last predefined cursor type.
+
+ Equivalent to ETypeHollowRectangle. This can be used for iterating through
+ the predefined cursor types. */
+ ETypeLast=ETypeHollowRectangle,
+ /** Reserved for future use.
+
+ All custom text cursors must have a type value greater than this. */
+ ETypeLastBasic = 1000,
+ };
+ /** Added for compatibility with previous releases. */
+ typedef TInt EType;
+ /** Cursor flash and clipping flags.
+
+ The flags not listed below are for internal use only. */
+ enum EFlags
+ {
+ /** The text cursor should not flash. */
+ EFlagNoFlash = 0x00000001,
+ /** The bitmap of each sprite member is clipped left of its x-origin and right of
+ its x-origin plus iWidth.
+
+ Used for custom text cursors only. */
+ EFlagClipHorizontal = 0x00000002,
+ /** The bitmap of each sprite member is clipped vertically.
+
+ How it is clipped depends on the text cursor's vertical alignment, see the
+ TCustomTextCursorAlignment enum in class RWsSession.
+
+ Used for custom text cursors only. */
+ EFlagClipVertical = 0x00000004,
+ /** @internalComponent */
+ EUserFlags = 0x0000FFFF,
+ /** @internalComponent */
+ EFlagClipped = 0x00010000,
+ /** @internalComponent */
+ EPrivateFlags = 0xFFFF0000,
+ };
+ /** The cursor type.
+
+ For possible values, see the ENamedCursors enum. */
+ TInt iType;
+ /** The height of the text cursor.
+
+ This value is also used for clipping custom text cursors, if the EFlagClipVertical
+ flag is set. */
+ TInt iHeight;
+ /** The ascent of the text cursor (the distance between the origin and the top). */
+ TInt iAscent;
+ /** The width of the text cursor.
+
+ Custom text cursors are clipped to this value, if the EFlagClipHorizontal
+ flag is set. */
+ TInt iWidth;
+ /** Cursor flash and clipping flags.
+
+ For possible values, see the EFlags enum. */
+ TUint iFlags;
+ /** The colour of the text cursor.
+
+ If the cursor is flashing, this colour is XOR'd with the screen.
+
+ This value is not used for custom text cursors. */
+ TRgb iColor;
+ };
+
+/** 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,
+ /** With this flag set, the sprite is displayed over the window and all its children.
+
+ Without the flag, the sprite is only displayed over the window's visible area.
+
+ This is particularly useful when the sprite is owned by a window group, as
+ it means the sprite will be displayed over the whole screen.
+
+ Notes:
+
+ By default a sprite is clipped to the visible region of the window that owns
+ it.
+
+ Sprites with this flag set are displayed in front of sprites without this
+ flag. */
+ 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,
+ /** @internalComponent */
+ ESpriteNonSystemFlags=0x0000FFFF,
+ /** @internalComponent */
+ ESpriteSystemFlags= 0xFFFF0000,
+ /** @internalComponent */
+ ESpritePointer=0x10000,
+ /** @internalComponent */
+ ESpriteOOM=0x20000,
+ /** @internalComponent */
+ ESpriteDisabled=0x40000,
+ /** @internalComponent */
+ ESpriteActive=0x80000,
+ };
+
+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 TPointerEvent
+/** Pointer event details.
+
+The function TWsEvent::Pointer() is used to get this structure for a pointer
+event.
+
+@publishedAll
+@released */
+ {
+/** Pointer event types.
+
+Note that the user actions that cause these events will vary according to
+the type of pointing device used. */
+ enum TType
+ {
+ /** Button 1 or pen down. */
+ EButton1Down,
+ /** Button 1 or pen up. */
+ EButton1Up,
+ /** Button 2 down.
+
+ This is the middle button of a 3 button mouse. */
+ EButton2Down,
+ /** Button 2 up.
+
+ This is the middle button of a 3 button mouse. */
+ EButton2Up,
+ /** Button 3 down. */
+ EButton3Down,
+ /** Button 3 up. */
+ EButton3Up,
+ /** Drag event.
+
+ These events are only received when button 1 is down. */
+ EDrag,
+ /** Move event.
+
+ These events are only received when button 1 is up and the XY input mode is
+ not pen. */
+ EMove,
+ /** Button repeat event. */
+ EButtonRepeat,
+ /** Switch on event caused by a screen tap. */
+ ESwitchOn,
+ };
+ /** The type of pointer event. */
+ TType iType;
+ /** The state of the modifier keys, defined in TEventModifier. */
+ TUint iModifiers; // State of pointing device and associated buttons
+ /** Co-ordinates of the pointer event relative to the origin of the window it occurred
+ in.
+
+ Positive co-ordinates indicate a position to the right of and down from
+ the window's origin, negative co-ordinates indicate a position to the left
+ and up. */
+ TPoint iPosition;
+ /** Co-ordinates of the pointer event relative to the parent window of the window
+ it occurred in.
+
+ Positive co-ordinates indicate a position to the right of and down from the window's
+ origin, negative co-ordinates indicate a position to the left and up. */
+ TPoint iParentPosition;
+ };
+
+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 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;
+ };
+
+struct TWsGraphicMessageHeaderEvent
+/** @internalComponent @released */
+ {
+ TInt iClientHandle;
+ TInt iDataLen;
+ };
+
+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:
+ /** @internalComponent */
+ TUint iHandle;
+ /** @internalComponent */
+ TRect iRect; // Rectangle to redraw
+ };
+
+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:
+ /** @internalComponent */
+ TUint iHandle;
+ /** @internalComponent */
+ TUint8 iEventData[sizeof(TKeyEvent)];
+ };
+
+class TWsEvent
+/** Window server event.
+
+All events generated by the window server, except redraw events and priority
+key events, are delivered to the client in a TWsEvent. The client obtains
+the TWsEvent by calling RWsSession::GetEvent(). The type of data contained
+in the TWsEvent depends on the type of event. The client can inquire the event
+type using Type(), and then retrieve the appropriate type of data.
+
+@publishedAll
+@released */
+ {
+public:
+ /** Event data size. */
+ enum
+ {
+ /** The size of a TPointerEvent.
+
+ This is the maximum number of bytes of data that can be returned by EventData().
+ Note: this value is 24 bytes.*/
+ EWsEventDataSize=sizeof(TPointerEvent)+8
+ };
+public:
+ inline TPointerEvent* Pointer() const;
+ inline TKeyEvent* Key() const;
+ inline TModifiersChangedEvent* ModifiersChanged() const;
+ inline TWsVisibilityChangedEvent* VisibilityChanged();
+ inline const TWsVisibilityChangedEvent* VisibilityChanged() const;
+ inline TWsErrorMessage* ErrorMessage() const;
+ inline TUint8* EventData() const;
+ inline TInt Type() const;
+ inline TUint Handle() const;
+ inline TTime Time() const;
+ inline void SetType(TInt aType);
+ inline void SetHandle(TUint aHandle);
+ inline void SetTimeNow();
+ inline TInt* Int() const;
+protected:
+ /** @internalComponent */
+ TInt iType;
+ /** @internalComponent */
+ TUint iHandle;
+ /** @internalComponent */
+ TTime iTime;
+ /** @internalComponent */
+ TUint8 iEventData[EWsEventDataSize];
+ };
+
+
+class RWsPointerCursor;
+
+/** Pointer cursor mode flags.
+
+These flags define the current cursor mode, and hence which sprite to use
+for the pointer cursor.
+
+@publishedAll
+@released
+@see RWsSession::SetPointerCursorMode()
+@see RWsSession::PointerCursorMode() */
+enum TPointerCursorMode
+ {
+ /** Don't have a pointer cursor. */
+ EPointerCursorNone,
+ /** The default system pointer cursor is used whenever there is a pointer cursor. */
+ EPointerCursorFixed,
+ /** The default system pointer cursor is used unless the window the pointer cursor
+ is above specifies one, in which case that cursor is used. */
+ EPointerCursorNormal,
+ /** There is no pointer cursor unless the pointer is above a window that has specified
+ one. */
+ EPointerCursorWindow,
+ /** First pointer cursor mode.
+
+ This is used in test code for iterating though available modes. */
+ EPointerCursorFirstMode=EPointerCursorNone,
+ /** The final pointer cursor mode.
+
+ This is used in test code for iterating though available modes. It will be
+ updated if more modes are added. */
+ EPointerCursorLastMode=EPointerCursorWindow,
+ };
+
+/** Flags which customise a long key press capture request made by a window group.
+
+These flags are passed to RWindowGroup::CaptureLongKey().
+
+Two things can be configured using this enum: the normal key event that is
+generated immediately, and the long key event that is generated after a short
+time interval. The normal key event can be sent immediately (on key down)
+to the application with keyboard focus, or, if the key is not held down long
+enough to generate a long key event, when the key is released. The long key
+event can be customised to generate a single key event only, or to auto repeat.
+
+@publishedAll
+@released
+@see RWindowGroup::CaptureLongKey() */
+enum TLongCaptureFlags
+ {
+ /** If specified, the normal ("short") key event is sent immediately (on key down)
+ to the application with keyboard focus. If not specified, the normal key event
+ is sent when the key is released (if the key is not held down long enough
+ to generate a long key event). */
+ ELongCaptureShortEventImmediately=0x01,
+ /** If specified, causes the long key press to automatically repeat. If not specified,
+ the long key press will generate a single key event only. */
+ ELongCaptureRepeatEvents=0x02,
+ /** Equivalent to ELongCaptureShortEventImmediately being set and the other flags
+ unset. */
+ ELongCaptureNormal=ELongCaptureShortEventImmediately,
+ /** Equivalent to the first two values being unset. */
+ ELongCaptureWaitShort=0,
+ };
+
+
+class TIpcArgs;
+class TReadDescriptorType;
+class TWriteDescriptorType;
+class CWindowGc;
+
+class TWsGraphicId
+/** Identifies an abstract artwork
+
+This is a piece of artwork that might be owned and authored by another process.
+A client can draw a piece of artwork, but that doesn't confer the ability to
+access the pixel representation of that artwork directly.
+
+@publishedAll
+@released */
+ {
+public:
+ enum TUninitialized
+ {
+ EUninitialized
+ };
+ TWsGraphicId(TUninitialized): iFlags(0) {}
+ IMPORT_C TWsGraphicId(TUid aUid);
+ IMPORT_C TWsGraphicId(TInt aId);
+ IMPORT_C TWsGraphicId(const TWsGraphicId& aCopy);
+ IMPORT_C TUid Uid() const;
+ IMPORT_C TBool IsUid() const;
+ IMPORT_C void Set(TUid aUid);
+ IMPORT_C TInt Id() const;
+ IMPORT_C TBool IsId() const;
+ IMPORT_C void Set(TInt aId);
+ IMPORT_C TInt Compare(const TWsGraphicId& aOther) const;
+private:
+ friend class CWsGraphic;
+ TUint iFlags;
+ TInt iId;
+ TInt iWsGraphicIdSpare[2];
+ };
+
+class CWsGraphic: public CBase
+/** Client representation of a window-server-side piece of artwork owned by this Client
+
+@publishedAll
+@released
+*/
+ {
+protected:
+ IMPORT_C CWsGraphic();
+public:
+ IMPORT_C ~CWsGraphic();
+protected:
+ // 2nd phase construction
+ IMPORT_C void BaseConstructL(TUid aUid,TUid aType,const TDesC8& aData);
+ IMPORT_C void BaseConstructL(TUid aType,const TDesC8& aData);
+ IMPORT_C void BaseConstructL(const TWsGraphicId& aReplace,TUid aType,const TDesC8& aData);
+ // sharing between clients
+ IMPORT_C virtual TInt ShareGlobally();
+ IMPORT_C virtual TInt Share(TSecureId aClientId);
+ IMPORT_C virtual TInt UnShare(TSecureId aClientId);
+ IMPORT_C virtual TInt UnShareGlobally();
+public:
+ IMPORT_C const TWsGraphicId& Id() const;
+ IMPORT_C TBool IsActive() const;
+ IMPORT_C void Destroy();
+protected:
+ IMPORT_C void SendMessage(const TDesC8& aData) const;
+ IMPORT_C TInt SendSynchronMessage(const TDesC8& aData) const;
+ IMPORT_C TInt Flush() const;
+ IMPORT_C void SetGraphicExtension(MWsObjectProvider* aExt);
+private:
+ // events from wserv, to be implemented by derived classes
+ /**
+ Handles message from this graphic artwork peer on the server.
+ @param aData Message from peer CWsGraphicDrawer.
+ */
+ virtual void HandleMessage(const TDesC8& aData) = 0;
+
+ /**
+ Handles custom operation when this graphic artwork is replaced. When this method
+ is invoked, the replaced peer CWsGraphicDrawer on the server has been destroyed.
+ */
+ virtual void OnReplace() = 0;
+ IMPORT_C virtual void OnClientClose();
+private:
+ void BaseConstructL();
+ IMPORT_C virtual TInt CWsGraphic_Reserved1();
+ IMPORT_C virtual TInt CWsGraphic_Reserved2();
+ IMPORT_C virtual TInt CWsGraphic_Reserved3();
+public:
+ class CManager;
+private:
+ friend class CManager;
+ class CPimpl;
+ friend class CPimpl;
+ CPimpl* iPimpl;
+ TInt iWsGraphicSpare[2];
+};
+
+class MWsClientClass
+/** Base class for all classes whose objects are clients of the window server.
+
+@publishedAll
+@released */
+ {
+public:
+ MWsClientClass();
+ MWsClientClass(RWsBuffer *aBuffer);
+ inline TInt WsHandle() const;
+protected:
+ void Write(const TAny *aData, TInt aLength,const TAny *aData2, TInt aLength2,TUint aOpcode) const;
+ void Write(const TAny *aBuf, TInt aBufLen,TUint aOpcode) const;
+ void Write(TUint aOpcode) const;
+ void WriteInt(TInt aInt, TUint aOpcode) const;
+ void WriteRect(const TRect &aRect, TUint aOpcode) const;
+ void WritePoint(const TPoint &aPoint, TUint aOpcode) const;
+ void WriteSize(const TSize &aSize, TUint aOpcode) const;
+ TInt WriteReply(TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
+ TInt WriteReplyInt(TInt aInt, TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
+ TInt WriteReply(const TAny *aBuf, TInt aBufLen,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
+ TInt WriteReply(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
+ TInt WriteReplyP(const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
+ TInt WriteReplyIntP(TInt aInt, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
+ TInt WriteReplyP(const TAny *aBuf, TInt aBufLen, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
+ TInt WriteReplyP(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
+ TInt WriteReplyByProvidingRemoteReadAccess(const TAny* aBuf, TInt aBufLen,const TReadDescriptorType& aRemoteReadBuffer,TUint aOpcode) const;
+ void AddToBitmapArray(const TInt aBitmapHandle)const;
+ void AsyncRequest(TRequestStatus& aStatus, TUint aOpcode) const;
+protected:
+ /** @internalComponent*/
+ TInt32 iWsHandle;
+ /** @internalComponent*/
+ RWsBuffer *iBuffer;
+ };
+
+
+class RWindowTreeNode;
+class CWsScreenDevice;
+class CWsBitmap;
+class RAnimDll;
+class RWsSpriteBase;
+class RDirectScreenAccess;
+class RSoundPlugIn;
+
+
+class RWsSession : public MWsClientClass, public RSessionBase
+/** Window server session.
+
+The session between the client and the window server can be used to mediate
+asynchronous events, for client interface control and for system control.
+A description of each of these capabilities is given below.
+
+Mediating asynchronous events:
+
+Primarily, the session mediates asynchronous events to the user. Three event
+streams are available: the standard event stream which all applications must
+use; the redraw event stream which must be used by all applications except
+those which exclusively use backed-up windows; and the priority key event
+stream which may be used for abort keys and the like for specialist applications.
+
+All these events are mediated as standard asynchronous services. Typical window
+server client programs encapsulate each service they require in an active
+object whose RunL() identifies the event and calls the appropriate member
+function of a class associated with an application framework, or a window.
+
+Client interface control:
+
+The client's interface with the window server has several aspects, each of
+which is controlled through the window server session.
+
+Flushing defines how requests to the window server are handled.
+
+System control:
+
+Many system-wide settings may be controlled through the window server session.
+Typically, these functions are only used by the system shell and its associated
+sessions/applications. They include: auto-repeat and double-click, querying
+all window groups in the system, setting the default shadow vector, setting
+the system pointer cursors, counting resources used by the window server
+(this is only useful for debugging checks), getting and setting the state of
+the modifier keys (for instance Shift and Ctrl), and setting the window server
+background colour.
+
+@publishedAll
+@released */
+ {
+ friend class RWsBuffer;
+ friend class RWindowTreeNode;
+ friend class CWsScreenDevice;
+ friend class CWsBitmap;
+ friend class RAnimDll;
+ friend class RWsSpriteBase;
+ friend class RDirectScreenAccess;
+ friend class RSoundPlugIn;
+ friend class CWsGraphic;
+public:
+ /** Compute mode flags.
+
+ When a window group takes focus or loses it, the window server can boost its
+ client's thread or process priority to provide a better response to the user.
+ How it alters the priority is determined by the current compute mode of the
+ client.
+
+ @see ComputeMode() */
+ enum TComputeMode
+ {
+ /** Client priority is permanently set to its current level. It is not altered
+ or set by the windowing system if the focus changes.
+
+ Thus if ComputeMode() is called with this flag when a client is in the foreground,
+ it will subsequently have foreground priority even if it is in the background. */
+ EPriorityControlDisabled,
+ /** Client process's priority is always set to EPriorityBackground. */
+ EPriorityControlComputeOn,
+ /** Client process's priority is set to EPriorityForeground when the window group
+ takes focus, and set to EPriorityBackground when it loses focus.
+
+ This is the default behaviour. */
+ EPriorityControlComputeOff
+ };
+ enum {ESystemInfoArraySize=16};
+ /** Window server logging commands passed to LogCommand().
+
+ @see RWsSession::LogCommand() */
+ enum TLoggingCommand
+ {
+ /** Enables logging. */
+ ELoggingEnable,
+ /** Disables logging. */
+ ELoggingDisable,
+ /** Logs the current status of all the windows in the tree, even if logging is
+ not currently enabled. */
+ ELoggingStatusDump, //Window Tree Dump
+ /** Logs information about the window server's heap size and usage, even if logging
+ is not currently enabled. */
+ ELoggingHeapDump,
+ };
+
+ struct TWindowGroupChainInfo
+ {
+ /*Stores id and Parent id window group
+
+ This is used to define chained window groups's id and it's parent id.
+ An array of these structures is returned by some of the varients of the function WindowGroupList.
+ @publishedAll
+ @released */
+ TInt iId;
+ TInt iParentId;
+ };
+
+ struct SSystemInfo
+ /** @internalComponent */
+ {
+ TInt iInfo[ESystemInfoArraySize];
+ };
+ /** The vertical alignment of a custom text cursor sprite.
+
+ One of these values must be set, see SetCustomTextCursor(). This value also
+ determines which part of each sprite member bitmap is clipped when the cursor's
+ TTextCursor::EFlagClipVertical flag is set. */
+ enum TCustomTextCursorAlignment
+ {
+ /** The y-origin of each sprite member bitmap is aligned with the top of the line. */
+ ECustomTextCursorAlignTop,
+ /** The y-origin of each sprite member bitmap is aligned with the baseline of the
+ line. */
+ ECustomTextCursorAlignBaseline,
+ /** The y-origin of each sprite member bitmap is aligned with the bottom of the
+ line. */
+ ECustomTextCursorAlignBottom
+ };
+//
+public:
+ IMPORT_C RWsSession();
+ IMPORT_C TInt Connect();
+ IMPORT_C TInt Connect(RFs& aFileServer);
+ IMPORT_C void Close();
+ IMPORT_C TVersion Version();
+
+ IMPORT_C TInt SetHotKey(THotKey aType, TUint aKeyCode, TUint aModifierMask, TUint aModifier);
+ IMPORT_C TInt ClearHotKeys(THotKey aType);
+ IMPORT_C TInt RestoreDefaultHotKey(THotKey aType);
+//
+ IMPORT_C void EventReady(TRequestStatus *aStat);
+ IMPORT_C void EventReadyCancel();
+ IMPORT_C void GetEvent(TWsEvent &aEvent);
+ IMPORT_C void PurgePointerEvents();
+//
+ IMPORT_C void RedrawReady(TRequestStatus *aStat);
+ IMPORT_C void RedrawReadyCancel();
+ IMPORT_C void GetRedraw(TWsRedrawEvent &aEvent);
+//
+ IMPORT_C void PriorityKeyReady(TRequestStatus *aStat);
+ IMPORT_C void PriorityKeyReadyCancel();
+ IMPORT_C void GetPriorityKey(TWsPriorityKeyEvent &aEvent);
+//
+ IMPORT_C void Flush();
+ IMPORT_C TBool SetAutoFlush(TBool aState);
+ IMPORT_C TInt SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);
+ IMPORT_C void GetKeyboardRepeatRate(TTimeIntervalMicroSeconds32 &aInitialTime, TTimeIntervalMicroSeconds32 &aTime);
+ IMPORT_C void GetDoubleClickSettings(TTimeIntervalMicroSeconds32 &aInterval, TInt &aDistance);
+ IMPORT_C TInt SetDoubleClick(const TTimeIntervalMicroSeconds32 &aInterval, TInt aDistance);
+//
+ IMPORT_C TInt NumWindowGroups() const;
+ IMPORT_C TInt WindowGroupList(CArrayFixFlat<TInt> *aWindowList);
+ IMPORT_C TInt WindowGroupList(RArray<TWindowGroupChainInfo>* aWindowList);
+ IMPORT_C TInt NumWindowGroups(TInt aPriority) const;
+ IMPORT_C TInt WindowGroupList(TInt aPriority, CArrayFixFlat<TInt> *aWindowList);
+ IMPORT_C TInt WindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowList);
+ IMPORT_C TInt GetFocusWindowGroup();
+ IMPORT_C TInt GetDefaultOwningWindow();
+ IMPORT_C TInt SetWindowGroupOrdinalPosition(TInt aIdentifier, TInt aPosition);
+ IMPORT_C TInt GetWindowGroupClientThreadId(TInt aIdentifier, TThreadId &aThreadId);
+ IMPORT_C TInt GetWindowGroupHandle(TInt aIdentifier);
+ IMPORT_C TInt GetWindowGroupOrdinalPriority(TInt aIdentifier);
+ IMPORT_C TInt SendEventToWindowGroup(TInt aIdentifier, const TWsEvent &aEvent);
+ IMPORT_C TInt SendEventToAllWindowGroups(const TWsEvent &aEvent);
+ IMPORT_C TInt SendEventToAllWindowGroups(TInt aPriority, const TWsEvent &aEvent);
+ IMPORT_C TInt SendEventToOneWindowGroupsPerClient(const TWsEvent &aEvent);
+ IMPORT_C TInt GetWindowGroupNameFromIdentifier(TInt aIdentifier, TDes &aWindowName);
+ IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,const TDesC& aMatch,TInt aOffset=0);
+ IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,TThreadId aThreadId);
+ IMPORT_C TInt SendMessageToWindowGroup(TInt aIdentifier, TUid aUid, const TDesC8 &aParams);
+ IMPORT_C TInt SendMessageToAllWindowGroups(TUid aUid, const TDesC8& aParams);
+ IMPORT_C TInt SendMessageToAllWindowGroups(TInt aPriority, TUid aUid, const TDesC8& aParams);
+ IMPORT_C TInt FetchMessage(TUid &aUid, TPtr8 &aParams, const TWsEvent& aMessageEvent);
+//
+ IMPORT_C void SetShadowVector(const TPoint &aVector);
+ IMPORT_C TPoint ShadowVector() const;
+//
+ IMPORT_C void SetBackgroundColor(TRgb aColor);
+ IMPORT_C TRgb GetBackgroundColor() const;
+//
+ IMPORT_C TInt RegisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface); ///< @publishedPartner
+ IMPORT_C void UnregisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface); ///< @publishedPartner
+ IMPORT_C TInt PreferredSurfaceConfigurationSize(); ///< @publishedPartner
+//
+ IMPORT_C TInt SetSystemPointerCursor(const RWsPointerCursor &aPointerCursor,TInt aCursorNumber);
+ IMPORT_C void ClearSystemPointerCursor(TInt aCursorNumber);
+ IMPORT_C TInt ClaimSystemPointerCursorList();
+ IMPORT_C void FreeSystemPointerCursorList();
+//
+ IMPORT_C TInt SetCustomTextCursor(TInt aIdentifier, const TArray<TSpriteMember>& aSpriteMemberArray, TUint aSpriteFlags, TCustomTextCursorAlignment aAlignment);
+//
+ IMPORT_C TInt ResourceCount();
+ IMPORT_C void PasswordEntered();
+ IMPORT_C void ComputeMode(TComputeMode aMode);
+//
+ IMPORT_C TInt HeapCount() const;
+ IMPORT_C TInt DebugInfo(TInt aFunction, TInt aParam=0) const;
+ IMPORT_C TInt DebugInfo(TInt aFunction, TDes8& aReturnBuf, TInt aParam=0) const;
+ IMPORT_C void HeapSetFail(TInt aTAllocFail,TInt aValue);
+ IMPORT_C TInt SetModifierState(TEventModifier aModifier,TModifierState aState);
+ IMPORT_C TInt GetModifierState() const;
+//
+ IMPORT_C TInt RequestOffEvents(TBool aOn,RWindowTreeNode *aWin=NULL);
+ IMPORT_C TDisplayMode GetDefModeMaxNumColors(TInt& aColor,TInt& aGray) const;
+ IMPORT_C TInt GetColorModeList(CArrayFixFlat<TInt> *aModeList) const;
+//
+ IMPORT_C void SetPointerCursorArea(const TRect& aArea);
+ IMPORT_C void SetPointerCursorArea(TInt aScreenSizeMode,const TRect& aArea);
+ IMPORT_C TRect PointerCursorArea() const;
+ IMPORT_C TRect PointerCursorArea(TInt aScreenSizeMode) const;
+ IMPORT_C void SetPointerCursorMode(TPointerCursorMode aMode);
+ IMPORT_C TInt SetClientCursorMode(TPointerCursorMode aMode);
+ IMPORT_C TPointerCursorMode PointerCursorMode() const;
+ IMPORT_C void SetDefaultSystemPointerCursor(TInt aCursorNumber);
+ IMPORT_C void ClearDefaultSystemPointerCursor();
+ IMPORT_C TInt SetPointerCursorPosition(const TPoint& aPosition);
+ IMPORT_C TPoint PointerCursorPosition() const;
+
+ IMPORT_C void SetDefaultFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);
+ IMPORT_C void PrepareForSwitchOff();
+ IMPORT_C void SetBufferSizeL(TInt aBufSize);
+ IMPORT_C void SetMaxBufferSizeL(TInt aMaxBufSize);
+ IMPORT_C TInt SetSystemFaded(TBool aFaded);
+ IMPORT_C TInt SetSystemFaded(TBool aFaded,TUint8 aBlackMap,TUint8 aWhiteMap);
+
+// Functions for multiple screens
+ IMPORT_C TInt SetFocusScreen(TInt aScreenNumber);
+ IMPORT_C TInt GetFocusScreen();
+ IMPORT_C void ClearAllRedrawStores();
+#if defined(__WINS__)
+// Function for WINS behaviour only
+//
+ IMPORT_C void SetRemoveKeyCode(TBool aRemove);
+ IMPORT_C void SimulateXyInputType(TXYInputType aInputType); //Only for testing WSERV
+#endif
+//
+ IMPORT_C void SimulateRawEvent(TRawEvent aEvent);
+ IMPORT_C void SimulateKeyEvent(TKeyEvent aEvent);
+ IMPORT_C void LogCommand(TLoggingCommand aCommand);
+ IMPORT_C void LogMessage(const TLogMessageText &aMessage);
+//
+// Functions for test code use only
+//
+ IMPORT_C void SystemInfo(TInt &aSystemInfoNumber, SSystemInfo &aSystemInfo);
+ IMPORT_C void TestWrite(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);
+ IMPORT_C void TestWriteReply(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);
+ IMPORT_C void TestWriteReplyP(TInt aHandle,TInt aOpcode,const TAny *aData,TInt aLength,TDes8 *aReplyPackage);
+ IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC8& aRemoteReadBuffer);
+ IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC16& aRemoteReadBuffer);
+
+ IMPORT_C TInt Finish();
+ IMPORT_C void SyncMsgBuf();
+// functions not exported, used by CWsGraphic
+ void GraphicMessageReady(TRequestStatus *aStat);
+ void GetGraphicMessage(TDes8& aData);
+ void GraphicMessageCancel();
+ void GraphicAbortMessage(TInt aError);
+ TInt GraphicFetchHeaderMessage();
+private:
+ TInt doWindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowListCh, TInt aNumOpcode, TInt aListOpcode);
+ TInt doWindowGroupList(TInt aPriority,CArrayFixFlat<TInt>* aWindowListId,TInt aNumOpcode,TInt aListOpcode);
+ TInt doSetHotKey(TInt aOpcode, TInt aType, TUint aKeycode, TUint aModifierMask, TUint aModifiers);
+ void doReadEvent(TRequestStatus *aStat, TInt aOpcode);
+
+private:
+ void connectL();
+ TInt DoFlush(const TIpcArgs& aIpcArgs);
+ TInt DoSyncMsgBuf(const TIpcArgs& aIpcArgs);
+ void DirectAcessActivation(TBool aIsNowActive);
+ };
+
+class RWindowGroup;
+class RWsSprite;
+
+/** @internalComponent */
+typedef TInt (*AnimCommand)(TPtr8 *aBufPtr,TAny *aPackage);
+
+
+class RWindowTreeNode : public MWsClientClass
+/** A handle to a node in the server-side window tree.
+
+This handle class is used as the base for both window groups and the windows
+within them; it is not intended for user derivation, and may not be directly
+constructed: use one of the standard derived classes instead.
+
+@publishedAll
+@released */
+ {
+ friend class RWindowGroup;
+ friend class RWindowBase;
+ friend class CWindowGc;
+ friend class RAnimDll;
+ friend class RWsSprite;
+public:
+ /** Fade control flags.
+
+ These flags define whether fading is applied to all child windows when SetFaded()
+ is called on a window. */
+ enum TFadeControl
+ {
+ /** Include all child windows when fading/un-fading. */
+ EFadeIncludeChildren=ETrue,
+ /** Fade only the parent window.
+
+ Note that a panic will occur if this value is used when SetFaded() is called
+ on a window group. */
+ EFadeWindowOnly=EFalse,
+ };
+protected:
+ RWindowTreeNode();
+ RWindowTreeNode(RWsSession &aWs);
+public:
+ IMPORT_C void Close();
+ IMPORT_C void Destroy();
+ IMPORT_C TUint32 ClientHandle() const;
+ IMPORT_C TUint32 Parent() const;
+ IMPORT_C TUint32 PrevSibling() const;
+ IMPORT_C TUint32 NextSibling() const;
+ IMPORT_C TUint32 Child() const;
+ IMPORT_C TInt OrdinalPriority() const;
+ IMPORT_C TInt OrdinalPosition() const;
+ IMPORT_C TInt FullOrdinalPosition() const;
+ IMPORT_C void SetOrdinalPosition(TInt aPos);
+ IMPORT_C void SetOrdinalPosition(TInt aPos,TInt aOrdinalPriority);
+ IMPORT_C TInt WindowGroupId();
+ IMPORT_C TInt SetPointerCursor(TInt aCursorNumber);
+ IMPORT_C void SetCustomPointerCursor(const RWsPointerCursor &aPointerCursor);
+ IMPORT_C TInt EnableOnEvents(TEventControl aCircumstances=EEventControlOnlyWithKeyboardFocus);
+ IMPORT_C void DisableOnEvents();
+ IMPORT_C TInt EnableGroupChangeEvents();
+ IMPORT_C void DisableGroupChangeEvents();
+ IMPORT_C TInt EnableFocusChangeEvents();
+ IMPORT_C void DisableFocusChangeEvents();
+ IMPORT_C TInt EnableGroupListChangeEvents();
+ IMPORT_C void DisableGroupListChangeEvents();
+ IMPORT_C TInt EnableVisibilityChangeEvents();
+ IMPORT_C void DisableVisibilityChangeEvents();
+ IMPORT_C TInt EnableErrorMessages(TEventControl aCircumstances);
+ IMPORT_C void DisableErrorMessages();
+ IMPORT_C TInt EnableModifierChangedEvents(TUint aModifierMask, TEventControl aCircumstances);
+ IMPORT_C void DisableModifierChangedEvents();
+ IMPORT_C void SetNonFading(TBool aNonFading);
+ IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren);
+ IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren,TUint8 aBlackMap,TUint8 aWhiteMap);
+ IMPORT_C void ClearPointerCursor();
+protected:
+ __DECLARE_TEST;
+ };
+
+
+class TSurfaceId;
+class TSurfaceConfiguration;
+
+class RWindowBase : public RWindowTreeNode
+/** Client-side handle to a server-side window.
+
+The server-side windows of handles derived from this class can be displayed
+on the device's screen, and associated with pointer events.
+
+This class is not for user derivation; however derived classes form part of
+the Window Server API.
+
+@publishedAll
+@released */
+ {
+public:
+ /** Capture behaviour flags.
+
+ @see SetPointerCapture()
+ @see EEventDragDrop */
+ enum TCaptureFlags
+ {
+// Flags, these can be combined to customise pointer capture
+ /** If set, capture is enabled, disabled otherwise. */
+ TCaptureFlagEnabled=0x01,
+ /** If set, drag-drop events are sent to the window in which the pointer was lifted.
+ Drag-drop is a tap-drag-lift sequence. */
+ TCaptureFlagDragDrop=0x02,
+ /** Capture events from windows belonging to any group, not just the group of the
+ window on which the flag was set */
+ TCaptureFlagAllGroups=0x04,
+// States, made up of a set of flags
+ /** Equivalent to disabling all the above flags. */
+ TCaptureDisabled=0,
+ /** Equivalent to TCaptureFlagEnabled. */
+ TCaptureEnabled=TCaptureFlagEnabled,
+ /** Equivalent to the OR of the first three flags. */
+ TCaptureDragDrop=TCaptureFlagEnabled|TCaptureFlagDragDrop|TCaptureFlagAllGroups,
+ };
+protected:
+ RWindowBase();
+ RWindowBase(RWsSession &aWs);
+public:
+ IMPORT_C void Activate();
+ IMPORT_C void SetPosition(const TPoint &point);
+ IMPORT_C TInt SetSizeErr(const TSize &size);
+ IMPORT_C TInt SetExtentErr(const TPoint &point,const TSize &size);
+ IMPORT_C TSize Size() const;
+ IMPORT_C TPoint InquireOffset(const RWindowTreeNode &aWindow) const;
+ IMPORT_C void PointerFilter(TUint32 aFilterMask, TUint32 aFilter);
+ IMPORT_C void SetPointerGrab(TBool aState);
+ IMPORT_C void ClaimPointerGrab(TBool aSendUpEvent=ETrue);
+ IMPORT_C void SetPointerCapture(TInt aFlags);
+ IMPORT_C void SetPointerCapturePriority(TInt aPriority);
+ IMPORT_C TInt GetPointerCapturePriority() const;
+ IMPORT_C void SetVisible(TBool aState);
+ IMPORT_C void SetShadowHeight(TInt aHeight);
+ IMPORT_C void SetShadowDisabled(TBool aState);
+ IMPORT_C TPoint Position() const;
+ IMPORT_C TPoint AbsPosition() const;
+ IMPORT_C TInt SetCornerType(TCornerType aCornerType, TInt aCornerFlags=0);
+ IMPORT_C TInt SetShape(const TRegion &aRegion);
+ IMPORT_C TInt SetRequiredDisplayMode(TDisplayMode aMode);
+ IMPORT_C TDisplayMode DisplayMode();
+ IMPORT_C void EnableBackup(TUint aBackupType=EWindowBackupAreaBehind);
+ IMPORT_C void RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32 aTime,const TRect &aRect);
+ IMPORT_C void CancelPointerRepeatEventRequest();
+ IMPORT_C TInt AllocPointerMoveBuffer(TInt aMaxPoints, TUint aFlags);
+ IMPORT_C void FreePointerMoveBuffer();
+ IMPORT_C void EnablePointerMoveBuffer();
+ IMPORT_C void DisablePointerMoveBuffer();
+ IMPORT_C TInt RetrievePointerMoveBuffer(TDes8 &aBuf);
+ IMPORT_C void DiscardPointerMoveBuffer();
+ IMPORT_C TInt AddKeyRect(const TRect &aRect, TInt aScanCode, TBool aActivatedByPointerSwitchOn);
+ IMPORT_C void RemoveAllKeyRects();
+ IMPORT_C TInt PasswordWindow(TPasswordMode aPasswordMode);
+ IMPORT_C void FadeBehind(TBool aFade);
+ IMPORT_C TBool IsFaded();
+ IMPORT_C TBool IsNonFading();
+ IMPORT_C TInt MoveToGroup(TInt aIdentifier);
+ IMPORT_C TInt SetBackgroundSurface(const TSurfaceId& aSurface); ///< @publishedPartner
+ IMPORT_C TInt SetBackgroundSurface(const TSurfaceConfiguration& aConfiguration, TBool aTriggerRedraw); ///< @publishedPartner
+ IMPORT_C void RemoveBackgroundSurface(TBool aTriggerRedraw); ///< @publishedPartner
+ IMPORT_C TInt GetBackgroundSurface(TSurfaceConfiguration& aConfiguration); ///< @publishedPartner
+ IMPORT_C TRgb KeyColor(); ///< @publishedPartner whilst prototype
+protected:
+ TInt construct(const RWindowTreeNode &parent,TUint32 aHandle, TInt aType, TDisplayMode aDisplayMode);
+ };
+
+
+class RBlankWindow : public RWindowBase
+/** Blank window.
+
+A blank window may have its extent and colour changed, but nothing else may
+be drawn to it. Blank windows provide no functionality that is not provided
+by the RWindow class. However, they are useful when the application requires
+a window that cannot be drawn to, for example a container window.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RBlankWindow();
+ IMPORT_C RBlankWindow(RWsSession &aWs);
+ IMPORT_C TInt Construct(const RWindowTreeNode &parent, TUint32 aHandle);
+ IMPORT_C void SetColor(TRgb aColor);
+ IMPORT_C void SetColor();
+ IMPORT_C void SetSize(const TSize &size);
+ IMPORT_C void SetExtent(const TPoint &point,const TSize &size);
+ };
+
+
+class RDrawableWindow : public RWindowBase
+/** Handle to a drawable window.
+
+This class cannot be constructed directly.
+The two concrete derived classes, RWindow and RBackedUpWindow, allow
+drawing but use different protocols because RWindow relies on the client to
+redraw invalid areas.
+
+@publishedAll
+@released */
+ {
+protected:
+ RDrawableWindow();
+ RDrawableWindow(RWsSession &aWs);
+public:
+ IMPORT_C void Scroll(const TPoint &aOffset);
+ IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset);
+ IMPORT_C void Scroll(const TPoint &aOffset, const TRect &aRect);
+ IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect);
+ IMPORT_C TRect GetDrawRect();
+protected:
+ void SetDrawRect(const TRect &aRect);
+private:
+ void doScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect, TInt aOpcode);
+
+ TRect iDrawRect;
+ };
+
+/** Transparency policies
+
+These policies are to control the behaviour of a transparent window.
+@publishedAll
+@released
+@see RWindow::SetTransparencyPolicy() */
+enum TWsTransparencyPolicy {
+ /** Default behaviour. */
+ ETransparencyDefault,
+ /** Freeze the content of underneath the transparent window to prevent redraw everytime
+ the overlying window changes. */
+ ETransparencyFreezeUnder,
+ };
+
+class RWindow : public RDrawableWindow
+/** Handle to a standard window.
+
+An RWindow is a handle to a server-side window which can be displayed and
+drawn to, and whose redraws are performed by the application.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RWindow();
+ IMPORT_C RWindow(RWsSession &aWs);
+ IMPORT_C TInt Construct(const RWindowTreeNode &parent,TUint32 aHandle);
+ IMPORT_C void BeginRedraw();
+ IMPORT_C void BeginRedraw(const TRect &aRect);
+ IMPORT_C void EndRedraw();
+ IMPORT_C void Invalidate();
+ IMPORT_C void Invalidate(const TRect &aRect);
+ IMPORT_C void GetInvalidRegion(RRegion &aRegion);
+ IMPORT_C void SetBackgroundColor(TRgb aColor);
+ IMPORT_C void SetBackgroundColor();
+ IMPORT_C void SetSize(const TSize &size);
+ IMPORT_C void SetExtent(const TPoint &point,const TSize &size);
+ IMPORT_C void HandleTransparencyUpdate();
+ IMPORT_C TInt SetTransparencyFactor(const TRgb& aTransparencyFactor);
+ IMPORT_C TInt SetTransparencyBitmap(const CFbsBitmap& aTransparencyBitmap);
+ IMPORT_C TInt SetTransparencyWsBitmap(const CWsBitmap& aTransparencyBitmap);
+ IMPORT_C void SetNonTransparent();
+ IMPORT_C void EnableRedrawStore(TBool aEnabled);
+ IMPORT_C TInt SetTransparencyAlphaChannel();
+ IMPORT_C TInt SetTransparentRegion(const TRegion& aRegion);
+ IMPORT_C TInt SetTransparencyPolicy(TWsTransparencyPolicy aPolicy);
+ IMPORT_C TBool IsRedrawStoreEnabled();
+ IMPORT_C void EnableOSB(TBool);
+ IMPORT_C void ClearRedrawStore();
+ };
+
+
+class RBackedUpWindow : public RDrawableWindow
+/** Client-side handle to a drawable window with a backup bitmap.
+
+A backed-up window is associated with a backup bitmap which retains the contents
+of the window. When an area of the window is invalidated, the window server
+uses the bitmap directly to update the window without requiring an application
+redraw. The backup bitmap is owned by the font and bitmap server and resides
+on the font and bitmap server's shared heap, which is accessible to all client
+programs: functions are provided to allow the client application to access
+this bitmap directly and perform updates to the window under application control.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RBackedUpWindow();
+ IMPORT_C RBackedUpWindow(RWsSession &aWs);
+ IMPORT_C TInt Construct(const RWindowTreeNode &parent,TDisplayMode aDisplayMode, TUint32 aHandle);
+ IMPORT_C TInt BitmapHandle();
+ IMPORT_C void UpdateScreen();
+ IMPORT_C void UpdateScreen(const TRegion &aRegion);
+ IMPORT_C void UpdateBackupBitmap();
+ IMPORT_C void MaintainBackup();
+ };
+
+
+class RWindowGroup : public RWindowTreeNode
+/** Client-side handle to a server-side window group.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RWindowGroup();
+ IMPORT_C RWindowGroup(RWsSession &aWs);
+ IMPORT_C TInt Construct(TUint32 aClientHandle);
+ IMPORT_C TInt Construct(TUint32 aClientHandle,TBool aIsFocusable);
+ IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle);
+ IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle,TBool aIsFocusable);
+ IMPORT_C void AllowProcessToCreateChildWindowGroups(TUid aProcessSID);
+ IMPORT_C void EnableReceiptOfFocus(TBool aState);
+ IMPORT_C void AutoForeground(TBool aState);
+ IMPORT_C void SetOrdinalPriorityAdjust(TInt aAdjust);
+ IMPORT_C TInt SetOrdinalPositionErr(TInt aPos,TInt aOrdinalPriority);
+ IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
+ IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier, TInt aPriority);
+ IMPORT_C void CancelCaptureKey(TInt32 aCaptureKey);
+ IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier);
+ IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier, TInt aPriority);
+ IMPORT_C void CancelCaptureKeyUpAndDowns(TInt32 aCaptureKey);
+ IMPORT_C TInt32 CaptureLongKey(TUint aInputKeyCode,TUint aOutputKeyCode,TUint aModifierMask,TUint aModifier
+ ,TInt aPriority,TUint aFlags);
+ IMPORT_C TInt32 CaptureLongKey(TTimeIntervalMicroSeconds32 aRepeatTime,TUint aInputKeyCode,TUint aOutputKeyCode
+ ,TUint aModifierMask,TUint aModifier,TInt aPriority,TUint aFlags);
+ IMPORT_C void CancelCaptureLongKey(TInt32 aCaptureKey);
+ IMPORT_C TInt AddPriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
+ IMPORT_C void RemovePriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
+ IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor);
+ IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor, const TRect &aClipRect);
+ IMPORT_C void CancelTextCursor();
+ IMPORT_C void SetOwningWindowGroup(TInt aIdentifier);
+ IMPORT_C void DefaultOwningWindow();
+ IMPORT_C TInt SetName(const TDesC &aName);
+ IMPORT_C TInt Name(TDes &aWindowName) const;
+ IMPORT_C TInt Identifier() const;
+ IMPORT_C void DisableKeyClick(TBool aState);
+ IMPORT_C TInt EnableScreenChangeEvents();
+ IMPORT_C void DisableScreenChangeEvents();
+ IMPORT_C void SimulatePointerEvent(TRawEvent aEvent);
+ IMPORT_C TInt ClearChildGroup();
+ IMPORT_C TInt SetChildGroup(TInt aId);
+private:
+ TInt32 doCaptureKey(TUint aKey, TUint aModifierMask, TUint aModifiers, TInt aPriority, TInt aOpcode);
+ void doCancelCaptureKey(TInt32 aCaptureKeyHandle, TInt aOpcode);
+ TInt Construct(TInt aIdOfParentWindowGroup,TUint32 aClientHandle,TBool aIsFocusable);
+ };
+
+
+class CWsBitmap : public CFbsBitmap, public MWsClientClass
+/** Window server bitmap.
+
+This is a bitmap to which the window server already has a handle. Functions
+which take a window server bitmap are faster than equivalent functions which
+take a CFbsBitmap.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C CWsBitmap();
+ IMPORT_C CWsBitmap(RWsSession &aWs);
+ IMPORT_C ~CWsBitmap();
+ IMPORT_C TInt Create(const TSize& aSizeInPixels,TDisplayMode aDispMode);
+ IMPORT_C TInt Duplicate(TInt aHandle);
+ IMPORT_C TInt Load(const TDesC& aFileName,TInt32 aId,TBool aShareIfLoaded=ETrue);
+ IMPORT_C void InternalizeL(RReadStream& aStream);
+ IMPORT_C void Reset();
+private:
+ TInt createWsBitmap(TInt aErr);
+ };
+
+class RWsGraphicMsgBuf;
+
+class TWsGraphicMsgFixedBase
+/** Base class for fixed-size messages to be attached to CWindowGc::DrawWsGraphic commands
+@publishedAll
+@released
+*/ {
+public:
+ IMPORT_C TPtrC8 Pckg() const;
+ IMPORT_C TUid TypeId() const;
+ IMPORT_C TInt Size() const;
+protected:
+ IMPORT_C TWsGraphicMsgFixedBase(TUid aTypeId,TInt aSizeOfDerived);
+private:
+ const TUid iTypeId;
+ const TInt iSize;
+ };
+
+class RWsGraphicMsgBuf: private RBuf8
+/** Utility class for building data buffers to be attached to CWindowGc::DrawWsGraphic commands
+Useful when there is more than one piece of data to be attached to the draw command
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RWsGraphicMsgBuf();
+ using RBuf8::Close;
+ using RBuf8::CleanupClosePushL;
+ IMPORT_C TInt Append(TUid aTypeId,const TDesC8& aData);
+ IMPORT_C TInt Append(TUid aTypeId,const TDesC16& aData);
+ IMPORT_C TInt Append(TUid aTypeId,TInt aLen,TPtr8& aPtr);
+ IMPORT_C TInt Append(const TWsGraphicMsgFixedBase& aMsg);
+ IMPORT_C void Remove(TInt aIndex);
+ IMPORT_C TInt Count() const;
+ IMPORT_C TUid TypeId(TInt aIndex) const;
+ IMPORT_C TPtrC8 Data(TInt aIndex) const;
+ IMPORT_C TPtr8 Data(TInt aIndex);
+ IMPORT_C void GetFixedMsg(TWsGraphicMsgFixedBase& aMsg,TInt aIndex) const;
+ IMPORT_C const TDesC8& Pckg() const;
+private:
+ TInt ExpandForAppend(TInt aDataLen);
+ void WriteHeader(TUid aUid,TInt aLen);
+ TInt IntAt(TInt aOfs) const;
+private:
+ TInt iRMsgBufSpare[2];
+ };
+
+
+class CWindowGc : public CBitmapContext, public MWsClientClass
+/** Window graphics context.
+
+Most window graphics context drawing functions map to equivalent CFbsBitGc
+functions. They are implemented on the screen with any co-ordinates being
+relative to the top left corner of the window. However extra clipping is applied.
+The drawing will always be clipped to the visible part of the window. In addition
+it will be clipped to the non-invalid part if you are not doing a redraw and
+to the region being validated if you are doing a redraw.
+
+Note:
+
+In general, server side functions which encounter conditions which would normally
+cause a leave, do not leave but instead return an error value indicating the
+leave condition. In this way the leave can be handled on the appropriate side
+of the client/server boundary. For example, a client can choose to wrap server
+calls with User::LeaveIfError(), which causes a leave with the specified
+error.
+
+The above advice is true of many functions in this class, and in its derived
+classes.
+
+@publishedAll
+@released
+@see CGraphicsContext */
+ {
+ friend class CWsScreenDevice;
+public:
+ IMPORT_C CWindowGc(CWsScreenDevice *aDevice);
+ IMPORT_C virtual ~CWindowGc();
+ IMPORT_C virtual TInt Construct();
+ IMPORT_C virtual void Activate(RDrawableWindow &aDevice);
+ IMPORT_C virtual void Deactivate();
+//====================FROM CGraphicsContext.H===============================
+ IMPORT_C virtual CGraphicsDevice* Device() const;
+ IMPORT_C virtual void SetOrigin(const TPoint &aPoint=TPoint(0,0));
+ IMPORT_C virtual void SetDrawMode(TDrawMode aDrawingMode);
+ IMPORT_C virtual void SetClippingRect(const TRect& aRect);
+ IMPORT_C virtual void CancelClippingRect();
+ IMPORT_C virtual void Reset();
+
+ IMPORT_C virtual void UseFont(const CFont *aFont);
+ IMPORT_C virtual void DiscardFont();
+ IMPORT_C virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle);
+ IMPORT_C virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);
+// Used to do justified text properly
+ IMPORT_C virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps);
+// Used primarily to get accurate WYSIWYG
+ IMPORT_C virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars);
+
+ IMPORT_C virtual void SetPenColor(const TRgb &aColor);
+ IMPORT_C virtual void SetPenStyle(TPenStyle aPenStyle);
+ IMPORT_C virtual void SetPenSize(const TSize& aSize);
+
+ IMPORT_C virtual void SetBrushColor(const TRgb &aColor);
+ IMPORT_C virtual void SetBrushStyle(TBrushStyle aBrushStyle);
+ IMPORT_C virtual void SetBrushOrigin(const TPoint &aOrigin);
+ IMPORT_C virtual void UseBrushPattern(const CFbsBitmap *aDevice);
+ IMPORT_C virtual void DiscardBrushPattern();
+//
+// Move the internal position, as used by DrawLineTo & DrawLineBy, and set by MoveTo,
+// MoveBy, DrawLine, DrawLineTo, DrawLineBy and DrawPolyline
+ IMPORT_C virtual void MoveTo(const TPoint &aPoint);
+ IMPORT_C virtual void MoveBy(const TPoint &aPoint);
+ IMPORT_C virtual void Plot(const TPoint &aPoint);
+//
+// Line drawing subject to pen color, width and style and draw mode
+ IMPORT_C virtual void DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
+ IMPORT_C virtual void DrawLine(const TPoint &aPoint1,const TPoint &aPoint2);
+ IMPORT_C virtual void DrawLineTo(const TPoint &aPoint);
+ IMPORT_C virtual void DrawLineBy(const TPoint &aPoint);
+ IMPORT_C virtual void DrawPolyLine(const CArrayFix<TPoint> *aPointList);
+ IMPORT_C virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints);
+//
+// Filled outlines
+// Outlines subject to pen color, width and style and draw mode
+// (set pen to ENullPen for no outline)
+// Fill subject to brush style (color, hash or pattern) and origin and
+// drawing mode (set brush to ENullBrush for no fill)
+ IMPORT_C virtual void DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
+ IMPORT_C virtual void DrawEllipse(const TRect &aRect);
+ IMPORT_C virtual void DrawRect(const TRect &aRect);
+ IMPORT_C virtual void DrawRoundRect(const TRect &aRect,const TSize &aEllipse);
+ IMPORT_C virtual TInt DrawPolygon(const CArrayFix<TPoint> *aPointList,TFillRule aFillRule=EAlternate);
+ IMPORT_C virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate);
+//
+// Uses the bitmap's Twips size and does a "stretch" blit in general
+ IMPORT_C virtual void DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice);
+ IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice);
+ IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect);
+ IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask);
+ IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CWsBitmap* aBitmap, const TRect& aSourceRect, const CWsBitmap* aMaskBitmap, TBool aInvertMask);
+//
+// Text drawing subject to drawing mode
+// Subject to used font, pen color, drawing mode,
+// word and char justification
+ IMPORT_C virtual void DrawText(const TDesC &aBuf,const TPoint &aPos);
+//
+// Subject to same as above plus brush for background
+// (set brush to ENullBrush for no effect on background)
+ IMPORT_C virtual void DrawText(const TDesC &aBuf,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);
+//================Extra functions from CBitmapContext==============
+ IMPORT_C virtual void Clear();
+ IMPORT_C virtual void Clear(const TRect &aRect);
+ IMPORT_C virtual void CopyRect(const TPoint &anOffset,const TRect &aRect);
+ IMPORT_C virtual void BitBlt(const TPoint &aPos, const CFbsBitmap *aBitmap);
+ IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource);
+ IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask);
+ IMPORT_C virtual void BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap);
+ IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CWsBitmap *aBitmap, const TRect &aSource);
+ IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CWsBitmap *aBitmap,const TRect& aSourceRect,const CWsBitmap *aMaskBitmap,TBool aInvertMask);
+ IMPORT_C virtual void MapColors(const TRect& aRect,const TRgb* aColors,TInt aNumPairs=2,TBool aMapForwards=ETrue);
+
+ IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp);
+ IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);
+//=================Extra functions specific to wserv GDI==============
+ IMPORT_C virtual void SetDitherOrigin(const TPoint& aPoint);
+ IMPORT_C virtual TInt SetClippingRegion(const TRegion &aRegion);
+ IMPORT_C virtual void CancelClippingRegion();
+ IMPORT_C virtual void SetOpaque(TBool aDrawOpaque=ETrue);
+//=================Functions also supplied by CFbsBitGc==============
+ IMPORT_C virtual void SetFaded(TBool aFaded);
+ IMPORT_C virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);
+ IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt);
+ IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp, const TRect& aSrcRect, const CWsBitmap* aAlphaBmp, const TPoint& aAlphaPt);
+
+protected:
+ IMPORT_C TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);
+
+private:
+
+ IMPORT_C void Reserved_CGraphicsContext_2();
+
+ IMPORT_C void Reserved_CBitmapContext_1();
+ IMPORT_C void Reserved_CBitmapContext_2();
+ IMPORT_C void Reserved_CBitmapContext_3();
+
+public:
+ IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect);
+ IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect,const TDesC8& aData);
+
+private:
+ IMPORT_C virtual void Reserved_CWindowGc_3();
+ IMPORT_C virtual void Reserved_CWindowGc_4();
+ IMPORT_C virtual void Reserved_CWindowGc_5();
+
+////=============================================================
+private: // Private code
+ TRgb Color(TInt aOpcode)const;
+ void SetJustification(TInt aExcessWidth,TInt aNumGaps, TInt aOpcode);
+ void DrawArcOrPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd, TInt aOpcode);
+ void doDrawPolyLine(const CArrayFix<TPoint> *aPointArray, const TPoint* aPointList,TInt aNumPoints);
+ TInt doDrawPolygon(const CArrayFix<TPoint> *aPointArray,const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule);
+ void WriteTextPos(TInt aOpcode,TInt aOpcodePtr,const TPoint &aPos,const TDesC &aBuf) const;
+ void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC &aBuf,TInt aOpcode,TInt aOpcodePtr) const;
+ void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC8 &aBuf,TInt aOpcode,TInt aOpcodePtr) const;
+ void APIExGetUnderlineMetrics(TAny*& aOutput);
+ TInt APIExSetShadowColor(TAny* aShadowColor);
+
+private: // Private data
+ CFbsFont *iFont;
+ CWsScreenDevice *iDevice;
+ };
+
+
+class CWsScreenDevice : public CBitmapDevice, public MWsClientClass
+/** Software device screen.
+
+An object of this class can be used to enquire or set parameters of the software
+screen, and determine the physical limits of the device.
+
+CWsScreenDevice gives access to the list of screen modes. These are the combinations
+of screen rotation and screen size supported by the device. One of them is
+selected as the current screen mode. The possible screen modes are initialised
+in wsini.ini.
+
+@publishedAll
+@released
+@see CFbsScreenDevice */
+ {
+public:
+ /** Whether or not to include sprites when comparing areas of the screen*/
+ enum TSpriteInCompare
+ {
+ /** This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,
+ const TRect &aRect2,TUint aFlags).
+ When called with the value ERemoveSprite if there are any sprites visible in the areas of the screen being compared then these
+ will not be included in the comparison.
+ The function CWsScreenDevice::RectCompare(const TRect &aRect1,const TRect &aRect2) will not include
+ sprites in the comparison.
+ */
+ ERemoveSprite=0,
+ /** This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,
+ const TRect &aRect2,TUint aFlags).
+ When called with the value EIncludeSprite if there are any sprites visible in the areas of the screen being compared then these
+ will be included in the comparison.*/
+ EIncludeSprite=1,
+ /** This enum can be specified as the 3rd parameter to CWsScreenDevice::RectCompare(const TRect &aRect1,
+ const TRect &aRect2,TUint aFlags).
+ When called with the value EIncludeTextCursor if there are any text cursors visible in the areas of the screen being compared then these
+ will be included in the comparison.*/
+ EIncludeTextCursor=2
+ };
+public:
+ IMPORT_C CWsScreenDevice();
+ IMPORT_C CWsScreenDevice(RWsSession &aWs);
+ IMPORT_C ~CWsScreenDevice();
+ IMPORT_C TInt Construct();
+ IMPORT_C TInt Construct( TInt aDefaultScreenNumber ) ;
+//==== From CGraphicsDevice ====//
+ IMPORT_C TDisplayMode DisplayMode() const;
+ IMPORT_C TSize SizeInPixels() const;
+ IMPORT_C TSize SizeInTwips() const;
+ IMPORT_C TInt HorizontalTwipsToPixels(TInt aTwips) const;
+ IMPORT_C TInt VerticalTwipsToPixels(TInt aTwips) const;
+ IMPORT_C TInt HorizontalPixelsToTwips(TInt aPixels) const;
+ IMPORT_C TInt VerticalPixelsToTwips(TInt aPixels) const;
+ IMPORT_C TRect PointerRect() const;
+ IMPORT_C TInt CreateContext(CGraphicsContext *&aGc);
+ inline TInt CreateContext(CWindowGc*& aGc);
+ IMPORT_C virtual TInt GetNearestFontInTwips(CFont*& aFont,const TFontSpec& aFontSpec);
+ IMPORT_C virtual TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec);
+ IMPORT_C virtual TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);
+ IMPORT_C TInt NumTypefaces() const;
+ IMPORT_C void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const;
+ IMPORT_C TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const;
+// ==== From CBitmapDevice ====//
+ IMPORT_C void GetPixel(TRgb& aColor,const TPoint& aPixel) const;
+ IMPORT_C void GetScanLine(TDes8& aScanLine,const TPoint& aStartPixel,TInt aPixelLength, TDisplayMode aDispMode) const;
+ IMPORT_C TInt AddFile(const TDesC& aName,TInt& aId);
+ IMPORT_C void RemoveFile(TInt aId=0);
+ IMPORT_C virtual TInt GetNearestFontInPixels(CFont*& aFont,const TFontSpec& aFontSpec);
+ IMPORT_C virtual TInt GetNearestFontToDesignHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec);
+ IMPORT_C virtual TInt GetNearestFontToMaxHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);
+ IMPORT_C TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const;
+ IMPORT_C void ReleaseFont(CFont* aFont);
+//===== From CFbsScreenDevice ====//
+ IMPORT_C void PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const;
+ IMPORT_C void SetPalette(CPalette* aPalette);
+ IMPORT_C TInt GetPalette(CPalette*& aPalette) const;
+//===== Extra functions ====//
+ IMPORT_C TInt SetCustomPalette(const CPalette* aPalette);
+ IMPORT_C TInt GetFontById(CFont*& aFont,TUid aUid,const TAlgStyle& aAlgStyle);
+ IMPORT_C TBool RectCompare(const TRect &aRect1,const TRect &aRect2);
+ IMPORT_C TBool RectCompare(const TRect& aRect1,const TRect &aRect2,TUint aFlags) const;
+ IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap) const;
+ IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap, const TRect &aRect) const;
+ IMPORT_C TInt SetBackLight(TBool aBackLight);
+//===== Screen Rotation functions ====//
+ IMPORT_C void SetScreenSizeAndRotation(const TPixelsTwipsAndRotation &aSizeAndRotation);
+ IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsTwipsAndRotation &aSizeAndRotation) const;
+ IMPORT_C void SetScreenSizeAndRotation(const TPixelsAndRotation &aSizeAndRotation);
+ IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsAndRotation &aSizeAndRotation) const;
+ IMPORT_C TScreenModeEnforcement ScreenModeEnforcement() const;
+ IMPORT_C void SetScreenModeEnforcement(TScreenModeEnforcement aMode) const;
+ IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsTwipsAndRotation &aSizeAndRotation) const;
+ IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsAndRotation &aSizeAndRotation) const;
+ IMPORT_C void SetCurrentRotations(TInt aMode, CFbsBitGc::TGraphicsOrientation aRotation) const;
+ IMPORT_C TInt GetRotationsList(TInt aMode, CArrayFixFlat<TInt> *aRotationList) const;
+ IMPORT_C TInt NumScreenModes() const;
+ IMPORT_C void SetScreenMode(TInt aMode);
+ IMPORT_C TInt CurrentScreenMode() const;
+ IMPORT_C void SetAppScreenMode(TInt aMode);
+ IMPORT_C TPoint GetDefaultScreenModeOrigin() const;
+ IMPORT_C TPoint GetScreenModeOrigin(TInt aMode) const;
+ IMPORT_C TSize GetCurrentScreenModeScale() const;
+ IMPORT_C TSize GetScreenModeScale(TInt aMode) const;
+ IMPORT_C TPoint GetCurrentScreenModeScaledOrigin() const;
+ IMPORT_C TPoint GetScreenModeScaledOrigin(TInt aMode) const;
+ IMPORT_C TInt GetScreenSizeModeList(RArray<TInt>* aModeList);
+ IMPORT_C TDisplayMode GetScreenModeDisplayMode(const TInt &aMode) const;
+//===== Used for testing purpose only ====//
+ IMPORT_C TSizeMode GetCurrentScreenModeAttributes() const;
+ IMPORT_C void SetCurrentScreenModeAttributes(const TSizeMode &aModeAtt);
+ IMPORT_C TInt GetScreenNumber() const;
+private: // Private data
+ CFbsTypefaceStore* iTypefaceStore;
+ TSize iPhysicalScreenSizeInTwips;
+ TSize iDisplaySizeInPixels;
+ friend class CWindowGc;
+ };
+
+
+class RWsSpriteBase : public MWsClientClass
+// Client side class base class for sprites and pointer cursors
+/** Sprite base class.
+
+Unless stated otherwise, references to sprites in the documentation for this class also
+apply to pointer cursors.
+
+@publishedAll
+@released
+@see RWsSprite
+@see RWsPointerCursor */
+ {
+protected:
+ IMPORT_C RWsSpriteBase();
+ IMPORT_C RWsSpriteBase(RWsSession &aWs);
+public:
+ IMPORT_C TInt Activate();
+ IMPORT_C TInt AppendMember(const TSpriteMember &aMemberData);
+ IMPORT_C void UpdateMember(TInt aIndex);
+ IMPORT_C TInt UpdateMember(TInt aIndex, const TSpriteMember &aMemberData);
+ IMPORT_C void Close();
+ };
+
+
+class RWsSprite : public RWsSpriteBase
+/** Sprite.
+
+This class defines functions to create and initialise a sprite, and to set
+its position.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RWsSprite();
+ IMPORT_C RWsSprite(RWsSession &aWs);
+ IMPORT_C TInt Construct(RWindowTreeNode &aWindow, const TPoint &aPos, TInt aFlags);
+ IMPORT_C void SetPosition(const TPoint &aPos);
+ };
+
+
+class RWsPointerCursor : public RWsSpriteBase
+/** Pointer cursor.
+
+The pointer cursor is created in a similar way to a sprite. After creating it,
+one or more sprite members containing the bitmaps to be displayed are added.
+
+After a pointer cursor has been created and activated, it does not become
+visible until the application calls RWindowTreeNode::SetPointerCursor() or
+RWindowTreeNode::SetCustomPointerCursor(). The pointer cursor's origin automatically
+tracks the position of the pointing device, and the origin forms the pointer
+cursor's "hot spot", i.e., the point whose co-ordinates are sent to the client
+if a pointer event occurs. If the pointer cursor's bitmap needs to extend
+to the left or upwards from the pointer position, its sprite member should
+be given a negative offset in TSpriteMember::iOffset.
+
+Note:
+
+Pointer cursors are rarely used in pure pen architectures, but they are supported
+for mouse or tablet use.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C RWsPointerCursor();
+ IMPORT_C RWsPointerCursor(RWsSession &aWs);
+ IMPORT_C TInt Construct(TInt aFlags);
+ };
+
+
+class RAnim;
+
+
+class RAnimDll : public MWsClientClass
+/** Client-side interface to the server-side animation DLL.
+
+This is the client side class matching the server side CAnimDLL class. It
+provides functions to create, load, close and destroy a server-side CAnimDll
+object.
+
+@publishedAll
+@released
+@see CreateCAnimDllL()
+@see CAnimDll */
+ {
+public:
+ IMPORT_C RAnimDll();
+ IMPORT_C virtual ~RAnimDll();
+ IMPORT_C RAnimDll(RWsSession &aWs);
+ IMPORT_C TInt Load(const TDesC &aFileName);
+ IMPORT_C void Destroy();
+ IMPORT_C virtual void Close();
+private:
+ TInt CommandReply(TInt aHandle, TInt aOpcode, const TIpcArgs* aIpcArgs=NULL);
+ TInt CommandReply(TInt aHandle, TInt aOpcode, const TDesC8& aArgs, const TIpcArgs* aIpcArgs=NULL);
+ void Command(TInt aHandle, TInt aOpcode, const TPtrC8 &aArgs);
+ void Command(TInt aHandle, TInt aOpcode);
+ void AsyncCommandReply(TRequestStatus& aStatus, TInt aOpcode, TIpcArgs& aIpcArgs);
+ TInt CreateInstance(TInt32& aHandle, const MWsClientClass &aDevice, TInt aType, const TDesC8 &aArgs, TInt aOpcode, const TIpcArgs* aIpcArgs);
+ void DestroyInstance(TInt aHandle);
+private:
+ friend class RAnim;
+ };
+
+
+class RAnim
+/** Client-side handle to a server-side animation class.
+
+This class should be sub-classed to provide a client side interface to the
+server side animation DLL. The server side animation DLL is derived from CAnim.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C virtual ~RAnim();
+ IMPORT_C virtual void Close();
+ IMPORT_C void Destroy();
+protected:
+ IMPORT_C RAnim();
+ IMPORT_C RAnim(RAnimDll &aDll);
+ IMPORT_C TInt Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams);
+ IMPORT_C TInt Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs);
+ IMPORT_C TInt Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams);
+ IMPORT_C TInt Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs);
+ IMPORT_C TInt CommandReply(TInt aOpcode);
+ IMPORT_C TInt CommandReply(TInt aOpcode, const TPtrC8 &aArgs);
+ IMPORT_C TInt CommandReply(TInt aOpcode, const TDesC8& aArgs, const TIpcArgs& aIpcArgs);
+ IMPORT_C void Command(TInt aOpcode, const TPtrC8 &aArgs);
+ IMPORT_C void Command(TInt aOpcode);
+ IMPORT_C void AsyncCommandReply(TRequestStatus& aRequestStatus,TInt aOpcode, const TIpcArgs& aIpcArgs);
+private:
+ TInt32 iHandle;
+ RAnimDll *iAnimDll;
+ };
+
+class CDsaMsgQueue;
+
+class RDirectScreenAccess : public MWsClientClass
+/** The interface between an application that directly accesses the screen and
+the window server.
+
+Note that most applications that need to access the screen directly should
+use CDirectScreenAccess instead. RDirectScreenAccess only needs to be used
+directly by applications without access to an active scheduler.
+
+@publishedAll
+@released */
+ {
+public:
+ /** Provides the reason why direct screen access must terminate. This enum is used
+ in the MAbortDirectScreenAccess::AbortNow() and MDirectScreenAccess::Restart()
+ functions.
+
+ The first value (ETerminateCancel) indicates that direct screen access is
+ being terminated by the application. The final three values indicate that
+ direct screen access is being terminated by the window server. Note that
+ for users of CDirectScreenAccess, the termination code is not important
+ because these issues are dealt with by CDirectScreenAccess::StartL(). */
+ enum TTerminationReasons
+ {
+ /** The application has finished direct screen access. */
+ ETerminateCancel,
+ /** A window is about to come in front of a part of the area that is being used
+ for direct screen access. */
+ ETerminateRegion,
+ /** The screen's color depth (as enumerated by TDisplayMode) is about to change. */
+ ETerminateScreenMode,
+ /** The current screen mode (the combination of screen rotation and screen size)
+ is about to change. */
+ ETerminateRotation,
+ };
+ /** The priority of the active object that responds to notification that direct
+ screen access must stop. */
+ enum TPriority
+ {
+ /** A suggested value for the priority of the active object that responds to notification
+ from the window server that direct screen access must stop. This is also the
+ value used by CDirectScreenAccess for this purpose. */
+ EPriorityVeryHigh=2000,
+ };
+public:
+ IMPORT_C RDirectScreenAccess();
+ IMPORT_C RDirectScreenAccess(RWsSession& aWs);
+ IMPORT_C TInt Construct();
+ IMPORT_C TInt Request(RRegion*& aRegion,TRequestStatus& aStatus,const RWindowBase& aWindow);
+ IMPORT_C void Completed();
+ IMPORT_C void Cancel();
+ IMPORT_C void Close();
+private:
+ RWsSession* iWs;
+ CDsaMsgQueue* iMsgQueue;
+ // To maintain BC we need the following
+ RThread iWsThread;
+ TRequestStatus* iDummyRequest;
+ };
+
+
+class MAbortDirectScreenAccess
+/** The interface for terminating direct screen access.
+
+An object of a class which implements this interface should be passed to CDirectScreenAccess::NewL().
+
+@publishedAll
+@released
+@see MDirectScreenAccess */
+ {
+public:
+ /** This function is called by the window server when direct screen access must
+ stop (for example because a dialogue is moved in front of the area where direct
+ screen access is taking place).
+
+ In response to this, direct screen access must stop immediately. In simple cases,
+ this will involve cancelling the active object that is driving the drawing to the
+ screen.
+
+ No attempt to call a Window Server API function can be made from
+ AbortNow(), because then a temporary deadlock will occur. This is because WSERV
+ is waiting to receive the client's acknowledgment that it has aborted, and so will
+ not be able to service the call. As soon as the restriction no longer applies,
+ the function Restart() will be called.
+
+ @param aReason The reason why direct screen access was terminated. */
+ virtual void AbortNow(RDirectScreenAccess::TTerminationReasons aReason)=0;
+ };
+
+
+class MDirectScreenAccess : public MAbortDirectScreenAccess
+/** The interface for restarting direct screen access.
+
+The Restart() function is called by the window server as soon as direct screen
+access can resume. It is called after the window server has called AbortNow().
+
+An object of the derived class is passed to CDirectScreenAccess::NewL().
+
+@publishedAll
+@released
+@see CDirectScreenAccess::NewL() */
+ {
+public:
+ /** This function is called by the window server as soon as direct screen access
+ can resume.
+
+ This function should call CDirectScreenAccess::StartL() within a trap harness.
+ If this leaves, e.g. through lack of memory, direct screen access cannot be
+ restarted. StartL() re-calculates the clipping region, so that if direct screen
+ access was aborted because another window appeared in front of it, that window
+ will not be overwritten when direct screen access resumes.
+
+ In this function, you can resume calls to Window Server Client Side API functions.
+
+ @param aReason Provides the reason why direct screen access was terminated. */
+ virtual void Restart(RDirectScreenAccess::TTerminationReasons aReason)=0;
+ };
+
+
+class CDirectScreenAccess : public CActive
+/** An active object used to start direct screen access.
+
+Direct screen access is a way of drawing to the screen without using the window
+server. As this avoids client-server communication, it is much faster, and
+may be useful for games and video. Note that some interaction with the window
+server is needed in order to prevent the application from drawing over other
+application's data.
+
+The object's (private) RunL() function is called by the window server in order
+to abort direct screen access. This might occur when another window needs
+to be displayed in front or when the window with direct screen access is moved.
+The active object's priority is RDirectScreenAccess::EPriorityVeryHigh so
+that direct screen access will be aborted as quickly as possible.
+
+@publishedAll
+@released */
+ {
+public:
+ IMPORT_C static CDirectScreenAccess* NewL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWin,MDirectScreenAccess& aAbort);
+ ~CDirectScreenAccess();
+ IMPORT_C void StartL();
+ inline CFbsBitGc* Gc();
+ inline CFbsScreenDevice*& ScreenDevice();
+ inline RRegion* DrawingRegion();
+private:
+ enum TFlags
+ {
+ EDirectCheckModeChange=0x1,
+ EDirectCheckSizeModeChange=0x2,
+ };
+private:
+ inline CDirectScreenAccess(RWsSession& aWs,CWsScreenDevice* aScreenDevice,RWindowBase& aWindow,MDirectScreenAccess& aAbort);
+ void ConstructL(RWsSession& aWs);
+ void CreateScreenObjectsL(TDisplayMode aCurrentMode);
+ void UpdateSizeAndRotation(CFbsBitGc* aGc);
+ static TInt Restart(TAny* aDirect);
+ void Restart();
+ //Pure virtual functions from CActive
+ void DoCancel();
+ void RunL();
+private:
+ CFbsBitGc* iGc;
+ CFbsScreenDevice* iScreenDevice;
+ RRegion* iDrawingRegion;
+ RWindowBase& iWindow;
+ CWsScreenDevice* iWsScreenDevice;
+ MDirectScreenAccess& iAbort;
+ RDirectScreenAccess iDirectAccess;
+ RDirectScreenAccess::TTerminationReasons iReason;
+ CIdle* iRestart;
+ TSize iScreenSize;
+ TBool iAborting;
+ TUint iFlags;
+ TInt iScreenNumber;
+ };
+
+
+class RSoundPlugIn : public MWsClientClass
+/** Client interface to the key or pointer click plug-in DLL.
+
+The plug-in DLL implements the CClickMaker class.
+
+@publishedAll
+@released
+@see CClickMaker */
+ {
+public:
+ /** A possible return value for CommandReply(). */
+ enum
+ {
+ /** The value returned by CommandReply() if no plug-in is loaded,
+ or if the plug-in identified by the aUid parameter in Construct() is not loaded.
+ Its value is set to KMinTInt so that it should not clash with any other expected
+ return value from this function. */
+ ESoundWrongPlugIn=KMinTInt
+ };
+public:
+ IMPORT_C RSoundPlugIn();
+ IMPORT_C RSoundPlugIn(RWsSession &aWs);
+ IMPORT_C TInt Construct(TUid aUid=KNullUid);
+ IMPORT_C void Close();
+ IMPORT_C void Destroy();
+ IMPORT_C TBool IsLoaded(TBool& aIsChangeable);
+ IMPORT_C TInt Unload();
+ IMPORT_C TInt Load(const TDesC &aFileName);
+ IMPORT_C void SetKeyClick(TBool aEnabled);
+ IMPORT_C void SetPenClick(TBool aEnabled);
+ IMPORT_C TBool KeyClickEnabled();
+ IMPORT_C TBool PenClickEnabled();
+ IMPORT_C TInt CommandReply(TInt aOpcode, const TPtrC8 &aArgs);
+ };
+
+inline TInt MWsClientClass::WsHandle() const
+ /** Gets the server side handle for the object.
+
+ @return The server-side handle for the object. */
+ {return(iWsHandle);}
+
+inline TInt CWsScreenDevice::CreateContext(CWindowGc *&aGc)
+ /** Creates a graphics context for this device.
+
+ This function always causes a flush of the window server buffer.
+
+ @param aGc On successful return, contains a new graphics context referring
+ to this screen device.
+ @return KErrNone if successful, otherwise one of the system-wide error codes.
+ @see CGraphicsDevice::CreateContext() */
+ {return(CreateContext((CGraphicsContext *&)aGc));}
+
+inline TUint TWsRedrawEvent::Handle() const
+ /** Gets the handle of the window which is the target of the redraw event.
+
+ This is the handle that was passed to the window's Construct() function: typically
+ it will be a pointer to the object owning the window, providing access to
+ its member functions.
+
+ @return The window's handle. */
+ {return(iHandle);}
+
+inline TRect TWsRedrawEvent::Rect() const
+ /** Gets the rectangle to redraw.
+
+ @return The rectangle that needs redrawing. Co-ordinates are relative to
+ the window whose handle is given by Handle(). */
+ {return(iRect);}
+
+inline TPointerEvent *TWsEvent::Pointer() const
+ /** Gets the pointer event.
+
+ This function can be used to get information about the pointer event if Type()
+ returns an event of type EEventPointer. or EEventDragDrop.
+
+ @return Structure containing pointer event data. */
+ {return((TPointerEvent *)&iEventData);}
+
+inline TKeyEvent *TWsEvent::Key() const
+ /** Gets the key event.
+
+ This function can be used to get information about the key event if Type()
+ returns an event of type EEventKey, EEventKeyUp or EEventKeyDown.
+
+ @return Structure containing key event data */
+ {return((TKeyEvent *)&iEventData);}
+
+inline TWsVisibilityChangedEvent* TWsEvent::VisibilityChanged()
+ /** Gets information about the visibility changed event.
+
+ This function can be used to get information about the visibility changed event
+ if Type() returns an event of type EEventWindowVisibilityChanged.
+
+ @return Structure containing visibility changed event data */
+ { return reinterpret_cast<TWsVisibilityChangedEvent*>(iEventData); }
+
+inline const TWsVisibilityChangedEvent* TWsEvent::VisibilityChanged() const
+ /** Gets information about the visibility changed event.
+
+ This function can be used to get information about the visibility changed event
+ if Type() returns an event of type EEventWindowVisibilityChanged.
+
+ @return Structure containing visibility changed event data */
+ { return reinterpret_cast<const TWsVisibilityChangedEvent*>(iEventData); }
+
+inline TModifiersChangedEvent *TWsEvent::ModifiersChanged() const
+ /** Gets information about the modifier changed event.
+
+ This function can be used to get information about the modifier changed event
+ if Type() returns an event of type EEventModifiersChanged.
+
+ @return Structure containing modifier changed event data */
+ {return((TModifiersChangedEvent *)&iEventData);}
+
+inline TWsErrorMessage *TWsEvent::ErrorMessage() const
+ /** Gets an error event.
+
+ This function can be used to get information about the error event if Type()
+ returns an event of type EEventErrorMessage.
+
+ @return The error event. */
+ {return((TWsErrorMessage *)&iEventData);}
+
+inline TUint8 *TWsEvent::EventData() const
+ /** Gets information about the event.
+
+ This function gives you direct access to the event data as a whole. The event
+ can be a key or pointer event or it could be a new special event that only
+ you and another application know about. You are limited to EWsEventDataSize
+ bytes worth of data.
+
+ @return A pointer to the event data. */
+ {return((TUint8 *)&iEventData);}
+
+inline TInt TWsEvent::Type() const
+ /** Gets the type of event that occurred.
+
+ @return The event type. Event types are defined in TEventCode. */
+ {return(iType);}
+
+inline TUint TWsEvent::Handle() const
+ /** Gets the window handle.
+
+ This is the handle that was passed to the window's Construct() function: typically
+ it will be a pointer to the client-side object owning the window, providing
+ access to its member functions.
+
+ @return The window handle. */
+ {return(iHandle);}
+
+inline TTime TWsEvent::Time() const
+ /** Gets the time when the event occurred.
+
+ @return The time when the event occurred. */
+ {return(iTime);}
+
+inline void TWsEvent::SetType(TInt aType)
+ /** Sets the event type.
+
+ @param aType The event type. Event types are defined in TEventCode. */
+ {iType=aType;}
+
+inline void TWsEvent::SetHandle(TUint aHandle)
+ /** Sets the event handle.
+
+ This is the client handle of the window that is being sent the event.
+
+ @param aHandle The event handle. */
+ {iHandle=aHandle;}
+
+inline void TWsEvent::SetTimeNow()
+ /** Sets the event time to the current time. */
+ {iTime.UniversalTime();}
+
+inline TInt *TWsEvent::Int() const
+ /** Gets the event data as a TInt.*/
+ { return (TInt*)&iEventData; }
+
+inline TUint TWsPriorityKeyEvent::Handle() const
+ /** Gets the handle for the window group which added the priority key.
+
+ This is the handle that was passed to the window group's Construct() function.
+ Since most applications have only one window group, however, this function
+ is rarely used.
+
+ @return The window group handle. */
+ {return(iHandle);}
+
+inline TKeyEvent *TWsPriorityKeyEvent::Key() const
+ /** Gets the priority key event.
+
+ @return Structure containing priority key event data */
+ {return((TKeyEvent *)&iEventData);}
+
+inline void TWsPriorityKeyEvent::SetHandle(TUint aHandle)
+ /** Sets the window group event handle.
+
+ This is the client handle of the window that is being sent the event.
+
+ @param aHandle The event handle. */
+ {iHandle=aHandle;}
+
+inline CDirectScreenAccess::CDirectScreenAccess(RWsSession& aWs,CWsScreenDevice* aScreenDevice,RWindowBase& aWindow,MDirectScreenAccess& aAbort)
+ :CActive(RDirectScreenAccess::EPriorityVeryHigh), iWindow(aWindow), iAbort(aAbort), iDirectAccess(aWs)
+ {iWsScreenDevice=aScreenDevice;}
+
+inline CFbsBitGc* CDirectScreenAccess::Gc()
+ /** Gets the graphics context for drawing to the screen.
+
+ This is set up by calling StartL(). Its origin is set so that you should use
+ window coordinates to specify which part of the screen to draw to and its
+ clipping region is set to the visible part of the window.
+
+ Code built to run on the Emulator must call CFbsScreenDevice::Update() in
+ order to see the results of drawing to this graphics context, but this may
+ not be required on all target hardware.
+
+ @return The graphics context for drawing to the screen. */
+ { return iGc; }
+
+inline CFbsScreenDevice*& CDirectScreenAccess::ScreenDevice()
+ /** Gets the screen device to draw to.
+
+ You should not use this screen device to create fonts because the object is
+ deleted and recreated when direct screen access is aborted and restarted.
+ Instead, create and use your own CFbsScreenDevice object to create fonts.
+
+ @return The target screen device. */
+ { return iScreenDevice; }
+
+inline RRegion* CDirectScreenAccess::DrawingRegion()
+ /** Gets the clipping region to draw to.
+
+ You must not draw outside of this region.
+
+ The clipping region is calculated when StartL() is called, and is only updated
+ if StartL() is called again.
+
+ The region is specified in screen coordinates. This can be useful if you need
+ to reapply the clipping region to the graphics context (CFbsBitGc::SetClippingRegion()).
+
+ @return The clipping region to draw to. */
+ { return iDrawingRegion; }
+
+inline TSizeMode::TSizeMode(TSize& aSize) :
+ iOrigin(0, 0), iScreenSize(aSize)
+ {}
+
+inline TInt TSizeMode::ScaledCord(TInt aOrigin,TInt aScale)
+ {return (aOrigin+aScale-1)/aScale;}
+
+inline TPoint TSizeMode::ScaledOrigin()
+ {return TPoint(ScaledCord(iOrigin.iX,iScreenScale.iWidth),ScaledCord(iOrigin.iY,iScreenScale.iHeight));}
+
+#endif