w32std.h

Go to the documentation of this file.

// Copyright (c) 1994-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// Standard window server header file
// 
//
 
#ifndef __W32STD_H__
#define __W32STD_H__
 
#ifndef __FNTSTORE_H__
#include <fntstore.h>
#endif
#ifndef __BITDEV_H__
#include <bitdev.h>
#endif
#ifndef __BITSTD_H__
#include <bitstd.h>
#endif
#include <e32keys.h>
#include <textcursor.h>
#include <pointerevent.h>
#include <advancedpointerevent.h>
#include <sizemode.h>
#include <babitflags.h>
#include <wspublishandsubscribedata.h>
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <graphics/windowserverconstants.h>
#include <graphics/pointereventdata.h>
#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
 
_LIT(KWSERVThreadName,"Wserv");
 
class RWindowBase;
class RWindow;
class RWsBuffer;
class MWsObjectProvider;
class RWsDrawableSource;
class TSizeMode;
 
enum TScreenModeEnforcement
    {
    ESizeEnforcementNone,
    ESizeEnforcementPixelsAndRotation,
    ESizeEnforcementPixelsTwipsAndRotation,
    };
 
struct TPixelsAndRotation
    {
    TSize iPixelSize;
    CFbsBitGc::TGraphicsOrientation iRotation;
    };
 
struct TPixelsTwipsAndRotation
    {
    TSize iPixelSize;
    TSize iTwipsSize;
    CFbsBitGc::TGraphicsOrientation iRotation;
    };
 
enum {
    KLogMessageLength=0x80
    };
 
typedef TBuf<KLogMessageLength> TLogMessageText;
 
enum
    {
    KPasswordWindowGroupPriority=1000
    };
 
enum {
    KOrdinalPositionSwitchToOwningWindow=0x80000000
    };
 
enum TCornerType
// Bottom 16 bits available for corner type
    {
    EWindowCornerSquare,
    EWindowCorner1,
    EWindowCorner2,
    EWindowCorner3,
    EWindowCorner5,
    EWindowCornerRegion,        // Private
    ECornerTypeMask=0xFFFF
    };
 
enum TCornerFlags
// Top 16 bits available for corner flags
    {
    EWindowCornerNotTL=0x10000,
    EWindowCornerNotTR=0x20000,
    EWindowCornerNotBL=0x40000,
    EWindowCornerNotBR=0x80000,
    };
 
enum TWindowBackupType
    {
    EWindowBackupAreaBehind=0x0001,
    EWindowBackupFullScreen=0x0002,
    };
 
enum TEventCode
    {
    EEventNull,
    EEventKey,
    EEventKeyUp,
    EEventKeyDown,
    EEventModifiersChanged,
    EEventPointer,          //5
    EEventPointerEnter,
    EEventPointerExit,
    EEventPointerBufferReady,
    EEventDragDrop,
    EEventFocusLost,        //10
    EEventFocusGained,
    EEventSwitchOn,
    EEventPassword,
    EEventWindowGroupsChanged,
    EEventErrorMessage,     //15
    EEventMessageReady,
    EEventMarkInvalid,  // For internal use only
    EEventSwitchOff,
    EEventKeySwitchOff,
    EEventScreenDeviceChanged, //20
    EEventFocusGroupChanged,
    EEventCaseOpened,
    EEventCaseClosed,
    EEventWindowGroupListChanged,
    EEventWindowVisibilityChanged,
#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP
    EEventRestartSystem,
#endif
    EEventDisplayChanged = EEventWindowVisibilityChanged+2,
    //Codes for events only passed into Key Click DLL's
    EEventKeyRepeat=100,
    EEventGroupWindowOpen,
    EEventGroupWindowClose,
    EEventWindowClose,
    //Codes for events only passed into anim dlls
    EEventDirectScreenAccessBegin=200,
    EEventDirectScreenAccessEnd,
    EEventHeartbeatTimerStateChange,
 
    //The range 900-999 is reserved for UI Framework events
    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
 
    EEventUser=1000,
 
    };
 
 
enum THotKey
    {
    EHotKeyEnableLogging,
    EHotKeyDisableLogging,
    EHotKeyStateDump,
    EHotKeyOfDeath,
    EHotKeyShutDown,
    EHotKeyHeapDump,
    EHotKeyIncContrast,
    EHotKeyDecContrast,
    EHotKeyOff,
    EHotKeyBacklightOn,
    EHotKeyBacklightOff,
    EHotKeyBacklightToggle,
    EHotKeyScreenDimension0,
    EHotKeyScreenDimension1,
    EHotKeyScreenDimension2,
    EHotKeyScreenDimension3,
    EHotKeyCycleDisplaySize,
    EHotKeyCycleOrientation,
    EHotKeyIncBrightness,
    EHotKeyDecBrightness,
 
    EHotKeyCycleFocusScreen,
 
    EHotKeyFirstKeyType=EHotKeyEnableLogging,       //Must always be set to the first one
    EHotKeyLastKeyType=EHotKeyCycleFocusScreen,     //Must always be set to the last one
    };
 
 
enum TPasswordMode
    {
    EPasswordCancel,
    EPasswordNone,
    EPasswordOnceADay,
    EPasswordAlways,
    EPasswordAlwaysTriggerNow,
    EPasswordOnceADayTriggerNow,
    };
enum TPriorities {
           EAllPriorities=KMinTInt,
           };
 
enum TSpriteFlags
    {
    ESpriteFlash=0x1,
    ESpriteNoChildClip=0x2,
    ESpriteNoShadows=0x4
    };
 
struct TSpriteMember
    {
    CFbsBitmap *iBitmap;
    CFbsBitmap *iMaskBitmap;
    TBool iInvertMask;
    CGraphicsContext::TDrawMode iDrawMode;
    TPoint iOffset;
    TTimeIntervalMicroSeconds32 iInterval;
    };
 
enum TEventControl
    {
    EEventControlAlways,
    EEventControlOnlyWithKeyboardFocus,
    EEventControlOnlyWhenVisible
    };
 
enum TPointerFilter
    {
    //Basic Types
    EPointerFilterEnterExit=0x1,
    EPointerFilterMove=0x2,
    EPointerFilterDrag=0x4,
    EPointerGenerateSimulatedMove=0x8,
    //Combinations of the above
    EPointerMoveEvents=EPointerFilterMove|EPointerGenerateSimulatedMove,
    };
 
struct TKeyEvent
    {
    TUint iCode;
    TInt iScanCode;
    TUint iModifiers;
    TInt iRepeats;
    };
 
struct TModifiersChangedEvent
    {
    TUint iChangedModifiers;
    TUint iModifiers;
    };
 
struct TWsVisibilityChangedEvent
        {
    enum
        {
        ECanBeSeen = 0x01,
        ECantBeSeen = 0x02,
        };
    enum
        {
        EPartiallyVisible = 0x01,
        ENotVisible = 0x02,
        EFullyVisible = 0x04,
        };
    TUint iFlags;
    };
 
struct TWsDisplayChangedEvent
    {
    TInt iDisplayNumber;
    TInt iConfigurationChangeId;
    TInt iResolutionListChangeId;   
    };
 
struct TWsErrorMessage
    {
    enum TErrorCategory
        {
        EDrawingRegion,
        EBackLight,
        ELogging,
        EContrast,
        };
    TErrorCategory iErrorCategory;
    TUint iError;
    };
 
class TWsRedrawEvent
    {
public:
    inline TUint Handle() const;
    inline TRect Rect() const;
public:
    void SetHandle(TUint aHandle);
    void SetRect(TRect aRect);
protected:
    TUint iHandle;  
    TRect iRect;    
    };
 
class TWsPriorityKeyEvent
    {
public:
    inline TKeyEvent *Key() const;
    inline TUint Handle() const;
    inline void SetHandle(TUint aHandle);
protected:
    TUint iHandle;  
    TUint8 iEventData[sizeof(TKeyEvent)];   
    };
 
