--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/javalegacyutils/inc/mevents.h Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,397 @@
+/*
+* Copyright (c) 1999-2001 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:
+*
+*/
+
+
+#ifndef MEVENTS_H
+#define MEVENTS_H
+
+#include <jutils.h>
+
+#include "logger.h"
+
+/**
+ * Callback interface for event server thread.
+ */
+class MEventServer
+{
+public:
+
+ /**
+ * Event server started.
+ */
+ virtual void Started(TInt aError, RServer2 server) = 0;
+
+ /**
+ * Argument for event server thread.
+ */
+ virtual TAny* Arg() const = 0;
+};
+
+class CJavaEventServer;
+class TJavaEventServer
+{
+ friend class CJavaEventServer;
+public:
+ IMPORT_C static TJavaEventServer NewL(const TDesC& aName, TThreadFunction aServerThread=NULL, TAny* aServerArg=NULL);
+ IMPORT_C static TJavaEventServer NewL(const TDesC& aName, TThreadFunction aServerThread, TAny* aServerArg, TUint aStackSize, RAllocator* aHeap = 0);
+
+ inline TJavaEventServer()
+ {}
+ inline TJavaEventServer(TInt aServer)
+ :iServer(JavaUnhand<CJavaEventServer>(aServer))
+ {}
+ inline CJavaEventServer* operator->() const
+ {
+ return iServer;
+ }
+ static inline TInt Handle(CJavaEventServer* aServer)
+ {
+ return JavaMakeHandle(aServer);
+ }
+ inline TInt Handle() const
+ {
+ return Handle(iServer);
+ }
+ IMPORT_C void Shutdown();
+private:
+ inline TJavaEventServer(CJavaEventServer* aServer);
+private:
+ CJavaEventServer* iServer;
+};
+
+#pragma warning(disable: 4786) // Truncated browser info for long mangled names
+
+class CJavaEventBase;
+class CJavaEventSourceBase : public CBase
+{
+ enum {KMaxExecuteArgumentSize=32};
+ static inline void CallCheck(TInt aSize)
+ { // fault at run time for invalid JpServer calls
+#pragma warning(disable: 4127)
+ if (aSize>KMaxExecuteArgumentSize) Panic(aSize);
+#pragma warning(default: 4127)
+ }
+public:
+ inline TInt Handle() const
+ {
+ return JavaMakeHandle(this);
+ }
+ inline jweak Peer() const
+ {
+ return iPeer;
+ }
+ inline TJavaEventServer Server() const
+ {
+ return iServer;
+ }
+ inline void Dispose(JNIEnv& aJni)
+ {
+ iDead=ETrue;
+ Close(aJni);
+ }
+ inline TBool IsDisposed() const
+ {
+ return iDead;
+ }
+ TBool Open();
+ IMPORT_C void Close(JNIEnv& aJni);
+
+
+ void OnVmClose();
+
+ template <class R,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
+ inline R Execute(R(*aFuncL)(T1,T2,T3,T4,T5,T6,T7,T8),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7,T8 aT8)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7)+sizeof(T8));
+ return (R)DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7,aT8);
+ }
+ template <class R,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+ inline R Execute(R(*aFuncL)(T1,T2,T3,T4,T5,T6,T7),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7));
+ return (R)DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7);
+ }
+ template <class R,class T1,class T2,class T3,class T4,class T5,class T6>
+ inline R Execute(R(*aFuncL)(T1,T2,T3,T4,T5,T6),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6));
+ return (R)DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6);
+ }
+ template <class R,class T1,class T2,class T3,class T4,class T5>
+ inline R Execute(R(*aFuncL)(T1,T2,T3,T4,T5),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5));
+ return (R)DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5);
+ }
+ template <class R,class T1,class T2,class T3,class T4>
+ inline R Execute(R(*aFunc)(T1,T2,T3,T4),T1 aT1,T2 aT2,T3 aT3,T4 aT4)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4));
+ return (R)DoExecute((TAny*)aFunc,aT1,aT2,aT3,aT4);
+ }
+ template <class R,class T1,class T2,class T3>
+ inline R Execute(R(*aFunc)(T1,T2,T3),T1 aT1,T2 aT2,T3 aT3)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3));
+ return (R)DoExecute((TAny*)aFunc,aT1,aT2,aT3);
+ }
+ template <class R,class T1,class T2>
+ inline R Execute(R(*aFunc)(T1,T2),T1 aT1,T2 aT2)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2));
+ return (R)DoExecute((TAny*)aFunc,aT1,aT2);
+ }
+ template <class R,class T1>
+ inline R Execute(R(*aFunc)(T1),T1 aT1)
+ {
+ CallCheck(sizeof(T1));
+ return (R)DoExecute((TAny*)aFunc,aT1);
+ }
+ template <class R>
+ inline R Execute(R(*aFunc)())
+ {
+ return (R)DoExecute((TAny*)aFunc);
+ }
+
+ template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+ inline void ExecuteV(void (*aFuncL)(T1,T2,T3,T4,T5,T6,T7),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7));
+ DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7);
+ }
+ template <class T1,class T2,class T3,class T4,class T5,class T6>
+ inline void ExecuteV(void (*aFuncL)(T1,T2,T3,T4,T5,T6),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6));
+ DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6);
+ }
+ template <class T1,class T2,class T3,class T4,class T5>
+ inline void ExecuteV(void (*aFuncL)(T1,T2,T3,T4,T5),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5));
+ DoExecute((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5);
+ }
+ template <class T1,class T2,class T3,class T4>
+ inline void ExecuteV(void (*aFunc)(T1,T2,T3,T4),T1 aT1,T2 aT2,T3 aT3,T4 aT4)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4));
+ DoExecute((TAny*)aFunc,aT1,aT2,aT3,aT4);
+ }
+ template <class T1,class T2,class T3>
+ inline void ExecuteV(void (*aFunc)(T1,T2,T3),T1 aT1,T2 aT2,T3 aT3)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3));
+ DoExecute((TAny*)aFunc,aT1,aT2,aT3);
+ }
+ template <class T1,class T2>
+ inline void ExecuteV(void (*aFunc)(T1,T2),T1 aT1,T2 aT2)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2));
+ DoExecute((TAny*)aFunc,aT1,aT2);
+ }
+ template <class T1>
+ inline void ExecuteV(void (*aFunc)(T1),T1 aT1)
+ {
+ CallCheck(sizeof(T1));
+ DoExecute((TAny*)aFunc,aT1);
+ }
+ inline void ExecuteV(void (*aFunc)())
+ {
+ DoExecute((TAny*)aFunc);
+ }
+
+ template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4,T5,T6,T7,T8,T9),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7,T8 aT8,T9 aT9)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7)+sizeof(T8)+sizeof(T9));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7,aT8,aT9);
+ }
+ template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4,T5,T6,T7,T8),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7,T8 aT8)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7)+sizeof(T8));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7,aT8);
+ }
+ template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4,T5,T6,T7),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6,T7 aT7)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6)+sizeof(T7));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6,aT7);
+ }
+ template <class T1,class T2,class T3,class T4,class T5,class T6>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4,T5,T6),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5,T6 aT6)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5)+sizeof(T6));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5,aT6);
+ }
+ template <class T1,class T2,class T3,class T4,class T5>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4,T5),T1 aT1,T2 aT2,T3 aT3,T4 aT4,T5 aT5)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4)+sizeof(T5));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4,aT5);
+ }
+ template <class T1,class T2,class T3,class T4>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3,T4),T1 aT1,T2 aT2,T3 aT3,T4 aT4)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3)+sizeof(T4));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3,aT4);
+ }
+ template <class T1,class T2,class T3>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2,T3),T1 aT1,T2 aT2,T3 aT3)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2)+sizeof(T3));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2,aT3);
+ }
+ template <class T1,class T2>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1,T2),T1 aT1,T2 aT2)
+ {
+ CallCheck(sizeof(T1)+sizeof(T2));
+ return DoExecuteTrap((TAny*)aFuncL,aT1,aT2);
+ }
+ template <class T1>
+ inline TInt ExecuteTrap(void (*aFuncL)(T1),T1 aT1)
+ {
+ CallCheck(sizeof(T1));
+ return DoExecuteTrap((TAny*)aFuncL,aT1);
+ }
+ inline int ExecuteTrap(void (*aFuncL)())
+ {
+ return DoExecuteTrap((TAny*)aFuncL);
+ }
+protected:
+ IMPORT_C CJavaEventSourceBase();
+ IMPORT_C ~CJavaEventSourceBase();
+ IMPORT_C void ConstructL(JNIEnv& aJni, jobject aPeer,TJavaEventServer aServer);
+
+ IMPORT_C TBool DoPostEvent(CJavaEventBase* aEvent, TInt aPriority);
+
+ IMPORT_C virtual TBool CheckEvent(CJavaEventBase* aEvent);
+private:
+ IMPORT_C virtual void FinalizeSvr();
+
+ IMPORT_C virtual void FinalizeJni(JNIEnv& aJni);
+
+ IMPORT_C TInt DoExecute(TAny* aFunc,...);
+ IMPORT_C TInt DoExecuteTrap(TAny* aFuncL,...);
+ static void DoFinalize(CJavaEventSourceBase* aThis);
+
+ IMPORT_C static void Panic(TInt aPanic);
+public:
+ class TConstructorBase
+ {
+ public:
+ inline TInt GetHandle()
+ {
+ CleanupStack::Pop();
+ return iObject->Handle();
+ }
+ protected:
+ IMPORT_C TConstructorBase(CJavaEventSourceBase* aObject, JNIEnv& aJni);
+ private:
+ static void Disposer(TAny* aThis);
+ protected:
+ CJavaEventSourceBase* iObject;
+ JNIEnv& iJni;
+ };
+private:
+ jweak iPeer;
+ TJavaEventServer iServer;
+ TInt iRef;
+ TBool iDead;
+};
+
+#pragma warning(default: 4786)
+
+class CJavaEventBase : public CBase
+{
+ friend class CJavaEventSourceBase;
+ friend class CJavaEventServer;
+
+public:
+ enum {EEventPriority = 0, ENotifyPriority = 1, ELastPriority = 1};
+ enum TDisposability { EDisposableEvent, EReusableEvent };
+public:
+ inline TBool IsDisposable() const
+ {
+ return iDisposableState == EDisposableEvent;
+ }
+protected:
+ CJavaEventBase(TDisposability aDisposable)
+ : iDisposableState(aDisposable) {}
+
+public:
+ inline CJavaEventSourceBase& Object() const
+ {
+ return *iObject;
+ }
+
+ void Run(JNIEnv& aJni);
+
+private:
+ virtual void Dispatch(JNIEnv& aJni) =0;
+ TSglQueLink iLink;
+ CJavaEventSourceBase* iObject;
+ TDisposability iDisposableState;
+};
+
+template <class T>
+class CJavaEvent : public CJavaEventBase
+{
+protected:
+ CJavaEvent(TDisposability aDisposable = EDisposableEvent)
+ : CJavaEventBase(aDisposable) {}
+ inline T& Object() const
+ {
+ return static_cast<T&>(CJavaEventBase::Object());
+ }
+};
+
+template <class T>
+class CJavaEventSource : public CJavaEventSourceBase
+{
+protected:
+ class TConstructor : public CJavaEventSourceBase::TConstructorBase
+ {
+ public:
+ inline TConstructor(T* aObject,JNIEnv& aJni)
+ :TConstructorBase(aObject,aJni)
+ {}
+ inline TConstructor(JNIEnv& aJni)
+ :TConstructorBase(new(ELeave) T,aJni)
+ {}
+ inline T* operator->() const
+ {
+ return static_cast<T*>(iObject);
+ }
+ };
+public:
+ inline static T& Unhand(TInt aHandle)
+ {
+ return *JavaUnhand<T>(aHandle);
+ }
+ inline TBool PostEvent(CJavaEvent<T>* aEvent, TInt aPriority = CJavaEventBase::EEventPriority)
+ {
+ return DoPostEvent(aEvent, aPriority);
+ }
+ static TInt New(JNIEnv& aJni,jobject aPeer,TJavaEventServer aServer)
+ {
+ TRAPD(h,TConstructor self(aJni); self->ConstructL(aJni,aPeer,aServer); h=self.GetHandle());
+ return h;
+ }
+};
+
+#endif // MEVENTS_H