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

// Shells for window server window functions.

// 

//

#include <e32std.h>

#include "../SERVER/w32cmd.h"

#include "CLIENT.H"

#include "w32comm.h"

#include <graphics/surface.h>

#include "rtfxeffect.h"

RWindowTreeNode::RWindowTreeNode()

/** Protected default constructor.

This creates a sessionless, uninitialised window tree node handle. This class 

is not for user derivation; however derived classes form part of the Window 

Server API.

Because RWindowTreeNode and its derived classes are lightweight handles, if 

your class contains an object of such a class, the object should be an inline 

member rather than a pointer member.

This default constructor allows you to instantiate such an inline member before 

the class that contains it has created a window server session. If you do this, 

you will need to call the RWindowTreeNode constructor that takes an RWsSession 

parameter before you can use the member, because RWindowTreeNode-derived objects 

must have a reference to a window server session in order to be valid. */

	{}

RWindowTreeNode::RWindowTreeNode(RWsSession &aWs) : MWsClientClass(aWs.iBuffer)

/** Protected constructor which creates an uninitialised window tree node handle 

within a server session. 

This class is not for user derivation; however derived classes form part of 

the standard Window Server API, and are constructed with a public 

constructor with the same signature as this one.

@param aWs Window server session. */

	{}

RWindowBase::RWindowBase() : RWindowTreeNode()

/** Protected default constructor; creates an uninitialised, sessionless window 

handle.

Handles to server-side objects must be created in a session in order to be 

operational; this constructor is merely a convenience to allow the handle 

to be stored as a data member. See RWindowTreeNode::RWindowTreeNode() for 

details of how the complete setup of a handle field may be deferred until 

the window server session is known. */

	{}

RWindowBase::RWindowBase(RWsSession &aWs) : RWindowTreeNode(aWs)

/** Protected constructor; creates an uninitialised window handle within a session.

@param aWs Window server session. */

	{}

RDrawableWindow::RDrawableWindow() : RWindowBase()

/** Protected default constructor which creates a sessionless, uninitialised drawable-window 

handle.

Handles to server-side objects must be created in a session in order to be 

operational; this constructor is merely a convenience to allow the handle 

to be stored as a data member. See RWindowTreeNode::RWindowTreeNode() for 

details of how the complete setup of a handle field may be deferred until 

the window server session is known */

	{}

RDrawableWindow::RDrawableWindow(RWsSession &aWs) : RWindowBase(aWs)

/** Protected default constructor which creates an initialised drawable-window 

handle within a server session.

@param aWs Window server session. */

	{}

EXPORT_C RWindow::RWindow() : RDrawableWindow()

/** Default constructor which creates a sessionless, uninitialised window handle. 

Handles to server-side objects must be created in a session in order to be 

operational; this constructor is merely a convenience to allow the handle 

to be stored as a data member. See RWindowTreeNode::RWindowTreeNode() for 

details of how the complete setup of a handle field may be deferred until 

the window server session is known. */

	{}

EXPORT_C RWindow::RWindow(RWsSession &aWs) : RDrawableWindow(aWs)

/** Constructor which creates an initialised window handle within a server session.

@param aWs Window server session to use. */

	{}

EXPORT_C RBackedUpWindow::RBackedUpWindow() : RDrawableWindow()

/** Default C++ constructor which creates a sessionless backed-up window handle.

Handles to server-side objects must be created in a session in order to be 

operational; this constructor is merely a convenience to allow the handle 

to be stored as a data member. See RWindowTreeNode::RWindowTreeNode() for 

details of how the complete setup of a handle field may be deferred until 

the window server session is known. */

	{}

EXPORT_C RBackedUpWindow::RBackedUpWindow(RWsSession &aWs) : RDrawableWindow(aWs)

/** Constructor which creates an uninitialised backed-up window handle within a 

session.

@param aWs The window server session that owns the window. */

	{}

EXPORT_C RBlankWindow::RBlankWindow() : RWindowBase()

/** Default C++ constructor which creates an invalid blank-window handle. 

See RWindowTreeNode::RWindowTreeNode() for details of how the complete setup 

of a handle field may be deferred until the window server session is known. */

	{}

EXPORT_C RBlankWindow::RBlankWindow(RWsSession &aWs) : RWindowBase(aWs)