class TWsEvent
    {
public:
    enum
        {
        EWsEventDataSize=sizeof(TAdvancedPointerEvent)
        };
public:
    inline TWsEvent();
    inline TAdvancedPointerEvent* Pointer() const;
    inline TKeyEvent* Key() const;
    inline TModifiersChangedEvent* ModifiersChanged() const;
    inline TWsVisibilityChangedEvent* VisibilityChanged();
    inline const TWsVisibilityChangedEvent* VisibilityChanged() const;
    inline TWsDisplayChangedEvent* DisplayChanged();
    inline const TWsDisplayChangedEvent* DisplayChanged() const;
    inline TWsErrorMessage* ErrorMessage() const;
    inline TUint8* EventData() const;
    inline TInt Type() const;
    inline TUint Handle() const;
    inline TTime Time() const;
    inline void SetType(TInt aType);
    inline void SetHandle(TUint aHandle);
    inline void SetTimeNow();
    inline TInt* Int() const;
    IMPORT_C void InitAdvancedPointerEvent(TPointerEvent::TType aType, TUint aModifiers, const TPoint3D &aPoint3D, TUint8 aPointerNumber);
    IMPORT_C void SetPointerNumber(TUint8 aPointerNumber);
    IMPORT_C void SetPointerZ(TInt aZ);
protected:
    TInt iType; 
    TUint iHandle;  
    TTime iTime;    
    TUint8 iEventData[EWsEventDataSize];    
    };
 
 
class RWsPointerCursor;
 
enum TPointerCursorMode
    {
    EPointerCursorNone,
    EPointerCursorFixed,
    EPointerCursorNormal,
    EPointerCursorWindow,
    EPointerCursorFirstMode=EPointerCursorNone,
    EPointerCursorLastMode=EPointerCursorWindow,
    };
 
enum TLongCaptureFlags
    {
    ELongCaptureShortEventImmediately=0x01,
    ELongCaptureRepeatEvents=0x02,
    ELongCaptureNormal=ELongCaptureShortEventImmediately,
    ELongCaptureWaitShort=0,
    };
 
 
class TIpcArgs;
class TReadDescriptorType;
class TWriteDescriptorType;
class CWindowGc;
class RWsSession;
 
