diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/nonnga/CLIENT/RANIM.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/nonnga/CLIENT/RANIM.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,447 @@ +// Copyright (c) 1995-2009 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 Animate DLL +// +// + +#include +#include "../SERVER/w32cmd.h" +#include "w32comm.h" +#include "CLIENT.H" + +EXPORT_C RAnimDll::RAnimDll() +/** Default constructor. + +RAnimDll is a lightweight class which can be allocated as a non-pointer member. +This constructor is provided to allow such a member to be instantiated while +its owner is constructed. + +Note that an RAnimDll constructed without a reference to a window server session +is invalid. */ + {} + +EXPORT_C RAnimDll::RAnimDll(RWsSession &aWs) : MWsClientClass(aWs.iBuffer) +/** Valid constructor. + +To be useable, an animation DLL should always be constructed with a reference +to a window server session as argument. + +@param aWs Window server session to use. */ + {} + +EXPORT_C RAnimDll::~RAnimDll() +/** Empty virtual destructor. + +Destroy() should be used to instead of this function to destroy both this +object and the server-side CAnimDll object. + +@see Destroy() +@see Close() */ + {} + +EXPORT_C void RAnimDll::Close() +/** Closes an animation DLL. + +Use this function to close a polymorphic DLL which was previously loaded on +the server. Cleans up and frees all resources belonging to the DLL but does +not delete it. Closing is in accordance with the RLibrary mechanism. + +Load() and Close() are symmetrical operations. A DLL can be re-loaded after +a close has been called on it. + +To both close and delete a previously loaded DLL, use Destroy(). */ + { + if (iBuffer && iWsHandle) + Write(EWsAnimDllOpFree); + iWsHandle=NULL; + } + +EXPORT_C void RAnimDll::Destroy() +/** Closes and deletes a previously loaded polymorphic DLL. + +This function is equivalent to calling this->Close() followed by delete this, +in accordance with the RLibrary mechanism provided for managing polymorphic +DLLs. */ + { + Close(); + delete this; + } + +EXPORT_C TInt RAnimDll::Load(const TDesC &aFileName) +/** Instructs the server to load an animation DLL. + +Use this function to pass the name of a polymorphic DLL, the animation DLL, +for loading on the server side. Loading is in accordance with the RLibrary +mechanism. The DLL must conform to the interface defined by the window server, +otherwise an error will result. For requirements, see the description of CAnimDll. + +Load() and Close() are symmetrical operations. A DLL can be re-loaded after +a close has been called on it. + +This function always causes a flush of the window server buffer. + +@param aFileName Filename of the DLL to load. +@return KErrNone if successful, otherwise one of the system-wide error codes. +@panic TW32Panic 17 in debug builds if called on an already constructed object.*/ + { + __ASSERT_DEBUG(iWsHandle == KNullHandle, Panic(EW32PanicGraphicDoubleConstruction)); + TWsClCmdLoadAnimDll load; + load.length=aFileName.Length(); + TInt ret; + ret=iBuffer->WriteReplyWs(&load,sizeof(load),aFileName.Ptr(),aFileName.Size(),EWsClOpCreateAnimDll); + if (ret<0) + return(ret); + iWsHandle=ret; + return(KErrNone); + } + +TInt RAnimDll::CommandReply(TInt aHandle, TInt aOpcode, const TDesC8& aArgs, const TIpcArgs* aIpcArgs) + { + TInt params[2]; + params[0]=aHandle; + params[1]=aOpcode; + return(WriteReply(¶ms,sizeof(params),aArgs.Ptr(),aArgs.Length(),EWsAnimDllOpCommandReply,aIpcArgs)); + } + +TInt RAnimDll::CommandReply(TInt aHandle, TInt aOpcode, const TIpcArgs* aIpcArgs) + { + TInt params[2]; + params[0]=aHandle; + params[1]=aOpcode; + return(WriteReply(¶ms,sizeof(params),EWsAnimDllOpCommandReply,aIpcArgs)); + } + +void RAnimDll::Command(TInt aHandle, TInt aOpcode, const TPtrC8 &aArgs) + { + TInt params[2]; + params[0]=aHandle; + params[1]=aOpcode; + Write(¶ms,sizeof(params),aArgs.Ptr(),aArgs.Length(),EWsAnimDllOpCommand); + } + +void RAnimDll::Command(TInt aHandle, TInt aOpcode) + { + TInt params[2]; + params[0]=aHandle; + params[1]=aOpcode; + Write(¶ms,sizeof(params),EWsAnimDllOpCommand); + } + +void RAnimDll::AsyncCommandReply(TRequestStatus& aStatus, TInt aOpcode, TIpcArgs& aIpcArgs) + { + __ASSERT_DEBUG((aOpcode&EWservMessAnimDllAsyncCommand)==0, Assert(EW32AssertIllegalOpcode)); + aIpcArgs.Set(KAsyncMessageSlotAnimDllHandle,iWsHandle); + iBuffer->Flush(); // needs to happen first so that things occur in their correct order, and because this asynchronous function uses a different mechanism, i.e. assigns different meanings to, say, the first slot in the TIpcArgs + iBuffer->Session()->SendReceive((aOpcode|EWservMessAnimDllAsyncCommand),aIpcArgs,aStatus); + } + +TInt RAnimDll::CreateInstance(TInt32& aHandle, const MWsClientClass &aDevice, TInt aType, const TDesC8 &aArgs, TInt aOpcode, const TIpcArgs* aIpcArgs) + { + TInt params[2]; + params[0]=aDevice.WsHandle(); + params[1]=aType; + const TInt returnValue=WriteReply(¶ms,sizeof(params),aArgs.Ptr(),aArgs.Length(),aOpcode,aIpcArgs); + if (returnValue>=0) + { + aHandle=returnValue; + return KErrNone; + } + return returnValue; + } + +void RAnimDll::DestroyInstance(TInt aHandle) + { + WriteReplyInt(aHandle,EWsAnimDllOpDestroyInstance); + } + +EXPORT_C RAnim::RAnim() : iHandle(0) +/** Default constructor. Developers should use the other constructor overload. */ + {} + +EXPORT_C RAnim::RAnim(RAnimDll &aDll) : iHandle(0),iAnimDll(&aDll) +/** Protected C++ constructor. + +This constructor should be used to construct an animation object from a given +animation DLL. The DLL must be loaded first, see the discussion of RAnimDll. + +@param aDll The animation DLL. */ + {} + +EXPORT_C RAnim::~RAnim() +/** Empty virtual destructor. */ + {} + +EXPORT_C TInt RAnim::Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams) +/** Completes construction of the object based on a window device, and creates +the server-side animation system. + +Construction information is passed to the server side via aType and aParams. +The server then passes the information to the function CreateInstanceL() inside +the Anim DLL. + +This function always causes a flush of the window server buffer. + +@param aDevice A window device. +@param aType The type of this animation object, as understood by CAnimDll::CreateInstanceL(). +@param aParams Packaged arguments which will be passed to the server side object +to tell it how to construct itself or initialise itself. +@return KErrNone if successful, otherwise one of the system-wide error codes. +@see CAnim::ConstructL() +@see CAnimDll::CreateInstanceL() */ + { + return iAnimDll->CreateInstance(iHandle, aDevice, aType, aParams, EWsAnimDllOpCreateInstance, NULL); + } + +EXPORT_C TInt RAnim::Construct(const RWindowBase &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs) +/** Completes construction of the object based on a window device, and creates +the server-side animation system. + +Construction information is passed to the server side via aType and aParams. +The server then passes the information to the function CreateInstanceL() inside +the Anim DLL. + +This function always causes a flush of the window server buffer. + +@param aDevice A window device. +@param aType The type of this animation object, as understood by CAnimDll::CreateInstanceL(). +@param aParams Packaged arguments which will be passed to the server side object +to tell it how to construct itself or initialise itself. +@param aIpcArgs Inter-process communication arguments which will be passed to the server side +object. Panics if the first "slot" is set to anything other than TIpcArgs::ENothing. +@return KErrNone if successful, otherwise one of the system-wide error codes. +@see CAnim::ConstructL() +@see CAnimDll::CreateInstanceL() */ + { + return iAnimDll->CreateInstance(iHandle, aDevice, aType, aParams, EWsAnimDllOpCreateInstance, &aIpcArgs); + } + +EXPORT_C TInt RAnim::Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams) +/** Completes construction of the Anim DLL based on a sprite. + +Construction information is passed to the server side via aType and aParams. +The server then passes the information to the function CreateInstanceL() inside +the Anim DLL. + +This function always causes a flush of the window server buffer. + +@param aDevice A sprite. +@param aType The type of this animation object, as understood by CAnimDll::CreateInstanceL(). +@param aParams Packaged arguments which will be passed to the server side object +to tell it how to construct itself or initialise itself. +@return KErrNone if successful, otherwise one of the system-wide error codes. +@see CAnim::ConstructL() +@see CAnimDll::CreateInstanceL() */ + { + return iAnimDll->CreateInstance(iHandle, aDevice, aType, aParams, EWsAnimDllOpCreateInstanceSprite, NULL); + } + +EXPORT_C TInt RAnim::Construct(const RWsSprite &aDevice, TInt aType, const TDesC8 &aParams, const TIpcArgs& aIpcArgs) +/** Completes construction of the Anim DLL based on a sprite. + +Construction information is passed to the server side via aType and aParams. +The server then passes the information to the function CreateInstanceL() inside +the Anim DLL. + +This function always causes a flush of the window server buffer. + +@param aDevice A sprite. +@param aType The type of this animation object, as understood by CAnimDll::CreateInstanceL(). +@param aParams Packaged arguments which will be passed to the server side object +to tell it how to construct itself or initialise itself. +@param aIpcArgs Inter-process communication arguments which will be passed to the server side +object. Panics if the first "slot" is set to anything other than TIpcArgs::ENothing. +@return KErrNone if successful, otherwise one of the system-wide error codes. +@see CAnim::ConstructL() +@see CAnimDll::CreateInstanceL() */ + { + return iAnimDll->CreateInstance(iHandle, aDevice, aType, aParams, EWsAnimDllOpCreateInstanceSprite, &aIpcArgs); + } + +EXPORT_C TInt RAnim::CommandReply(TInt aOpcode) +/** Sends a command to the server-side CAnim instance, and waits for a response. + +This function executes synchronously and returns the code returned by the +server-side method CAnim::CommandReplyL(). The request is not buffered. + +@param aOpcode An opcode meaningful to the server-side CAnim-derived class. +@return A value defined by the animation writer. The value may, in some cases, +be defined to be an error code. + +This function always causes a flush of the window server buffer. + +@see Command() +@see AsyncCommandReply() +@see CAnim::CommandReplyL() */ + { + return(iAnimDll->CommandReply(iHandle,aOpcode)); + } + +EXPORT_C TInt RAnim::CommandReply(TInt aOpcode, const TPtrC8 &aArgs) +/** Sends a command and its arguments to the server-side CAnim instance, and waits +for a response. + +The packaged command arguments are passed to the matching server side function, +where the behaviour should be implemented. The request is not buffered. The +function executes synchronously and returns the code returned by the server-side +method CAnim::CommandReplyL(). + +This function always causes a flush of the window server buffer. + +@param aOpcode An opcode meaningful to the server-side CAnim-derived class. +@param aArgs Packaged arguments which will be passed to the server side object. +@return A value defined by the animation writer. The value may, in some cases, +be defined to be an error code. +@see Command() +@see AsyncCommandReply() +@see CAnim::CommandReplyL() */ + { + return(iAnimDll->CommandReply(iHandle,aOpcode, aArgs)); + } + +EXPORT_C TInt RAnim::CommandReply(TInt aOpcode, const TDesC8& aArgs, const TIpcArgs& aIpcArgs) +/** Sends a command and its arguments to the server-side CAnim instance, and waits +for a response. + +The IPC (inter-process communication) arguments are passed to the matching server side function, +where the behaviour should be implemented. The request is not buffered. The +function executes synchronously and returns the code returned by the server-side +method CAnim::CommandReplyL(). The first slot of the TIpcArgs parameter is reserved for +internal use. + +This function always causes a flush of the window server buffer. + +@param aOpcode An opcode meaningful to the server-side CAnim-derived class. +@param aArgs Packaged arguments which will be passed to the server side object. +@param aIpcArgs Inter-process communication arguments which will be passed to the server side +object. Panics if the first "slot" is set to anything other than TIpcArgs::ENothing. +@return A value defined by the animation writer. The value may, in some cases, +be defined to be an error code. +@see Command() +@see AsyncCommandReply() +@see CAnim::CommandReplyL() */ + { + return(iAnimDll->CommandReply(iHandle,aOpcode,aArgs,&aIpcArgs)); + } + +EXPORT_C void RAnim::Command(TInt aOpcode) +/** Sends a command to the server-side CAnim instance, and returns immediately. + +Commands issued by this function may be buffered before being passed to the +server. + +Server-side errors cannot be detected, so Command() should not be used for +operations which could fail or which may leave. Use CommandReply() for those. +Although the window server will not fail due to errors not being returned +to the client side, client side behaviour will almost certainly not be correct +if errors have been generated but not received. + +Use of this function results in a server-side call to the equivalent CAnim::Command(). + +@param aOpcode An operation meaningful to the server-side CAnim object. +@see CommandReply() +@see AsyncCommandReply() +@see CAnim::Command() */ + { + iAnimDll->Command(iHandle,aOpcode); + } + +EXPORT_C void RAnim::Command(TInt aOpcode, const TPtrC8 &aArgs) +/** Sends a command and its arguments to the server-side CAnim instance, and returns +immediately. + +Commands issued by this function may be buffered before being passed to the +server. + +Server-side errors cannot be detected, so Command() should not be used for +operations which could fail or which may leave. Use CommandReply() for those. +Although the window server will not fail due to errors not being returned +to the client side, client side behaviour will almost certainly not be correct +if errors have been generated but not received. + +Use of this function results in a server-side call to the equivalent CAnim::Command(). + +@param aOpcode An operation meaningful to the server-side CAnim object. +@param aArgs Packaged arguments which will be passed to the server side object. + +@see CommandReply() +@see AsyncCommandReply() +@see CAnim::Command() */ + { + iAnimDll->Command(iHandle,aOpcode, aArgs); + } + +EXPORT_C void RAnim::AsyncCommandReply(TRequestStatus& aRequestStatus,TInt aOpcode, const TIpcArgs& aIpcArgs) +/** Sends a command and its arguments to the server-side CAnim instance asynchronously. + +The IPC (inter-process communication) arguments are passed to the CAnim-derived class' +CommandReplyL function, where the behaviour should be implemented. The request is not +buffered - rather the function executes asynchronously. The first and second slots of the +TIpcArgs parameter are reserved for internal use. + +If the code calling this function is itself an API that is asynchronous (i.e. if the +TRequestStatus passed into this function is simply a parameter to a higher-level API), then that +higher-level API should typically provide a corresponding "Cancel" function that its own clients +can use to cancel their asynchronous request - this would typically be implemented by the +higher-level API by using RAnim::CommandReply. + +@param aRequestStatus Set initially by the function to KRequestPending. Then when this +asynchronous function at some potentially later point in time "completes", aRequestStatus +is set to the completion code which is a value defined by the animation writer (i.e. the value +that the server-side CAnim-derived class' CommandReplyL returns or leaves with). The value may, +in some cases, be defined to be an error code. +@param aOpcode An opcode meaningful to the server-side CAnim-derived class. +@param aIpcArgs Inter-process communication arguments which will be passed to the server side +object. Panics if either the first or second "slot" is set to anything other than +TIpcArgs::ENothing. + +@see CommandReply() +@see Command() +@see CAnim::CommandReplyL() */ + { + TIpcArgs ipcArgs; + ipcArgs=aIpcArgs; // GCC doesn't seem to like doing a copy constructor on TIpcArgs, probably because it's confused by all the templated-ness of TIpcArgs' constructors + // check that the caller hasn't used the first or second slot (the first is set by the RAnimDll::AsyncCommandReply call below) + ipcArgs.Set(KAsyncMessageSlotAnimDllHandle,TIpcArgs::ENothing); + ipcArgs.Set(KAsyncMessageSlotAnimHandle,TIpcArgs::ENothing); + __ASSERT_ALWAYS(Mem::Compare(REINTERPRET_CAST(const TUint8*, &ipcArgs), sizeof(TIpcArgs), REINTERPRET_CAST(const TUint8*, &aIpcArgs), sizeof(TIpcArgs))==0,Panic(EW32PanicUsingReservedIpcSlot)); + ipcArgs.Set(KAsyncMessageSlotAnimHandle,iHandle); + iAnimDll->AsyncCommandReply(aRequestStatus, aOpcode, ipcArgs); + } + +EXPORT_C void RAnim::Close() +/** Sends the close command. + +This frees resources belonging to an animation object. It would be called +to release resources when the RAnim is owned in-line by another object (so +that destruction is automatic). + +This function always causes a flush of the window server buffer. */ + { + if (iHandle!=0) + { + iAnimDll->DestroyInstance(iHandle); + iHandle=0; + } + } + +EXPORT_C void RAnim::Destroy() +/** Closes and deletes the server-side animation object. + +This should be called on heap allocated objects. + +This function always causes a flush of the window server buffer. */ + { + Close(); + delete this; + }