/** Default C++ constructor which creates a valid but uninitialised blank-window 

handle. 

This constructor does not create a window in the window server: client programs 

must do this by calling RBlankWindow::Construct() before any operations can 

be carried out on the window.

@param aWs The window server session that owns the window. */

	{}

EXPORT_C RWindowGroup::RWindowGroup() : RWindowTreeNode()

/** Creates a sessionless, uninitialised window group handle.

Handles to server-side objects must be created in a session in order to be 

operational; this constructor is merely a convenience to allow the handle 

to be stored as a data member. See RWindowTreeNode::RWindowTreeNode() for 

details of how the complete setup of a handle field may be deferred until 

the window server session is known. */

	{}

EXPORT_C RWindowGroup::RWindowGroup(RWsSession &aWs) : RWindowTreeNode(aWs)

/** Creates an initialised window group handle within a server session.

@param aWs The window server session owning the window group. */

	{}

EXPORT_C void RWindowTreeNode::Close()

/** Closes the node. 

This function should be called on all windows once they are no longer needed. 

It causes the window server to destroy the server-side window, and frees client-side 

resources owned by the window.

Note: When Close() is called on a parent window, its children are disconnected 

from the window tree and are hence removed from the screen. However, any client-side 

resources owned by its children are not freed. To free these resources, Close() 

(or Destroy()) must be called on all its children individually. */

	{

	if (iBuffer && iWsHandle)

	    {

	    if (WindowSizeCacheEnabled())

	         {

	         DestroyWindowSizeCacheEntry();

	         }

        Write(EWsWinOpFree);

	    }

	iWsHandle=NULL;

	}

EXPORT_C void RWindowTreeNode::Destroy()

/** Closes and deletes the node. 

This function calls Close() followed by delete on the window. Use this function 

only when the window is allocated in its own heap cell. */

	{

	Close();

	delete this;

	}

EXPORT_C TUint32 RWindowTreeNode::ClientHandle() const

/** Gets the window's client handle

The return value is the client's integer handle that was passed as an argument

to the window's Construct() function: see RWindow::Construct()

for a description of the client handle.

This function always causes a flush of the window server buffer.

@return Handle ID for the window.

@see RWindow::Construct() */

	{

	return(WriteReply(EWsWinOpClientHandle));

	}

EXPORT_C TUint32 RWindowTreeNode::Parent() const

/** Gets the node's parent. 

The return value is the client's integer handle that was passed as an argument 

to the parent window tree node's Construct() function: see RWindow::Construct() 

for a description of the client handle.

If called on a window group, this function returns 0, as window groups have 

no parent.

This function always causes a flush of the window server buffer.

@return Handle ID for the parent, or zero for window groups. 

@see Child() 

@see RWindow::Construct() */

	{

	return(WriteReply(EWsWinOpParent));

	}

EXPORT_C TUint32 RWindowTreeNode::PrevSibling() const

/** Gets the node before this one in the sibling list. 

The return value is the client handle that was passed in the previous sibling window's 

Construct() function: see RWindow::Construct() for a description of the client handle.

This function always causes a flush of the window server buffer.

@return Handle ID for the previous sibling, or zero if no previous sibling exists. 

@see NextSibling() 

@see RWindow::Construct() */

	{

	return(WriteReply(EWsWinOpPrevSibling));

	}

EXPORT_C TUint32 RWindowTreeNode::NextSibling() const

/** Gets the next window after this one in its sibling list. 

The return value is the client handle that was passed in the next sibling 

window's Construct() function: see RWindow::Construct() for a description of the 

client handle.

This function always causes a flush of the window server buffer.

@return Window handle of next sibling, or 0 if no next sibling exists. 

@see PrevSibling()

@see Child()

@see Parent() */

	{

	return(WriteReply(EWsWinOpNextSibling));

	}

EXPORT_C TUint32 RWindowTreeNode::Child() const

/** Gets the first child of the node.

This function always causes a flush of the window server buffer.

@return The client handle of the child node that currently has ordinal position 

0. This is 0 if there isn't a child. */

	{

	return(WriteReply(EWsWinOpChild));

	}

EXPORT_C void RWindowTreeNode::__DbgTestInvariant() const