class TWsGraphicId
    {
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
    {
protected:
    IMPORT_C CWsGraphic();
public:
    IMPORT_C ~CWsGraphic();
protected:
    // 2nd phase construction
    IMPORT_C void BaseConstructL(TUid aUid,TUid aType,const TDesC8& aData);
    IMPORT_C void BaseConstructL(TUid aType,const TDesC8& aData);
    IMPORT_C void BaseConstructL(const TWsGraphicId& aReplace,TUid aType,const TDesC8& aData);
    // sharing between clients
    IMPORT_C virtual TInt ShareGlobally();
    IMPORT_C virtual TInt Share(TSecureId aClientId);
    IMPORT_C virtual TInt UnShare(TSecureId aClientId);
    IMPORT_C virtual TInt UnShareGlobally();
public:
    IMPORT_C const TWsGraphicId& Id() const;
    IMPORT_C TBool IsActive() const;
    IMPORT_C void Destroy();
protected:
    IMPORT_C void SendMessage(const TDesC8& aData) const;
    IMPORT_C TInt SendSynchronMessage(const TDesC8& aData) const;
    IMPORT_C TInt Flush() const;
    IMPORT_C void SetGraphicExtension(MWsObjectProvider* aExt);
    IMPORT_C RWsSession& Session();
    
private:
    // events from wserv, to be implemented by derived classes
    virtual void HandleMessage(const TDesC8& aData) = 0;
    
    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
    {
    friend class RTFXEffect;
public:
    MWsClientClass();
    MWsClientClass(RWsBuffer *aBuffer);
    inline TInt WsHandle() const;
protected:
    void Write(const TAny *aData1,TInt aLength1,TInt aLength2,TUint aOpcode) const;
    void Write(const TAny *aData, TInt aLength,const TAny *aData2, TInt aLength2,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    void Write(const TAny *aBuf, TInt aBufLen,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    void Write(TUint aOpcode) const;
    void WriteInt(TInt aInt, TUint aOpcode) const;
    void WriteRect(const TRect &aRect, TUint aOpcode) const;
    void WritePoint(const TPoint &aPoint, TUint aOpcode) const;
    void WriteSize(const TSize &aSize, TUint aOpcode) const;
    TInt WriteReply(TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    TInt WriteReplyInt(TInt aInt, TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    TInt WriteReply(const TAny *aBuf, TInt aBufLen,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    TInt WriteReply(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2,TUint aOpcode,const TIpcArgs* aIpcArgs=NULL) const;
    TInt WriteReplyP(const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
    TInt WriteReplyIntP(TInt aInt, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
    TInt WriteReplyP(const TAny *aBuf, TInt aBufLen, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
    TInt WriteReplyP(const TAny *aBuf, TInt aBufLen,const TAny *aBuf2, TInt aBuflen2, const TWriteDescriptorType& aReplyPackage,TUint aOpcode) const;
    TInt WriteReplyByProvidingRemoteReadAccess(const TAny* aBuf, TInt aBufLen,const TReadDescriptorType& aRemoteReadBuffer,TUint aOpcode) const;
    void AddToBitmapArray(const TInt aBitmapHandle)const;
    void AsyncRequest(TRequestStatus& aStatus, TUint aOpcode) const;
 
    TBool WindowSizeCacheEnabled() const;
    void MarkWindowSizeCacheDirty();
    void RefreshWindowSizeCache(const TSize& aNewSize) const;
    TInt CachedWindowSize(TSize& aSize) const;
    void DestroyWindowSizeCacheEntry();
 
private:
    void AppendData(const TAny *aData,TInt aLength,TBool aFinished);
    
protected:
    TInt32 iWsHandle;   
    RWsBuffer *iBuffer; 
    };
 
 
class RWindowTreeNode;
class CWsScreenDevice;
class CWsBitmap;
class RAnimDll;
class RWsSpriteBase;
class RDirectScreenAccess;
class RSoundPlugIn;
 
 
class RWsSession : public MWsClientClass, public RSessionBase
    {
    friend class RWsBuffer;
    friend class RWindowTreeNode;
    friend class CWsScreenDevice;
    friend class CWsBitmap;
    friend class RAnimDll;
    friend class RWsSpriteBase;
    friend class RDirectScreenAccess;
    friend class RSoundPlugIn;
    friend class CWsGraphic;
    friend class RWsDrawableSource;
public:
    enum TComputeMode
        {
        EPriorityControlDisabled,
        EPriorityControlComputeOn,
        EPriorityControlComputeOff
        };
    enum {ESystemInfoArraySize=16};
    enum TLoggingCommand
        {
        ELoggingEnable,
        ELoggingDisable,
        ELoggingStatusDump,     //Window Tree Dump
        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
        {
        TInt iInfo[ESystemInfoArraySize];
        };
    enum TCustomTextCursorAlignment
        {
        ECustomTextCursorAlignTop,
        ECustomTextCursorAlignBaseline,
        ECustomTextCursorAlignBottom
        };
    
//
public:
    IMPORT_C RWsSession();
    IMPORT_C TInt Connect();
    IMPORT_C TInt Connect(RFs& aFileServer);
    IMPORT_C void Close();
    IMPORT_C TVersion Version() const;
 
    IMPORT_C TInt SetHotKey(THotKey aType, TUint aKeyCode, TUint aModifierMask, TUint aModifier);
    IMPORT_C TInt ClearHotKeys(THotKey aType);
    IMPORT_C TInt RestoreDefaultHotKey(THotKey aType);
//
    IMPORT_C void EventReady(TRequestStatus *aStat);
    IMPORT_C void EventReadyCancel();
    IMPORT_C void GetEvent(TWsEvent &aEvent) const;
    IMPORT_C void PurgePointerEvents();
//
    IMPORT_C void RedrawReady(TRequestStatus *aStat);
    IMPORT_C void RedrawReadyCancel();
    IMPORT_C void GetRedraw(TWsRedrawEvent &aEvent);
//
    IMPORT_C void PriorityKeyReady(TRequestStatus *aStat);
    IMPORT_C void PriorityKeyReadyCancel();
    IMPORT_C void GetPriorityKey(TWsPriorityKeyEvent &aEvent) const;
//
    IMPORT_C void Flush();
    IMPORT_C TBool SetAutoFlush(TBool aState);
    IMPORT_C TInt SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);
    IMPORT_C void GetKeyboardRepeatRate(TTimeIntervalMicroSeconds32 &aInitialTime, TTimeIntervalMicroSeconds32 &aTime) const;
    IMPORT_C void GetDoubleClickSettings(TTimeIntervalMicroSeconds32 &aInterval, TInt &aDistance) const;
    IMPORT_C TInt SetDoubleClick(const TTimeIntervalMicroSeconds32 &aInterval, TInt aDistance);
//
    IMPORT_C TInt NumWindowGroups() const;
    IMPORT_C TInt WindowGroupList(CArrayFixFlat<TInt> *aWindowList) const;
    IMPORT_C TInt WindowGroupList(RArray<TWindowGroupChainInfo>* aWindowList) const;
    IMPORT_C TInt NumWindowGroups(TInt aPriority) const;
    IMPORT_C TInt WindowGroupList(TInt aPriority, CArrayFixFlat<TInt> *aWindowList) const;
    IMPORT_C TInt WindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowList) const;
    IMPORT_C TInt GetFocusWindowGroup() const;
    IMPORT_C TInt GetDefaultOwningWindow() const;
    IMPORT_C TInt SetWindowGroupOrdinalPosition(TInt aIdentifier, TInt aPosition);
    IMPORT_C TInt GetWindowGroupClientThreadId(TInt aIdentifier, TThreadId &aThreadId) const;
    IMPORT_C TInt GetWindowGroupHandle(TInt aIdentifier) const;
    IMPORT_C TInt GetWindowGroupOrdinalPriority(TInt aIdentifier) const;
    IMPORT_C TInt SendEventToWindowGroup(TInt aIdentifier, const TWsEvent &aEvent);
    IMPORT_C TInt SendEventToAllWindowGroups(const TWsEvent &aEvent);
    IMPORT_C TInt SendEventToAllWindowGroups(TInt aPriority, const TWsEvent &aEvent);
    IMPORT_C TInt SendEventToOneWindowGroupsPerClient(const TWsEvent &aEvent);
    IMPORT_C TInt GetWindowGroupNameFromIdentifier(TInt aIdentifier, TDes &aWindowName) const;
    IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,const TDesC& aMatch,TInt aOffset=0) const;
    IMPORT_C TInt FindWindowGroupIdentifier(TInt aPreviousIdentifier,TThreadId aThreadId) const;
    IMPORT_C TInt SendMessageToWindowGroup(TInt aIdentifier, TUid aUid, const TDesC8 &aParams);
    IMPORT_C TInt SendMessageToAllWindowGroups(TUid aUid, const TDesC8& aParams);
    IMPORT_C TInt SendMessageToAllWindowGroups(TInt aPriority, TUid aUid, const TDesC8& aParams);
    IMPORT_C TInt FetchMessage(TUid &aUid, TPtr8 &aParams, const TWsEvent& aMessageEvent) const;
//
    IMPORT_C void SetShadowVector(const TPoint &aVector);
    IMPORT_C TPoint ShadowVector() const;
//
    IMPORT_C void SetBackgroundColor(TRgb aColor);
    IMPORT_C TRgb GetBackgroundColor() const;
//
    IMPORT_C TInt RegisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface);
    IMPORT_C void UnregisterSurface(TInt aScreenNumber, const TSurfaceId& aSurface);
    IMPORT_C TInt PreferredSurfaceConfigurationSize() const;
//
    IMPORT_C TInt SetSystemPointerCursor(const RWsPointerCursor &aPointerCursor,TInt aCursorNumber);
    IMPORT_C void ClearSystemPointerCursor(TInt aCursorNumber);
    IMPORT_C TInt ClaimSystemPointerCursorList();
    IMPORT_C void FreeSystemPointerCursorList();
//
    IMPORT_C TInt SetCustomTextCursor(TInt aIdentifier, const TArray<TSpriteMember>& aSpriteMemberArray, TUint aSpriteFlags, TCustomTextCursorAlignment aAlignment);
//
    IMPORT_C TInt ResourceCount() const;
    IMPORT_C void PasswordEntered();
    IMPORT_C void ComputeMode(TComputeMode aMode);
//
    IMPORT_C TInt HeapCount() const;
    IMPORT_C TInt DebugInfo(TInt aFunction, TInt aParam=0) const;
    IMPORT_C TInt DebugInfo(TInt aFunction, TDes8& aReturnBuf, TInt aParam=0) const;
    IMPORT_C void HeapSetFail(TInt aTAllocFail,TInt aValue);
    IMPORT_C void HeapSetBurstFail(TInt aTAllocFail,TInt aRate,TInt aBurst);
    IMPORT_C TInt SetModifierState(TEventModifier aModifier,TModifierState aState);
    IMPORT_C TInt GetModifierState() const;
//
    IMPORT_C TInt RequestOffEvents(TBool aOn,RWindowTreeNode *aWin=NULL);
    IMPORT_C TDisplayMode GetDefModeMaxNumColors(TInt& aColor,TInt& aGray) const;
    IMPORT_C TInt GetColorModeList(CArrayFixFlat<TInt> *aModeList) const;
//
    IMPORT_C void SetPointerCursorArea(const TRect& aArea);
    IMPORT_C void SetPointerCursorArea(TInt aScreenSizeMode,const TRect& aArea);
    IMPORT_C TRect PointerCursorArea() const;
    IMPORT_C TRect PointerCursorArea(TInt aScreenSizeMode) const;
    IMPORT_C void SetPointerCursorMode(TPointerCursorMode aMode);
    IMPORT_C TInt SetClientCursorMode(TPointerCursorMode aMode);
    IMPORT_C TPointerCursorMode PointerCursorMode() const;
    IMPORT_C void SetDefaultSystemPointerCursor(TInt aCursorNumber);
    IMPORT_C void ClearDefaultSystemPointerCursor();
    IMPORT_C TInt SetPointerCursorPosition(const TPoint& aPosition);
    IMPORT_C TPoint PointerCursorPosition() const;
 
    IMPORT_C void SetDefaultFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);
    IMPORT_C void PrepareForSwitchOff();
    IMPORT_C void SetBufferSizeL(TInt aBufSize);
    IMPORT_C void SetMaxBufferSizeL(TInt aMaxBufSize);
    IMPORT_C TInt SetSystemFaded(TBool aFaded);
    IMPORT_C TInt SetSystemFaded(TBool aFaded,TUint8 aBlackMap,TUint8 aWhiteMap);
 
// Functions for multiple screens
    IMPORT_C TInt SetFocusScreen(TInt aScreenNumber);
    IMPORT_C TInt GetFocusScreen() const;
    IMPORT_C void ClearAllRedrawStores();
    IMPORT_C TInt NumWindowGroups(TInt aScreenNumber,TInt aPriority) const;
    IMPORT_C TInt NumberOfScreens() const;
    IMPORT_C TInt WindowGroupList(CArrayFixFlat<TInt>* aWindowList,TInt aScreenNumber,TInt aPriority=EAllPriorities) const;
    IMPORT_C TInt GetFocusWindowGroup(TInt aScreenNumber) const;
    IMPORT_C TInt GetDefaultOwningWindow(TInt aScreenNumber) const;
    IMPORT_C TDisplayMode GetDefModeMaxNumColors(TInt aScreenNumber,TInt& aColor,TInt& aGray) const;
    IMPORT_C TInt GetColorModeList(TInt aScreenNumber,CArrayFixFlat<TInt>* aModeList) const;
#if defined(__WINS__)
// Function for WINS behaviour only
    IMPORT_C void SetRemoveKeyCode(TBool aRemove);
    IMPORT_C void SimulateXyInputType(TInt aInputType);     //Only for testing WSERV
#endif
//
    IMPORT_C void SimulateRawEvent(TRawEvent aEvent);
    IMPORT_C void SimulateKeyEvent(TKeyEvent aEvent);
    IMPORT_C void LogCommand(TLoggingCommand aCommand);
    IMPORT_C void LogMessage(const TLogMessageText &aMessage);
 
// Functions for test code use only
    IMPORT_C void SystemInfo(TInt &aSystemInfoNumber, SSystemInfo &aSystemInfo);
    IMPORT_C void TestWrite(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);
    IMPORT_C void TestWriteReply(TInt aHandle,TInt aOpcode,const TAny *aData, TInt aLength);
    IMPORT_C void TestWriteReplyP(TInt aHandle,TInt aOpcode,const TAny *aData,TInt aLength,TDes8 *aReplyPackage);
    IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC8& aRemoteReadBuffer);
    IMPORT_C TInt TestWriteReplyByProvidingRemoteReadAccess(TInt aHandle,TInt aOpcode,const TDesC8& aData,const TDesC16& aRemoteReadBuffer);
    
    IMPORT_C TInt Finish();
    IMPORT_C void SyncMsgBuf();
 
// Getters and setters for pointer event's thresholds
    IMPORT_C TInt SetCloseProximityThresholds(TInt aEnterCloseProximityThreshold, TInt aExitCloseProximityThreshold);
    IMPORT_C TInt GetEnterCloseProximityThreshold() const;
    IMPORT_C TInt GetExitCloseProximityThreshold() const;
    IMPORT_C TInt SetHighPressureThresholds(TInt aEnterHighPressureThreshold, TInt aExitHighPressureThreshold);
    IMPORT_C TInt GetEnterHighPressureThreshold() const;
    IMPORT_C TInt GetExitHighPressureThreshold() const;
//
    IMPORT_C void EnableWindowSizeCacheL();
    IMPORT_C void SendEffectCommand(TInt aTfxCmd, const TDesC8& aTfxCmdData=KNullDesC8);
 
// Registering/Unregistering of TFX effect, to allow animations to be associated with each transition
    IMPORT_C void RegisterEffect(TInt aAction, TInt aPurpose, const TFileName& aResourceDir, const TFileName& aFilenameOutgoing, const TFileName& aFilenameIncoming, TUint aAppUid=0, TBitFlags aFlags=0);
    IMPORT_C void UnregisterEffect(TInt aAction, TInt aPurpose, TUint aAppUid=0);
    IMPORT_C void UnregisterAllEffects();
    IMPORT_C void OverrideEffects(TInt aAction, TInt aPurpose, const TFileName& aResourceDir, const TFileName& aFilenameOutgoing, const TFileName& aFilenameIncoming, TBitFlags aFlags=0);
    
//Application tells the window server the orientation of rendering it intends to use
    IMPORT_C void IndicateAppOrientation(TRenderOrientation aOrientation);
    
// functions not exported, used by CWsGraphic
    void GraphicMessageReady(TRequestStatus *aStat);
    void GetGraphicMessage(TDes8& aData) const;
    void GraphicMessageCancel();
    void GraphicAbortMessage(TInt aError);
    TInt GraphicFetchHeaderMessage();
private:
    TInt doWindowGroupList(TInt aPriority, RArray<TWindowGroupChainInfo>* aWindowListCh, TInt aNumOpcode, TInt aListOpcode) const;
    TInt doWindowGroupList(TInt aScreenNumber, TInt aPriority, CArrayFixFlat<TInt>* aWindowListId, TInt aNumOpcode, TInt aListOpcode) const;
    TInt doSetHotKey(TInt aOpcode, TInt aType, TUint aKeycode, TUint aModifierMask, TUint aModifiers);
    void doReadEvent(TRequestStatus *aStat, TInt aOpcode);
 
private:
    void connectL();
    TInt DoFlush(const TIpcArgs& aIpcArgs);
    TInt DoSyncMsgBuf(const TIpcArgs& aIpcArgs);
    void DirectAcessActivation(TBool aIsNowActive);
    };
 
class RWindowGroup;
class RWsSprite;
 
 
class RWindowTreeNode : public MWsClientClass
    {
    friend class RWindowGroup;
    friend class RWindowBase;
    friend class CWindowGc;
    friend class RAnimDll;
    friend class RWsSprite;
public:
    enum TFadeControl
        {
        EFadeIncludeChildren=ETrue,
        EFadeWindowOnly=EFalse,
        };
protected:
    RWindowTreeNode();
    RWindowTreeNode(RWsSession &aWs);
public:
    IMPORT_C void Close();
    IMPORT_C void Destroy();
    IMPORT_C TUint32 ClientHandle() const;
    IMPORT_C TUint32 Parent() const;
    IMPORT_C TUint32 PrevSibling() const;
    IMPORT_C TUint32 NextSibling() const;
    IMPORT_C TUint32 Child() const;
    IMPORT_C TInt OrdinalPriority() const;
    IMPORT_C TInt OrdinalPosition() const;
    IMPORT_C TInt FullOrdinalPosition() const;
    IMPORT_C void SetOrdinalPosition(TInt aPos);
    IMPORT_C void SetOrdinalPosition(TInt aPos,TInt aOrdinalPriority);
    IMPORT_C TInt ScreenNumber() const; 
    IMPORT_C TInt WindowGroupId() const;
    IMPORT_C TInt SetPointerCursor(TInt aCursorNumber);
    IMPORT_C void SetCustomPointerCursor(const RWsPointerCursor &aPointerCursor);
    IMPORT_C TInt EnableOnEvents(TEventControl aCircumstances=EEventControlOnlyWithKeyboardFocus);
    IMPORT_C void DisableOnEvents();
    IMPORT_C TInt EnableGroupChangeEvents();
    IMPORT_C void DisableGroupChangeEvents();
    IMPORT_C TInt EnableFocusChangeEvents();
    IMPORT_C void DisableFocusChangeEvents();
    IMPORT_C TInt EnableGroupListChangeEvents();
    IMPORT_C void DisableGroupListChangeEvents();
    IMPORT_C TInt EnableVisibilityChangeEvents();
    IMPORT_C void DisableVisibilityChangeEvents();
    IMPORT_C TInt EnableErrorMessages(TEventControl aCircumstances);
    IMPORT_C void DisableErrorMessages();
    IMPORT_C TInt EnableModifierChangedEvents(TUint aModifierMask, TEventControl aCircumstances);
    IMPORT_C void DisableModifierChangedEvents();
    IMPORT_C void SetNonFading(TBool aNonFading);
    IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren);
    IMPORT_C void SetFaded(TBool aFaded,TFadeControl aIncludeChildren,TUint8 aBlackMap,TUint8 aWhiteMap);
    IMPORT_C void ClearPointerCursor();
    IMPORT_C RWsSession* Session() const;
protected:
    __DECLARE_TEST;
    };
 
 
class TSurfaceId;
class TSurfaceConfiguration;
 
class RWindowBase : public RWindowTreeNode
    {
public:
    enum TCaptureFlags
        {
// Flags, these can be combined to customise pointer capture
        TCaptureFlagEnabled=0x01,
        TCaptureFlagDragDrop=0x02,
        TCaptureFlagAllGroups=0x04,
// States, made up of a set of flags
        TCaptureDisabled=0,
        TCaptureEnabled=TCaptureFlagEnabled,
        TCaptureDragDrop=TCaptureFlagEnabled|TCaptureFlagDragDrop|TCaptureFlagAllGroups,
        };
protected:
    RWindowBase();
    RWindowBase(RWsSession &aWs);
public:
    IMPORT_C void Activate();
    IMPORT_C void SetPosition(const TPoint &point);
    IMPORT_C TInt SetSizeErr(const TSize &size);
    IMPORT_C TInt SetExtentErr(const TPoint &point,const TSize &size);
    IMPORT_C TSize Size() const;
    IMPORT_C TPoint InquireOffset(const RWindowTreeNode &aWindow) const;
    IMPORT_C void PointerFilter(TUint32 aFilterMask, TUint32 aFilter);
    IMPORT_C void SetPointerGrab(TBool aState);
    IMPORT_C void ClaimPointerGrab(TBool aSendUpEvent=ETrue);
    IMPORT_C TInt ClaimPointerGrab(const TUint8 aPointerNumber, const TBool aSendUpEvent=ETrue);
    IMPORT_C void SetPointerCapture(TInt aFlags);
    IMPORT_C void SetPointerCapturePriority(TInt aPriority);
    IMPORT_C TInt GetPointerCapturePriority() const;
    IMPORT_C void SetVisible(TBool aState);
    IMPORT_C void SetShadowHeight(TInt aHeight);
    IMPORT_C void SetShadowDisabled(TBool aState);
    IMPORT_C TPoint Position() const;
    IMPORT_C TPoint AbsPosition() const;
    IMPORT_C TInt SetCornerType(TCornerType aCornerType, TInt aCornerFlags=0);
    IMPORT_C TInt SetShape(const TRegion &aRegion);
    IMPORT_C TInt SetRequiredDisplayMode(TDisplayMode aMode);
    IMPORT_C TDisplayMode DisplayMode() const;
    IMPORT_C void EnableBackup(TUint aBackupType=EWindowBackupAreaBehind);
    IMPORT_C void RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32 aTime,const TRect &aRect);
    IMPORT_C void CancelPointerRepeatEventRequest();
    IMPORT_C TInt RequestPointerRepeatEvent(TTimeIntervalMicroSeconds32 aTime,const TRect &aRect, const TUint8 aPointerNumber); //< @prototype
    IMPORT_C TInt CancelPointerRepeatEventRequest(const TUint8 aPointerNumber); //< @prototype
    IMPORT_C TInt AllocPointerMoveBuffer(TInt aMaxPoints, TUint aFlags);
    IMPORT_C void FreePointerMoveBuffer();
    IMPORT_C void EnablePointerMoveBuffer();
    IMPORT_C void DisablePointerMoveBuffer();
    IMPORT_C TInt RetrievePointerMoveBuffer(TDes8 &aBuf) const;
    IMPORT_C void DiscardPointerMoveBuffer();
    IMPORT_C TInt AddKeyRect(const TRect &aRect, TInt aScanCode, TBool aActivatedByPointerSwitchOn);
    IMPORT_C void RemoveAllKeyRects();
    IMPORT_C TInt PasswordWindow(TPasswordMode aPasswordMode);
    IMPORT_C void FadeBehind(TBool aFade);
    IMPORT_C TBool IsFaded() const;
    IMPORT_C TBool IsNonFading() const;
    IMPORT_C TInt MoveToGroup(TInt aIdentifier);
    IMPORT_C TInt SetBackgroundSurface(const TSurfaceId& aSurface);
    IMPORT_C TInt SetBackgroundSurface(const TSurfaceConfiguration& aConfiguration, TBool aTriggerRedraw);
    IMPORT_C void RemoveBackgroundSurface(TBool aTriggerRedraw);
    IMPORT_C TInt GetBackgroundSurface(TSurfaceConfiguration& aConfiguration) const;
    IMPORT_C void SetSurfaceTransparency(TBool aSurfaceTransparency);
    IMPORT_C TRgb KeyColor() const;
    IMPORT_C void EnableAdvancedPointers();
    IMPORT_C void SetPurpose(TInt aPurpose);
    IMPORT_C void SendEffectCommand(TInt aTfxCmd, const TDesC8& aTfxCmdData=KNullDesC8);
    IMPORT_C void OverrideEffects(TInt aAction, const TFileName& aResourceDir, const TFileName& aFilenameOutgoing, const TFileName& aFilenameIncoming, TBitFlags aFlags=0);
    IMPORT_C TInt FixNativeOrientation();
    IMPORT_C TSize SizeForEgl() const;
protected:
    TInt construct(const RWindowTreeNode &parent,TUint32 aHandle, TInt aType, TDisplayMode aDisplayMode);
    };
 
 
class RBlankWindow : public RWindowBase
    {
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
    {
protected:
    RDrawableWindow();
    RDrawableWindow(RWsSession &aWs);
public:
    IMPORT_C void Scroll(const TPoint &aOffset);
    IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset);
    IMPORT_C void Scroll(const TPoint &aOffset, const TRect &aRect);
    IMPORT_C void Scroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect);
    IMPORT_C TRect GetDrawRect() const;
protected:
    void SetDrawRect(const TRect &aRect);
private:
    void doScroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect, TInt aOpcode);
 
    TRect iDrawRect;
    };
 
enum TWsTransparencyPolicy {
    ETransparencyDefault,
    ETransparencyFreezeUnder,
    };
 
class RWindow : public RDrawableWindow
    {
public:
    IMPORT_C RWindow();
    IMPORT_C RWindow(RWsSession &aWs);
    IMPORT_C TInt Construct(const RWindowTreeNode &parent,TUint32 aHandle);
    IMPORT_C void BeginRedraw();
    IMPORT_C void BeginRedraw(const TRect &aRect);
    IMPORT_C void EndRedraw();
    IMPORT_C void Invalidate();
    IMPORT_C void Invalidate(const TRect &aRect);
    IMPORT_C void GetInvalidRegion(RRegion &aRegion) const;
    IMPORT_C void SetBackgroundColor(TRgb aColor);
    IMPORT_C void SetBackgroundColor();
    IMPORT_C void SetSize(const TSize &size);
    IMPORT_C void SetExtent(const TPoint &point,const TSize &size);
    IMPORT_C void HandleTransparencyUpdate();
    IMPORT_C TInt SetTransparencyFactor(const TRgb& aTransparencyFactor);
    IMPORT_C TInt SetTransparencyBitmap(const CFbsBitmap& aTransparencyBitmap);
    IMPORT_C TInt SetTransparencyWsBitmap(const CWsBitmap& aTransparencyBitmap);
    IMPORT_C void SetNonTransparent();
    IMPORT_C void EnableRedrawStore(TBool aEnabled);
    IMPORT_C TInt SetTransparencyAlphaChannel();
    IMPORT_C TInt SetTransparentRegion(const TRegion& aRegion);
    IMPORT_C TInt SetTransparencyPolicy(TWsTransparencyPolicy aPolicy);
    IMPORT_C TBool IsRedrawStoreEnabled() const;
    IMPORT_C void EnableOSB(TBool);
    IMPORT_C void ClearRedrawStore();
    };
 
 
class RBackedUpWindow : public RDrawableWindow
    {
public:
    IMPORT_C RBackedUpWindow();
    IMPORT_C RBackedUpWindow(RWsSession &aWs);
    IMPORT_C TInt Construct(const RWindowTreeNode &parent,TDisplayMode aDisplayMode, TUint32 aHandle);
    IMPORT_C TInt BitmapHandle() const;
    IMPORT_C void UpdateScreen();
    IMPORT_C void UpdateScreen(const TRegion &aRegion);
    IMPORT_C void UpdateBackupBitmap();
    IMPORT_C void MaintainBackup();
    };
 
 
class RWindowGroup : public RWindowTreeNode
    {
public:
    IMPORT_C RWindowGroup();
    IMPORT_C RWindowGroup(RWsSession &aWs);
    IMPORT_C TInt Construct(TUint32 aClientHandle);
    IMPORT_C TInt Construct(TUint32 aClientHandle,CWsScreenDevice* aScreenDevice);
    IMPORT_C TInt Construct(TUint32 aClientHandle,TBool aIsFocusable,CWsScreenDevice* aScreenDevice);
    IMPORT_C TInt Construct(TUint32 aClientHandle,TBool aIsFocusable);
    IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle);
    IMPORT_C TInt ConstructChildApp(TInt aIdOfParentWindowGroup,TUint32 aClientHandle,TBool aIsFocusable);
    IMPORT_C void AllowProcessToCreateChildWindowGroups(TUid aProcessSID);
    IMPORT_C void EnableReceiptOfFocus(TBool aState);
    IMPORT_C void AutoForeground(TBool aState);
    IMPORT_C void SetOrdinalPriorityAdjust(TInt aAdjust);
    IMPORT_C TInt SetOrdinalPositionErr(TInt aPos,TInt aOrdinalPriority);
    IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
    IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier, TInt aPriority);
    IMPORT_C void CancelCaptureKey(TInt32 aCaptureKey);
    IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier);
    IMPORT_C TInt32 CaptureKeyUpAndDowns(TUint aScanCode, TUint aModifierMask, TUint aModifier, TInt aPriority);
    IMPORT_C void CancelCaptureKeyUpAndDowns(TInt32 aCaptureKey);
    IMPORT_C TInt32 CaptureLongKey(TUint aInputKeyCode,TUint aOutputKeyCode,TUint aModifierMask,TUint aModifier
                                                                                                        ,TInt aPriority,TUint aFlags);
    IMPORT_C TInt32 CaptureLongKey(TTimeIntervalMicroSeconds32 aRepeatTime,TUint aInputKeyCode,TUint aOutputKeyCode
                                                                    ,TUint aModifierMask,TUint aModifier,TInt aPriority,TUint aFlags);
    IMPORT_C void CancelCaptureLongKey(TInt32 aCaptureKey);
    IMPORT_C TInt AddPriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
    IMPORT_C void RemovePriorityKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
    IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor);
    IMPORT_C void SetTextCursor(RWindowBase &aWin, const TPoint &aPos, const TTextCursor &aCursor, const TRect &aClipRect);
    IMPORT_C void CancelTextCursor();
    IMPORT_C void SetOwningWindowGroup(TInt aIdentifier);
    IMPORT_C void DefaultOwningWindow();
    IMPORT_C TInt SetName(const TDesC &aName);
    IMPORT_C TInt Name(TDes &aWindowName) const;
    IMPORT_C TInt Identifier() const;
    IMPORT_C void DisableKeyClick(TBool aState);
    IMPORT_C TInt EnableScreenChangeEvents();
    IMPORT_C void DisableScreenChangeEvents();
    IMPORT_C void SimulatePointerEvent(TRawEvent aEvent);
    IMPORT_C void SimulateAdvancedPointerEvent(TRawEvent aEvent);
    IMPORT_C TInt ClearChildGroup();
    IMPORT_C TInt SetChildGroup(TInt aId);
