[Timer] Use static CB for invoking timer callbacks.

[mono.git] / mcs / class / corlib / System.Threading / Overlapped.cs

diff --git a/mcs/class/corlib/System.Threading/Overlapped.cs b/mcs/class/corlib/System.Threading/Overlapped.cs
index b5bb12d93183d12d8563b9669989ff267bbffe95..85e3a0de003ece534571641cfaf7dbadf1eaca27 100644 (file)
--- a/mcs/class/corlib/System.Threading/Overlapped.cs
+++ b/mcs/class/corlib/System.Threading/Overlapped.cs
@@ -37,17 +37,20 @@ using System.Security.Permissions;
 
 namespace System.Threading
 {
+       [ComVisible (true)]
        public class Overlapped
        {
                IAsyncResult ares;
                int offsetL;
                int offsetH;
                int evt;
+               IntPtr evt_ptr;
 
                public Overlapped ()
                {
                }
 
+               [Obsolete ("Not 64bit compatible.  Please use the constructor that takes IntPtr for the event handle", false)]
                public Overlapped(int offsetLo, int offsetHi, int hEvent, IAsyncResult ar)
                {
                        offsetL = offsetLo;
@@ -56,6 +59,15 @@ namespace System.Threading
                        ares = ar;
                }
 
+               public Overlapped (int offsetLo, int offsetHi, IntPtr hEvent,
+                                  IAsyncResult ar)
+               {
+                       offsetL = offsetLo;
+                       offsetH = offsetHi;
+                       evt_ptr = hEvent;
+                       ares = ar;
+               }
+
                [CLSCompliant(false)]
                unsafe public static void Free (NativeOverlapped *nativeOverlappedPtr)
                {
@@ -74,22 +86,36 @@ namespace System.Threading
                        Overlapped result = new Overlapped ();
                        result.offsetL = nativeOverlappedPtr->OffsetLow;
                        result.offsetH = nativeOverlappedPtr->OffsetHigh;
-                       result.evt = nativeOverlappedPtr->EventHandle;
+                       result.evt = (int)nativeOverlappedPtr->EventHandle;
                        return result;
                }
 
                [CLSCompliant(false)]
+               [Obsolete ("Use Pack(iocb, userData) instead", false)]
                [MonoTODO ("Security - we need to propagate the call stack")]
                unsafe public NativeOverlapped *Pack (IOCompletionCallback iocb)
                {
                        NativeOverlapped *result = (NativeOverlapped *) Marshal.AllocHGlobal (Marshal.SizeOf (typeof (NativeOverlapped)));
                        result->OffsetLow = offsetL;
                        result->OffsetHigh = offsetH;
-                       result->EventHandle = evt;
+                       result->EventHandle = (IntPtr)evt;
                        return result;
                }
+
+               [CLSCompliant (false)]
+               [ComVisible (false)]
+               [MonoTODO ("handle userData")]
+               unsafe public NativeOverlapped *Pack (IOCompletionCallback iocb, object userData)
+               {
+                       NativeOverlapped *result = (NativeOverlapped *) Marshal.AllocHGlobal (Marshal.SizeOf(typeof(NativeOverlapped)));
+                       result->OffsetLow = offsetL;
+                       result->OffsetHigh = offsetH;
+                       result->EventHandle = evt_ptr;
+                       return(result);
+               }
                
                [CLSCompliant(false)]
+               [Obsolete ("Use UnsafePack(iocb, userData) instead", false)]
                [SecurityPermission (SecurityAction.Demand, ControlEvidence=true, ControlPolicy=true)]
                unsafe public NativeOverlapped *UnsafePack (IOCompletionCallback iocb)
                {
@@ -97,16 +123,35 @@ namespace System.Threading
                        return Pack (iocb);
                }
 
+               [ComVisible (false)]
+               [CLSCompliant (false)]
+               unsafe public NativeOverlapped *UnsafePack (IOCompletionCallback iocb, object userData)
+               {
+                       return Pack (iocb, userData);
+               }
+
                public IAsyncResult AsyncResult {
                        get { return ares; }
                        set { ares = value; }
                }
 
+               [Obsolete ("Not 64bit compatible.  Use EventHandleIntPtr instead.", false)]
                public int EventHandle {
                        get { return evt; }
                        set { evt = value; }
                }
 
+               [ComVisible (false)]
+               public IntPtr EventHandleIntPtr 
+               {
+                       get{
+                               return(evt_ptr);
+                       }
+                       set{
+                               evt_ptr = value;
+                       }
+               }
+
                public int OffsetHigh {
                        get { return offsetH; }
                        set { offsetH = value; }