/** In debug builds, this function always causes a flush of the window 

server buffer. */

	{

#if defined(_DEBUG)

	if (WriteReply(EWsWinOpTestInvariant))

		User::Invariant();

#endif

	}

EXPORT_C void RWindowTreeNode::SetOrdinalPosition(TInt aPos)

/** Sets the ordinal position of a window. 

A window's ordinal position is relative to its siblings with the same 

ordinal priority. The ordinal priority of displayable windows (in other words, 

not window groups) is almost always zero (the default). To set the ordinal priority 

as well as the ordinal position, use the other overload of this function. 

The lower the ordinal position, the nearer the window will be to the front of the z-order. 

The frontmost window has ordinal position zero. Specifying a negative value has the effect 

of sending the window to the back of the z-order.

Note: If this window is a window group in a chain, then all other window groups in the chain will be moved also.

When this function is called on Group Window with aPos set to KOrdinalPositionSwitchToOwningWindow then the 

function doesn't change the ordinal position of the group window, if instead it has focus then the window group 

that would come to the forground if it died will be moved to the foreground.

@param aPos The window's new ordinal position. The lower the ordinal, the closer to the 

front of the z-order the window will be. Specifying any negative value however, sends 

the window to the back of the z-order. */

	{

	WriteInt(aPos,EWsWinOpSetOrdinalPosition);

	}

EXPORT_C void RWindowTreeNode::SetOrdinalPosition(TInt aPos,TInt aOrdinalPriority)

/** Sets the ordinal position and ordinal priority of a window. 

Ordinal priority is a number assigned to a window that determines its position in the z-order. 

For sibling windows or group windows, the higher the priority, the closer it will be to the 

front. Ordinal priority overrides ordinal position, so that the ordinal position 

is only taken into account for sibling windows or window groups with the same ordinal priority. 

For a description of ordinal position, see the other overload of this function.

Most windows have an ordinal priority of zero. Only window groups are normally 

given non-default ordinal priorities.

To set priority of KPasswordWindowGroupPriority or greater on a window group, client will require 

SwEvent capability. If client does not have SwEvent capability then priority will be reduced 

to KPasswordWindowGroupPriority-1. This function doesn't return an error thus the client cannot 

tell if the priority is reduced, however, there is another function that can be used if the client 

does require an error, this is RWindowGroup::SetOrdinalPositionErr.

Note: If this window is a window group in a chain, then all other window groups in the chain will be moved also. 

And further they will all have their ordinal priority set to the specified value.

When this function is called on Group Window with aPos set to KOrdinalPositionSwitchToOwningWindow then the 

function doesn't change the ordinal position of the group window, if instead it has focus then the window group 

that would come to the forground if it died will be moved to the foreground.

@param aPos The window's new ordinal position. The lower the ordinal, the closer to the 

front of the z-order the window will be. Specifying any negative value however, sends 

the window to the back of the z-order.

@param aOrdinalPriority The window's new ordinal priority. */

	{

	TWsWinCmdOrdinalPos ordinalPos;

	ordinalPos.pos=aPos;

	ordinalPos.ordinalPriority=aOrdinalPriority;

	Write(&ordinalPos,sizeof(ordinalPos),EWsWinOpSetOrdinalPositionPri);

	}

EXPORT_C TInt RWindowTreeNode::OrdinalPriority() const

/** Gets the ordinal priority of the specified window.

This function was added for FEPs that need to know the priority in their dialogues. 

This function and RWsSession::GetWindowGroupOrdinalPriority() may return different 

values because this function isn't subject to any ordinal priority adjustment, 

while the window group ordinal priority may be.

This function always causes a flush of the window server buffer.

@return The ordinal priority of the specified window */

	{

	return(WriteReply(EWsWinOpOrdinalPriority));

	}

EXPORT_C TInt RWindowTreeNode::OrdinalPosition() const

/** Gets the current ordinal position of the window tree node. 

The ordinal position returned is the window's position amongst windows with 

the same parent (an with the same priority). Displayable windows almost always 

have the same priority, but window groups might typically have different priorities. 

If a window group's ordinal position among window groups of all priorities 

is required, use FullOrdinalPosition().

Note: all group windows (across all clients) have the same parent.

This function always causes a flush of the window server buffer.

@return The window's ordinal position. */

	{

	return(WriteReply(EWsWinOpOrdinalPosition));

	}