private:
    TInt32 doCaptureKey(TUint aKey, TUint aModifierMask, TUint aModifiers, TInt aPriority, TInt aOpcode);
    void doCancelCaptureKey(TInt32 aCaptureKeyHandle, TInt aOpcode);
    TInt Construct(TInt aIdOfParentWindowGroup, TUint32 aClientHandle, TBool aIsFocusable, CWsScreenDevice* aScreenDevice);
    };
 
 
class CWsBitmap : public CFbsBitmap, public MWsClientClass
    {
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
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
    {
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
    {
    friend class CWsScreenDevice;
public:
    enum TGraphicsRotation
        {
        EGraphicsRotationNone,
        EGraphicsRotation90,
        EGraphicsRotation180,
        EGraphicsRotation270
        };  
 
    IMPORT_C CWindowGc(CWsScreenDevice *aDevice);
    IMPORT_C virtual ~CWindowGc();
    IMPORT_C virtual TInt Construct();
    IMPORT_C virtual void Activate(RDrawableWindow &aDevice);
    IMPORT_C virtual void Deactivate();
//====================FROM CGraphicsContext.H===============================
    IMPORT_C virtual CGraphicsDevice* Device() const;
    IMPORT_C virtual void SetOrigin(const TPoint &aPoint=TPoint(0,0));
    IMPORT_C virtual void SetDrawMode(TDrawMode aDrawingMode);
    IMPORT_C virtual void SetClippingRect(const TRect& aRect);
    IMPORT_C virtual void CancelClippingRect();
    IMPORT_C virtual void Reset();
 
    IMPORT_C virtual void UseFont(const CFont *aFont);
    IMPORT_C virtual void DiscardFont();
    IMPORT_C virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle);
    IMPORT_C virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);
// Used to do justified text properly
    IMPORT_C virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps);
// Used primarily to get accurate WYSIWYG
    IMPORT_C virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars);
 
    IMPORT_C virtual void SetPenColor(const TRgb &aColor);
    IMPORT_C virtual void SetPenStyle(TPenStyle aPenStyle);
    IMPORT_C virtual void SetPenSize(const TSize& aSize);
 
    IMPORT_C virtual void SetBrushColor(const TRgb &aColor);
    IMPORT_C virtual void SetBrushStyle(TBrushStyle aBrushStyle);
    IMPORT_C virtual void SetBrushOrigin(const TPoint &aOrigin);
    IMPORT_C virtual void UseBrushPattern(const CFbsBitmap *aDevice);
    IMPORT_C virtual void DiscardBrushPattern();
//
// Move the internal position, as used by DrawLineTo & DrawLineBy, and set by MoveTo,
// MoveBy, DrawLine, DrawLineTo, DrawLineBy and DrawPolyline
    IMPORT_C virtual void MoveTo(const TPoint &aPoint);
    IMPORT_C virtual void MoveBy(const TPoint &aPoint);
    IMPORT_C virtual void Plot(const TPoint &aPoint);
//
//  Line drawing subject to pen color, width and style and draw mode
    IMPORT_C virtual void DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
    IMPORT_C virtual void DrawLine(const TPoint &aPoint1,const TPoint &aPoint2);
    IMPORT_C virtual void DrawLineTo(const TPoint &aPoint);
    IMPORT_C virtual void DrawLineBy(const TPoint &aPoint);
    IMPORT_C virtual void DrawPolyLine(const CArrayFix<TPoint> *aPointList);
    IMPORT_C virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints);