EXPORT_C TInt RWindowTreeNode::FullOrdinalPosition() const

/** Get the current full ordinal position of a window. 

This function normally returns a useful value only when called on a window 

group, because only window groups are normally given different priorities. 

For other types of window the value returned is usually the same as that returned 

by OrdinalPosition().

This function always causes a flush of the window server buffer.

@return The window's full ordinal position. */

	{

	return(WriteReply(EWsWinOpFullOrdinalPosition));

	}

/**Get the screen number that a window is located on

@return The screen number that the window is located on

 */

EXPORT_C TInt RWindowTreeNode::ScreenNumber() const

	{

	return(WriteReply(EWsWinOpScreenNumber));

	}

EXPORT_C TInt RWindowTreeNode::WindowGroupId() const

/** Returns the window group Id of the parent window group

If the window is a window group it will return it's Id. If it is not it scans 

up the window tree to find the group window from which this window is descended 

and returns it's Id.

This function always causes a flush of the window server buffer.

@return The window group Id of the window group from which this window is descended. */

	{

	return(WriteReply(EWsWinOpWindowGroupId));

	}

EXPORT_C TInt RWindowTreeNode::EnableOnEvents(TEventControl aCircumstances)

/** Requests notification of 'on' events. 'On' events are of type EEventSwitchOn.

This function always causes a flush of the window server buffer.

@param aCircumstances The circumstances in which 'on' events are to be reported. 

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see DisableOnEvents() */

	{

	return(WriteReplyInt(aCircumstances,EWsWinOpEnableOnEvents));

	}

EXPORT_C void RWindowTreeNode::DisableOnEvents()

/** Cancels notification of 'on' events. 

This function instructs the server to stop reporting 'on' events to this window. 

If the window server has not previously been instructed to report 'on' events, 

this method has no effect (i.e. the default is that windows do not get the 

events).

@see EnableOnEvents() */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableOnEvents);

	}

EXPORT_C TInt RWindowTreeNode::EnableGroupChangeEvents()

/** Requests notification of group-change events.

Use this function to instruct the window server to report group-change events 

to this window. These events will typically be of interest to a shell or similar 

application, for example to notify it that it should update its list of running 

applications. Window group changed events are of type EEventWindowGroupsChanged.

This function always causes a flush of the window server buffer.

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see DisableGroupChangeEvents() */

	{

	return(WriteReply(EWsWinOpEnableGroupChangeEvents));

	}

EXPORT_C void RWindowTreeNode::DisableGroupChangeEvents()

/** Cancels notification of group changed events. 

Use this function to instruct the server to stop reporting window group changed 

events to this window. If the window server has not previously been instructed 

to report window group changed events, this function has no effect (i.e. the 

default is that windows do not get the events).

@see EnableGroupChangeEvents() */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableGroupChangeEvents);

	}

EXPORT_C TInt RWindowTreeNode::EnableFocusChangeEvents()

/** Enables focus changed events.

After this function is called, the EEventFocusGroupChanged event is delivered 

to the window server message queue every time the focus window group changes. 

The handle of the event is set to the client handle of the window that this 

function is called on.

This function always causes a flush of the window server buffer.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. 

@see DisableFocusChangeEvents() */

	{

	return(WriteReply(EWsWinOpEnableFocusChangeEvents));

	}

EXPORT_C void RWindowTreeNode::DisableFocusChangeEvents()

/** Disables delivery of focus changed events.

Use this function to instruct the server to stop reporting window group focus 

changed events to this window. If the window server has not previously been 

instructed to report window group changed events, this function has no effect 

(i.e. the default is that windows do not get the events).

@see EnableFocusChangeEvents() */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableFocusChangeEvents);

	}

EXPORT_C TInt RWindowTreeNode::EnableGroupListChangeEvents()

/** Enables reporting of window group list change events.

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

this function will cause notification events (of type EEventWindowGroupListChanged) 

for any change in the window group list: additions, removals and reorderings.

This function is useful when you need to know about changes to window groups 

beneath the focused one, for instance when the screen is showing windows from 

more than one window group at the same time.

The handle of the event is set to the client handle of the window that this 

function is called on.

This function always causes a flush of the window server buffer.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

	{

	return(WriteReply(EWsWinOpEnableGroupListChangeEvents));

	}

EXPORT_C void RWindowTreeNode::DisableGroupListChangeEvents()

/** Disables reporting of window group list change events.

This function instructs the window server to stop sending window group list 

change events to this window. If the window server has not previously been 

instructed to report window group list change events, this function has no 

effect (i.e. the default is that windows do not receive group list change 

events). */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableGroupListChangeEvents);

	}