//
// Filled outlines
// Outlines subject to pen color, width and style and draw mode
// (set pen to ENullPen for no outline)
// Fill subject to brush style (color, hash or pattern) and origin and
// drawing mode (set brush to ENullBrush for no fill)
    IMPORT_C virtual void DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
    IMPORT_C virtual void DrawEllipse(const TRect &aRect);
    IMPORT_C virtual void DrawRect(const TRect &aRect);
    IMPORT_C virtual void DrawRoundRect(const TRect &aRect,const TSize &aEllipse);
    IMPORT_C virtual TInt DrawPolygon(const CArrayFix<TPoint> *aPointList,TFillRule aFillRule=EAlternate);
    IMPORT_C virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate);
//
// Uses the bitmap's Twips size and does a "stretch" blit in general
    IMPORT_C virtual void DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice);
    IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice);
    IMPORT_C virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect);
    IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask);
    IMPORT_C virtual void DrawBitmapMasked(const TRect& aDestRect, const CWsBitmap* aBitmap, const TRect& aSourceRect, const CWsBitmap* aMaskBitmap, TBool aInvertMask);
 
// Required as not all DrawText and DrawTextVertical functions are implemented in CWindowGc
    using CBitmapContext::DrawText;
    using CBitmapContext::DrawTextVertical;
//
// Text drawing subject to drawing mode
// Subject to used font, pen color, drawing mode,
// word and char justification
    IMPORT_C virtual void DrawText(const TDesC &aBuf,const TPoint &aPos);
//
// Subject to same as above plus brush for background
// (set brush to ENullBrush for no effect on background)
    IMPORT_C virtual void DrawText(const TDesC &aBuf,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);
//================Extra functions from CBitmapContext==============
    IMPORT_C virtual void Clear();
    IMPORT_C virtual void Clear(const TRect &aRect);
    IMPORT_C virtual void CopyRect(const TPoint &anOffset,const TRect &aRect);
    IMPORT_C virtual void BitBlt(const TPoint &aPos, const CFbsBitmap *aBitmap);
    IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource);
    IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask);
    IMPORT_C virtual void BitBlt(const TPoint &aPoint, const CWsBitmap *aBitmap);
    IMPORT_C virtual void BitBlt(const TPoint &aDestination, const CWsBitmap *aBitmap, const TRect &aSource);
    IMPORT_C virtual void BitBltMasked(const TPoint& aPoint,const CWsBitmap *aBitmap,const TRect& aSourceRect,const CWsBitmap *aMaskBitmap,TBool aInvertMask);
    IMPORT_C virtual void MapColors(const TRect& aRect,const TRgb* aColors,TInt aNumPairs=2,TBool aMapForwards=ETrue);
 
    IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp);
    IMPORT_C virtual void DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);
//=================Extra functions specific to wserv GDI==============
    IMPORT_C virtual void SetDitherOrigin(const TPoint& aPoint);
    IMPORT_C virtual TInt SetClippingRegion(const TRegion &aRegion);
    IMPORT_C virtual void CancelClippingRegion();
    IMPORT_C virtual void SetOpaque(TBool aDrawOpaque=ETrue);
//=================Functions also supplied by CFbsBitGc==============
    IMPORT_C virtual void SetFaded(TBool aFaded);
    IMPORT_C virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);
    IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt);
    IMPORT_C virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp, const TRect& aSrcRect, const CWsBitmap* aAlphaBmp, const TPoint& aAlphaPt);
//
    IMPORT_C TAny* Interface(TUid aInterfaceId);
    IMPORT_C const TAny* Interface(TUid aInterfaceId) const;
    
protected:  
    IMPORT_C TInt APIExtension(TUid aUid, TAny*& aOutput, TAny* aInput);
    
private:    
 
    IMPORT_C void Reserved_CGraphicsContext_2();
 
    IMPORT_C void Reserved_CBitmapContext_1();
    IMPORT_C void Reserved_CBitmapContext_2();
    IMPORT_C void Reserved_CBitmapContext_3();
 
public:
    IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect);
    IMPORT_C virtual void DrawWsGraphic(const TWsGraphicId& aId,const TRect& aDestRect,const TDesC8& aData);
private:
    IMPORT_C virtual void Reserved_CWindowGc_3();
    IMPORT_C virtual void Reserved_CWindowGc_4();
    IMPORT_C virtual void Reserved_CWindowGc_5();
 
//=============================================================
private: // Private code
    TRgb Color(TInt aOpcode)const;
    void SetJustification(TInt aExcessWidth,TInt aNumGaps, TInt aOpcode);
    void DrawArcOrPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd, TInt aOpcode);
    void doDrawPolyLine(const CArrayFix<TPoint> *aPointArray, const TPoint* aPointList,TInt aNumPoints);
    TInt doDrawPolygon(const CArrayFix<TPoint> *aPointArray,const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule);
    void WriteTextPos(TInt aOpcode,TInt aOpcodePtr,const TPoint &aPos,const TDesC &aBuf) const;
    void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC &aBuf,TInt aOpcode,TInt aOpcodePtr) const;
    void WriteTextCommand(TAny *aCmd, TInt aLen,const TDesC8 &aBuf,TInt aOpcode,TInt aOpcodePtr) const;
    TInt APIExGetUnderlineMetrics(TAny*& aOutput);
    TInt APIExSetShadowColor(TAny* aShadowColor);
    TInt APIExGetShadowColor(TAny*& aOutput);
    // New DrawText API's that take in context
    TInt APIExDrawText(const TDesC &aBuf,const TTextParameters* aParam,const TPoint &aPos);
    TInt APIExDrawText(const TDesC &aBuf,const TTextParameters* aParam,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);
    TInt APIExDrawTextVertical(const TDesC& aText,const TTextParameters* aParam,const TPoint& aPos,TBool aUp);
    TInt APIExDrawTextVertical(const TDesC& aText,const TTextParameters* aParam,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);
    TInt APIExInterface(TAny*& aInterface, TUid aInterfaceId);
 
    void DrawResource(const TPoint& aPos, const RWsDrawableSource& aSource, TGraphicsRotation aRotation=EGraphicsRotationNone);
    void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, TGraphicsRotation aRotation=EGraphicsRotationNone);
    void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TRect& aSrcRect, TGraphicsRotation aRotation=EGraphicsRotationNone);
    void DrawResource(const TRect& aDestRect, const RWsDrawableSource& aSource, const TDesC8& aParam);
    