EXPORT_C TInt RWindowTreeNode::EnableVisibilityChangeEvents()

/** Enables reporting of window visibility change events.

The window visibility is based on whether or not any area of the window can be seen

on the screen.  This can be affected by SetVisible(), but also by other windows in

front of this one, and by the presence of transparent windows which it can be seen

through.  Calling this function will cause notification events (of type

EEventWindowVisibilityChanged) for any change in the window's visibility.

This function is useful when you are performing graphical processing such as animations

and would like to stop them while they cannot be seen, for efficiency reasons.

The handle of the event is set to the client handle of the window that this 

function is called on.

This function always causes a flush of the window server buffer.

@return KErrNone if successful, otherwise another of the system-wide error 

codes. */

	{

	return(WriteReply(EWsWinOpEnableVisibilityChangeEvents));

	}

EXPORT_C void RWindowTreeNode::DisableVisibilityChangeEvents()

/** Disables reporting of window visibility change events.

This function instructs the window server to stop sending window visibility 

change events to this window. If the window server has not previously been 

instructed to report window visibility change events, this function has no 

effect (i.e. the default is that windows do not receive visibility change 

events). */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableVisibilityChangeEvents);

	}

EXPORT_C TInt RWindowTreeNode::EnableErrorMessages(TEventControl aCircumstances)

/** Requests notification of error message events. 

Use this function to instruct the window server to report error message events 

(of type EEventErrorMessage).

This function always causes a flush of the window server buffer.

@param aCircumstances The circumstances in which error message events are 

to be reported. 

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see DisableErrorMessages() */

	{

	return(WriteReplyInt(aCircumstances,EWsWinOpEnableErrorMessages));

	}

EXPORT_C void RWindowTreeNode::DisableErrorMessages()

/** Cancels notification of error message events. 

Use this function to instruct the server to stop reporting error message events 

to this window. If the window server has not previously been instructed to 

report error message events, this function has no effect (i.e. the default 

is that windows do not get error messages).

@see EnableErrorMessages() */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableErrorMessages);

	}

EXPORT_C TInt RWindowTreeNode::EnableModifierChangedEvents(TUint aModifierMask, TEventControl aCircumstances)

/** Requests notification of modifier changed events. 

Use this function to instruct the window server to report modifier changed 

events to this window. Values for the modifier keys are defined in TEventModifier. 

If more than one modifier key is to be monitored, their values should be combined 

using a bit-wise OR operation. Modifier changed events are of type EEventModifiersChanged.

This function always causes a flush of the window server buffer.

@param aModifierMask The modifiers to be reported. May be a combination of 

values defined in TEventModifier 

@param aCircumstances The circumstances in which modifier changed events are 

to be reported. 

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see DisableModifierChangedEvents() */

	{

	TWsWinCmdEnableModifierChangedEvents params(aModifierMask, aCircumstances);

	return(WriteReply(&params,sizeof(params),EWsWinOpEnableModifierChangedEvents));

	}

EXPORT_C void RWindowTreeNode::DisableModifierChangedEvents()

/** Cancels notification of modifier changed events. 

Use this function to instruct the server to stop reporting modifier changed 

events to this window. If the window server has not previously been instructed 

to report modifier changed events, this function has no effect (i.e. the default 

is that windows do not get the events).

@see EnableModifierChangedEvents() */

	{

	if (iWsHandle)

		Write(EWsWinOpDisableModifierChangedEvents);

	}

EXPORT_C TInt RWindowTreeNode::SetPointerCursor(TInt aCursorNumber)

/** Sets the pointer cursor from the system pointer cursor list. 

Use this function to set the current cursor to one contained in the system 

pointer cursor list. If the list does not contain a cursor with an index of 

aCursorNumber, the function will attempt to set the cursor to the default 

system pointer cursor, which has an index of 0 in the list.

The RWsSession class provides functions for setting and controlling the system 

pointer cursor list.

This function always causes a flush of the window server buffer.

@param aCursorNumber The cursor index in the system pointer cursor list. 

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see ClearPointerCursor() */

	{

	return(WriteReplyInt(aCursorNumber,EWsWinOpSetPointerCursor));

	}

EXPORT_C void RWindowTreeNode::SetCustomPointerCursor(const RWsPointerCursor &aPointerCursor)

/** Sets the pointer cursor to an application-defined cursor.

@param aPointerCursor The cursor to use. */

	{

	WriteInt(aPointerCursor.WsHandle(),EWsWinOpSetCustomPointerCursor);

	}

EXPORT_C void RWindowTreeNode::SetNonFading(TBool aNonFading)

/** Sets whether a window is non-fading.

When the non-fading flag is set the window will unfade if needed and remain 

unfaded until this flag is removed. This is useful for toolbars etc. which 

must never be faded.

@param aNonFading ETrue to set the non-fading flag, EFalse (the default) to 

re-set it. */

	{

	WriteInt(aNonFading,EWsWinOpSetNonFading);

	}

EXPORT_C void RWindowTreeNode::SetFaded(TBool aFaded,TFadeControl aIncludeChildren)

/** Sets the window as faded or unfaded.

This function allows a single window to be faded or unfaded. The function 

also allows the same action to be applied to all of the window's children.

Notes:

A redraw is required to un-fade a window because information is lost during 

fading (blank and backup windows deal with this themselves). Areas in shadow 

when the window is faded also require a redraw. 

While a window is faded, all drawing to that window will be adjusted appropriately 

by the window server.

@param aFaded ETrue to fade the window, EFalse to un-fade it. 

@param aIncludeChildren Fade control flags. These set whether fading/un-fading 

also apply to child windows. */

	{

	TWsWinCmdSetFaded params(aFaded,aIncludeChildren);

	Write(&params,sizeof(params),EWsWinOpSetFade);

	}

EXPORT_C void RWindowTreeNode::SetFaded(TBool aFaded,TFadeControl aIncludeChildren,TUint8 aBlackMap,TUint8 aWhiteMap)

/** Sets one or more windows as faded or unfaded, specifying a fading map. 

Fading is used to change the colour of a window to make other windows stand 

out. For example, you would fade all other windows when displaying a dialogue. 

Fading makes a window closer to white or closer to black.

Setting the fading map allows you to over-ride the default fading parameters 

set in RWsSession::SetDefaultFadingParameters(). 

The white and black fading values define the range over which colours are 

re-mapped when a window is faded. As the values get closer together, all colours 

in the faded window becomes more similar, creating the fading effect. 

When the numbers cross over (so that the black value is greater than the white 

value) the colours in the faded window start to invert, i.e. colours that 

were closer to white in the unfaded window are mapped to a darker colour when 

the window is faded.

The function also allows the fading action applied to this window to be applied 

to all of its children.

Notes:

Fading a window for a 2nd time will not change the fading map used. 

A redraw is required to un-fade a window because information is lost during 

fading. Note that blank (RBlankWindow) and backup (RBackedUpWindow) windows 

deal with this themselves. Areas in shadow when the window is faded also require 

a redraw. 

While a window is faded all drawing to that window will be adjusted appropriately 

by the window server.

@param aFaded ETrue to fade the window, EFalse to un-fade it. 

@param aIncludeChildren Fade control flags. This sets whether fading/un-fading 

is also to apply to all child windows. 

@param aBlackMap Black map fading parameter.

@param aWhiteMap White map fading parameter. 

@see RWsSession::SetDefaultFadingParameters()

@see CWindowGc::SetFadingParameters() */

	{

	TWsWinCmdSetFaded params(aFaded,aIncludeChildren,EFalse,aBlackMap,aWhiteMap);

	Write(&params,sizeof(params),EWsWinOpSetFade);

	}

EXPORT_C void RWindowTreeNode::ClearPointerCursor()

/** Clears pointer cursor settings.

These are the settings made by calling SetPointerCursor(). */

	{

	Write(EWsWinOpClearPointerCursor);

	}

/** Returns the window server session that is used to create this window handle. 

This functions returns null if the window handle is not initialised.

@see RWindowTreeNode(RWsSession &aWs)

*/

EXPORT_C RWsSession* RWindowTreeNode::Session() const

	{

	return iBuffer? iBuffer->Session() : NULL;

	}