private: // Private data
    class CPimpl;
    CPimpl* iPimpl;
    CWsScreenDevice *iDevice;
    };
 
 
class CWsScreenDevice : public CBitmapDevice, public MWsClientClass
    {
public:
    enum TSpriteInCompare
        {
        ERemoveSprite=0,
        EIncludeSprite=1,
        EIncludeTextCursor=2
        };
public:
    IMPORT_C CWsScreenDevice();
    IMPORT_C CWsScreenDevice(RWsSession &aWs);
    IMPORT_C ~CWsScreenDevice();
    IMPORT_C TInt Construct();
    IMPORT_C TInt Construct( TInt aDefaultScreenNumber ) ;
    IMPORT_C TAny* GetInterface(TUint aInterfaceId);
    inline const TAny* GetInterface(TUint aInterfaceId) const;
    IMPORT_C TBool IsModeDynamic(TInt aSizeMode) const;
    IMPORT_C TBool IsCurrentModeDynamic() const;
//==== From CGraphicsDevice ====//
    IMPORT_C TDisplayMode DisplayMode() const;
    IMPORT_C TSize SizeInPixels() const;
    IMPORT_C TSize SizeInTwips() const;
    IMPORT_C TInt HorizontalTwipsToPixels(TInt aTwips) const;
    IMPORT_C TInt VerticalTwipsToPixels(TInt aTwips) const;
    IMPORT_C TInt HorizontalPixelsToTwips(TInt aPixels) const;
    IMPORT_C TInt VerticalPixelsToTwips(TInt aPixels) const;
    IMPORT_C TRect PointerRect() const;
    IMPORT_C TInt CreateContext(CGraphicsContext *&aGc);
    inline TInt CreateContext(CWindowGc*& aGc);
    IMPORT_C virtual TInt GetNearestFontInTwips(CFont*& aFont,const TFontSpec& aFontSpec);
    IMPORT_C virtual TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec);
    IMPORT_C virtual TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);
    IMPORT_C TInt NumTypefaces() const;
    IMPORT_C void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const;
    IMPORT_C TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const;
// ==== From CBitmapDevice ====//
    IMPORT_C void GetPixel(TRgb& aColor,const TPoint& aPixel) const;
    IMPORT_C void GetScanLine(TDes8& aScanLine,const TPoint& aStartPixel,TInt aPixelLength, TDisplayMode aDispMode) const;
    IMPORT_C TInt AddFile(const TDesC& aName,TInt& aId);
    IMPORT_C void RemoveFile(TInt aId=0);
    IMPORT_C virtual TInt GetNearestFontInPixels(CFont*& aFont,const TFontSpec& aFontSpec);
    IMPORT_C virtual TInt GetNearestFontToDesignHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec);
    IMPORT_C virtual TInt GetNearestFontToMaxHeightInPixels(CFont*& aFont,const TFontSpec& aFontSpec,TInt aMaxHeight);
    IMPORT_C TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const;
    IMPORT_C void ReleaseFont(CFont* aFont);
//===== From CFbsScreenDevice ====//
    IMPORT_C void PaletteAttributes(TBool& aModifiable,TInt& aNumEntries) const;
    IMPORT_C void SetPalette(CPalette* aPalette);
    IMPORT_C TInt GetPalette(CPalette*& aPalette) const;
//===== Extra functions ====//
    IMPORT_C TInt SetCustomPalette(const CPalette* aPalette);
    IMPORT_C TInt GetFontById(CFont*& aFont,TUid aUid,const TAlgStyle& aAlgStyle);
    IMPORT_C TBool RectCompare(const TRect &aRect1,const TRect &aRect2) const;
    IMPORT_C TBool RectCompare(const TRect& aRect1,const TRect &aRect2,TUint aFlags) const;
    IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap) const;
    IMPORT_C TInt CopyScreenToBitmap(const CFbsBitmap *aBitmap, const TRect &aRect) const;
    IMPORT_C TInt SetBackLight(TBool aBackLight);
//===== Screen Rotation functions ====//
    IMPORT_C void SetScreenSizeAndRotation(const TPixelsTwipsAndRotation &aSizeAndRotation);
    IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsTwipsAndRotation &aSizeAndRotation) const;
    IMPORT_C void SetScreenSizeAndRotation(const TPixelsAndRotation &aSizeAndRotation);
    IMPORT_C void GetDefaultScreenSizeAndRotation(TPixelsAndRotation &aSizeAndRotation) const;
    IMPORT_C TScreenModeEnforcement ScreenModeEnforcement() const;
    IMPORT_C void SetScreenModeEnforcement(TScreenModeEnforcement aMode) const;
    IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsTwipsAndRotation &aSizeAndRotation) const;
    IMPORT_C void GetScreenModeSizeAndRotation(TInt aMode, TPixelsAndRotation &aSizeAndRotation) const;
    IMPORT_C void SetCurrentRotations(TInt aMode, CFbsBitGc::TGraphicsOrientation aRotation) const;
    IMPORT_C TInt GetRotationsList(TInt aMode, CArrayFixFlat<TInt> *aRotationList) const;
    IMPORT_C TInt NumScreenModes() const;
    IMPORT_C void SetScreenMode(TInt aMode);
    IMPORT_C TInt CurrentScreenMode() const;
    IMPORT_C void SetAppScreenMode(TInt aMode);
    IMPORT_C TPoint GetDefaultScreenModeOrigin() const;
    IMPORT_C TPoint GetScreenModeOrigin(TInt aMode) const;
    IMPORT_C TSize GetCurrentScreenModeScale() const;
    IMPORT_C TSize GetScreenModeScale(TInt aMode) const;
    IMPORT_C TPoint GetCurrentScreenModeScaledOrigin() const;
    IMPORT_C TPoint GetScreenModeScaledOrigin(TInt aMode) const;
    IMPORT_C TInt GetScreenSizeModeList(RArray<TInt>* aModeList) const;
    IMPORT_C TDisplayMode GetScreenModeDisplayMode(const TInt &aMode) const;
//===== Used for testing purpose only ====//
    IMPORT_C TSizeMode GetCurrentScreenModeAttributes() const;
    IMPORT_C void SetCurrentScreenModeAttributes(const TSizeMode &aModeAtt);
    IMPORT_C TInt GetScreenNumber() const;
private:
    CFbsTypefaceStore* TypeFaceStore()const;
    TSize DisplaySizeInPixels()const;
    TSize PhysicalScreenSizeInTwips()const;
private: // Private data
    class CScrDevExtension;             //Implements extension interfaces, including and replacing typeface store
    CScrDevExtension* iExtension;
    TSize iPhysicalScreenSizeInTwips;
    TSize iDisplaySizeInPixels;
    friend class CWindowGc;
    };
 
 
class RWsSpriteBase : public MWsClientClass
// Client side class base class for sprites and pointer cursors
    {
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
    {
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
    {
public:
    IMPORT_C RWsPointerCursor();
    IMPORT_C RWsPointerCursor(RWsSession &aWs);
    IMPORT_C TInt Construct(TInt aFlags);
    };
 
 
class RAnim;
 
 
class RAnimDll : public MWsClientClass
    {
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
    {
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
    {
public:
    enum TTerminationReasons
        {
        ETerminateCancel,
        ETerminateRegion,
        ETerminateScreenMode,
        ETerminateRotation,
        };
    enum TPriority
        {
        EPriorityVeryHigh=2000,
        };
public:
    IMPORT_C RDirectScreenAccess();
    IMPORT_C RDirectScreenAccess(RWsSession& aWs);
    IMPORT_C TInt Construct();
    IMPORT_C TInt Construct(TBool aRegionTrackingOnly);
    IMPORT_C TInt Request(RRegion*& aRegion,TRequestStatus& aStatus,const RWindowBase& aWindow);
    IMPORT_C void Completed();
    IMPORT_C void Cancel();
    IMPORT_C void Close();
private:
    RWsSession* iWs;
    CDsaMsgQueue* iMsgQueue;
    // To maintain BC we need the following
    RThread iWsThread;
    TRequestStatus* iDummyRequest;
    };
 
 
class MAbortDirectScreenAccess
    {
public:
    virtual void AbortNow(RDirectScreenAccess::TTerminationReasons aReason)=0;
    };
 
 
class MDirectScreenAccess : public MAbortDirectScreenAccess
    {
public:
    virtual void Restart(RDirectScreenAccess::TTerminationReasons aReason)=0;
    };
 
 
class CDirectScreenAccess : public CActive
    {
public:
    IMPORT_C static CDirectScreenAccess* NewL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWin,MDirectScreenAccess& aAbort);
    IMPORT_C static CDirectScreenAccess* NewL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWin,MDirectScreenAccess& aAbort,TBool aRegionTrackingOnly);
    ~CDirectScreenAccess();
    IMPORT_C void StartL();
    inline CFbsBitGc* Gc();
    inline CFbsScreenDevice*& ScreenDevice();
    inline RRegion* DrawingRegion();
private:
    enum TFlags
        {
        EDirectCheckModeChange      =   0x01,
        EDirectCheckSizeModeChange  =   0x02,
        EDirectRegionTrackingOnly   =   0x04,
        };
private:
    inline CDirectScreenAccess(RWsSession& aWs,CWsScreenDevice* aScreenDevice,RWindowBase& aWindow,MDirectScreenAccess& aAbort);
    void ConstructL(RWsSession& aWs,TBool aRegionTrackingOnly);
    void CreateScreenObjectsL(TDisplayMode aCurrentMode);
    void UpdateSizeAndRotation(CFbsBitGc* aGc);
    static TInt Restart(TAny* aDirect);
    void Restart();
    //Pure virtual functions from CActive
    void DoCancel();
    void RunL();
private:
    CFbsBitGc* iGc;
    CFbsScreenDevice* iScreenDevice;
    RRegion* iDrawingRegion;
    RWindowBase& iWindow;
    CWsScreenDevice* iWsScreenDevice;
    MDirectScreenAccess& iAbort;
    RDirectScreenAccess iDirectAccess;
    RDirectScreenAccess::TTerminationReasons iReason;
    CIdle* iRestart;
    TSize iScreenSize;
    TBool iAborting;
    TUint iFlags;
    TInt iScreenNumber;
    };
 
 
class RSoundPlugIn : public MWsClientClass
    {
public:
    enum
        {
        ESoundWrongPlugIn=KMinTInt
        };
public:
    IMPORT_C RSoundPlugIn();
    IMPORT_C RSoundPlugIn(RWsSession &aWs);
    IMPORT_C TInt Construct(TUid aUid=KNullUid);
    IMPORT_C void Close();
    IMPORT_C void Destroy();
    IMPORT_C TBool IsLoaded(TBool& aIsChangeable) const;
    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() const;
    IMPORT_C TBool PenClickEnabled() const;
    IMPORT_C TInt CommandReply(TInt aOpcode, const TPtrC8 &aArgs);
    };
 
inline TInt MWsClientClass::WsHandle() const
    {return(iWsHandle);}
 
inline const TAny* CWsScreenDevice::GetInterface(TUint aInterfaceId) const
    {
    return const_cast<CWsScreenDevice*>(this)->GetInterface(aInterfaceId);
    }
 
inline TInt CWsScreenDevice::CreateContext(CWindowGc *&aGc)
    {return(CreateContext((CGraphicsContext *&)aGc));}
 
inline TUint TWsRedrawEvent::Handle() const
    {return(iHandle);}
 
inline TRect TWsRedrawEvent::Rect() const
    {return(iRect);}
 
inline TWsEvent::TWsEvent()
    {
    iType=0;
    iHandle=0;
    iTime=0;
    Mem::FillZ(iEventData,EWsEventDataSize);
    }
 
inline TAdvancedPointerEvent* TWsEvent::Pointer() const
    {return((TAdvancedPointerEvent *)&iEventData);}
 
inline TInt TAdvancedPointerEvent::PointerNumber() const
    {
    return IsAdvancedPointerEvent() ? DoGetPointerNumber() : ENonAdvancedPointerPointerNumber;
    }
 
inline TInt TAdvancedPointerEvent::Proximity() const
    {
    return IsAdvancedPointerEvent() ? DoGetProximity() : ENonAdvancedPointerZCoordinate;
    }
 
inline TInt TAdvancedPointerEvent::Pressure() const
    {
    return IsAdvancedPointerEvent() ? DoGetPressure() : ENonAdvancedPointerZCoordinate;
    }
 
inline TInt TAdvancedPointerEvent::ProximityAndPressure() const
    {return IsAdvancedPointerEvent() ? DoGetProximityAndPressure() : ENonAdvancedPointerZCoordinate;}
 
inline TPoint3D TAdvancedPointerEvent::PositionAndPressure3D() const
    {
    TPoint3D point3D;
    point3D.iX=iPosition.iX;
    point3D.iY=iPosition.iY;
    point3D.iZ=ProximityAndPressure();
    return point3D;
    }
 
inline TPoint3D TAdvancedPointerEvent::Position3D() const
    {
    TPoint3D point3D;
    point3D.iX=iPosition.iX;
    point3D.iY=iPosition.iY;
    point3D.iZ=IsAdvancedPointerEvent() ? DoGetProximity() : ENonAdvancedPointerZCoordinate;
    return point3D;
    }
 
inline TPoint3D TAdvancedPointerEvent::Pressure3D() const
    {
    TPoint3D point3D;
    point3D.iX=iPosition.iX;
    point3D.iY=iPosition.iY;
    point3D.iZ=IsAdvancedPointerEvent() ? DoGetPressure() : ENonAdvancedPointerZCoordinate;
    return point3D;
    }
 
inline TKeyEvent *TWsEvent::Key() const
    {return((TKeyEvent *)&iEventData);}
 
inline TWsVisibilityChangedEvent* TWsEvent::VisibilityChanged()
    { return reinterpret_cast<TWsVisibilityChangedEvent*>(iEventData); }
 
inline const TWsVisibilityChangedEvent* TWsEvent::VisibilityChanged() const
    { return reinterpret_cast<const TWsVisibilityChangedEvent*>(iEventData); }
 
inline TWsDisplayChangedEvent* TWsEvent::DisplayChanged()
    { return reinterpret_cast<TWsDisplayChangedEvent*>(iEventData); }
 
inline const TWsDisplayChangedEvent* TWsEvent::DisplayChanged() const
    { return reinterpret_cast<const TWsDisplayChangedEvent*>(iEventData); }
 
inline TModifiersChangedEvent *TWsEvent::ModifiersChanged() const
    {return((TModifiersChangedEvent *)&iEventData);}
 
inline TWsErrorMessage *TWsEvent::ErrorMessage() const
    {return((TWsErrorMessage *)&iEventData);}
 
inline TUint8 *TWsEvent::EventData() const
    {return((TUint8 *)&iEventData);}
 
inline TInt TWsEvent::Type() const
    {return(iType);}
 
inline TUint TWsEvent::Handle() const
    {return(iHandle);}
 
inline TTime TWsEvent::Time() const
    {return(iTime);}
 
inline void TWsEvent::SetType(TInt aType)
    {iType=aType;}
 
inline void TWsEvent::SetHandle(TUint aHandle)
    {iHandle=aHandle;}
 
inline void TWsEvent::SetTimeNow()
    {iTime.UniversalTime();}
 
inline TInt *TWsEvent::Int() const
    { return (TInt*)&iEventData; }
 
inline TUint TWsPriorityKeyEvent::Handle() const
    {return(iHandle);}
 
inline TKeyEvent *TWsPriorityKeyEvent::Key() const
    {return((TKeyEvent *)&iEventData);}
 
inline void TWsPriorityKeyEvent::SetHandle(TUint aHandle)
    {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()
    { return iGc; }
 
inline CFbsScreenDevice*& CDirectScreenAccess::ScreenDevice()
    { return iScreenDevice; }
 
inline RRegion* CDirectScreenAccess::DrawingRegion()
    { return iDrawingRegion; }
 
#endif //__W32STD_H__