/** @panic TW32Panic 17 in debug builds if called on an already constructed object.*/

TInt RWindowBase::construct(const RWindowTreeNode &parent,TUint32 aClientHandle, TInt aType, TDisplayMode aDisplayMode)

	{

	__ASSERT_DEBUG(iWsHandle == KNullHandle, Panic(EW32PanicGraphicDoubleConstruction));

	TWsClCmdCreateWindow createWindow;

	createWindow.parent=parent.WsHandle();

	createWindow.clientHandle=aClientHandle;

	createWindow.type=(TWinTypes)aType;

	createWindow.displayMode=aDisplayMode;

	TInt ret=iBuffer->WriteReplyWs(&createWindow,sizeof(createWindow),EWsClOpCreateWindow);

	if (ret<0)

		return(ret);

	iWsHandle=ret;

	return(KErrNone);

	}

EXPORT_C void RWindowBase::Activate()

/** Displays the window and enables it to receive events. 

Calling this method on a window causes it to receive a redraw event 

if it is a non-backed-up window, and should be called after a window has 

been constructed and initialised.

Windows are not displayed automatically when they are constructed. This allows 

them to be customised using SetPosition(), SetOrdinalPosition(), SetExtent(), 

etc., before they are displayed. */

	{

	Write(EWsWinOpActivate);

	}

EXPORT_C TPoint RWindowBase::Position() const

/** Gets a window's position relative to its parent.

This function always causes a flush of the window server buffer.

@return Position of this window's origin relative to the origin of its parent. */

	{

	TPckgBuf<TPoint> pntPkg;

  	WriteReplyP(&pntPkg,EWsWinOpPosition);

	return(pntPkg());

	}

EXPORT_C TPoint RWindowBase::AbsPosition() const

/** Gets a window's absolute position - ie the windows position relative 

to the current screen size mode.

This function always causes a flush of the window server buffer.

@return Position of this window's origin relative to the screen. */

	{

	TPckgBuf<TPoint> pntPkg;

  	WriteReplyP(&pntPkg,EWsWinOpAbsPosition);

	return(pntPkg());

	}

EXPORT_C TSize RWindowBase::Size() const

/** Gets the window's current size.

This function always causes a flush of the window server buffer.

@return Current size of window. */

	{

	if (!WindowSizeCacheEnabled())

	    {

        TPckgBuf<TSize> sizePkg;

        WriteReplyP(&sizePkg,EWsWinOpSize);

        return (sizePkg());

        }

    else

        {

        TSize size;

        if (CachedWindowSize(size) == KErrNone)

            {

            iBuffer->Flush(NULL, EFalse);

            return size;

            }

        else

            {

            TPckgBuf<TSize> sizePkg;

            WriteReplyP(&sizePkg,EWsWinOpSize);

            size = sizePkg();

            RefreshWindowSizeCache(size);

            return size;

            }

        }

	}

/**

@internalAll

Disclaimer - this API is internal and is subject to change

@deprecated */

EXPORT_C TSize RWindowBase::SizeForEgl() const

    {

    return Size();

    }

EXPORT_C void RWindowBase::SetPosition(const TPoint &aPos)

/** Sets the position of a window relative to its parent. 

The co-ordinates given in aPos specify the position of the top left-hand 

corner of the window, relative to the top left-hand corner of its parent. 

A positive value indicates a direction to the right and down. Negative values 

are valid but will cause part of the window to be outside its parent's extent, 

and therefore clipped.

This function may be called at any time after the window's Construct() function: 

the window's position will change dynamically.

A window's position can also be set using the RWindow::SetExtent() and RWindowBase::SetExtentErr() 

functions.

Note: upon creation, a window's extent is the same as its parent’s. In other words 

it has the same origin and size. If the window’s parent is a group window, it is 

initialised to be full screen.

@param aPos The position of the window's origin, relative to its parent */

	{

	WritePoint(aPos,EWsWinOpSetPos);

	}

EXPORT_C TInt RWindowBase::SetSizeErr(const TSize &aSize)

/** Sets the size of a backed-up window. 

A window's size is not constrained by the size of its parent. However, its 

visible region is, and the child window's visible region will always be clipped 

to the parent's visible region.

Avoid using this function for a window known to be of type RBlankWindow or 

RWindow (i.e. not a backed-up window). Instead, use SetSize(), which is more 

efficient as it does not return a value. However, if the window is a backed-up 

window, or of unknown type, SetSizeErr() should be used, because 

setting the size of a backed-up window may cause an out-of-memory error.

This function may be called at any time after the window's Construct() function: 

the window's size will change dynamically.

This function always causes a flush of the window server buffer.

@param aSize Window size.

@return KErrNone if successful, otherwise one of the system-wide error codes. 

@see RWindow::SetSize()

@see RWindow::SetExtent()

@see RWindowBase::SetExtentErr() */

	{

	TInt err = WriteReply(&aSize,sizeof(aSize),EWsWinOpSetSizeErr);

	if (WindowSizeCacheEnabled())

	    {

        MarkWindowSizeCacheDirty();     

	    }

	return err;

	}

EXPORT_C TInt RWindowBase::SetExtentErr(const TPoint &pos,const TSize &size)

/** Sets a backed-up window's extent, relative to its parent, and returns an error 

code from the server. 

See SetPosition() and SetSizeErr() for a description of the rules applying 

to aPoint and aSize respectively.

Avoid using this function for a window of type RBlankWindow or RWindow (in other words, 

not a backed-up window). Instead, use SetExtent(), which is more efficient 

as it does not return a value. However, if the window is a backed-up window, 

or of unknown type, SetExtentErr() should be used, because setting 

the extent of a backed-up window may cause an out-of-memory error.

This function may be called at any time after the window's Construct() function: 

the window's extent will change dynamically.

This function always causes a flush of the window server buffer.

@param pos The position of the window's origin, relative to its parent. 

@param size Window size. 

@return KErrNone if successful, otherwise one of the system-wide error codes. */

	{

	TWsWinCmdSetExtent setExtent(pos,size);

	TInt err = WriteReply(&setExtent,sizeof(setExtent),EWsWinOpSetExtentErr);

	if (WindowSizeCacheEnabled())

	    {

        MarkWindowSizeCacheDirty();     

	    }

	return err;

	}

EXPORT_C TPoint RWindowBase::InquireOffset(const RWindowTreeNode &aWindow) const

/** Enquires the offset between this and another window. 

A positive value indicates a position to the right and down from aWindow, 

a negative value indicates a position to the left and up.

This function always causes a flush of the window server buffer.

@param aWindow Another window tree node. 

@return The offset of this window relative to aWindow. */

	{

	TPckgBuf<TPoint> pkgPoint;

	TUint32 handle=aWindow.WsHandle();

	WriteReplyP(&handle,sizeof(handle),&pkgPoint,EWsWinOpInquireOffset);

	return(pkgPoint());

	}

EXPORT_C void RWindowBase::PointerFilter(TUint32 aFilterMask, TUint32 aFilter)

/** Sets the filter which controls which pointer events are sent to the client 

session. 

A pointer filter can be defined for each window separately, and changed dynamically. 

The default behaviour when a window is created is that move, drag, enter and 

exit events are filtered out and not delivered to the client.

@param aFilterMask Bitwise OR of values from TPointerFilter masking event 

types which will be updated. 

@param aFilter Bits containing new values for the masked event types. A 1 bit 

causes the corresponding event to be filtered out, a 0 bit lets through the 

corresponding event. 

@see TPointerFilter */

	{

	TWsWinCmdPointerFilter params;

	params.mask=aFilterMask;

	params.flags=aFilter;

	Write(&params,sizeof(params),EWsWinOpPointerFilter);

	}

EXPORT_C void RWindowBase::SetPointerCapture(TInt aFlags)

/** Sets the pointer capture state.

A window which has called this function can capture events that would otherwise 

go to other windows. Normally, pointer events are sent to the window at 

the co-ordinates where the event occurs. Capturing only works on windows which 

are behind the capturing window in the z order. 

Capture can be enabled or disabled. If capturing is enabled a window will, 

by default, capture events only from windows in the same window group. A flag 

can be specified to allow it to capture events across all window groups.

Another flag can be used to specify drag-drop capture. This causes a drag-drop 

message to be sent to the window within which the pen was lifted. Drag-drop 

with a pen is a tap-drag-lift sequence.

Capture functionality is useful in situations where only the foreground window