1 files changed, 104 insertions, 0 deletions
diff --git a/ThirdParty/SmartThreadPool/EventWaitHandle.cs b/ThirdParty/SmartThreadPool/EventWaitHandle.cs
new file mode 100644
index 0000000..70a1a29
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/EventWaitHandle.cs
@@ -0,0 +1,104 @@
+#if (_WINDOWS_CE)
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+namespace Amib.Threading.Internal
+{
+    /// <summary>
+    /// EventWaitHandle class
+    /// In WindowsCE this class doesn't exist and I needed the WaitAll and WaitAny implementation.
+    /// So I wrote this class to implement these two methods with some of their overloads.
+    /// It uses the WaitForMultipleObjects API to do the WaitAll and WaitAny.
+    /// Note that this class doesn't even inherit from WaitHandle!
+    /// </summary>
+    public class STPEventWaitHandle
+    {
+        #region Public Constants
+        public const int WaitTimeout = Timeout.Infinite;
+        #endregion
+        #region Private External Constants
+        private const Int32 WAIT_FAILED = -1;
+        private const Int32 WAIT_TIMEOUT = 0x102;
+        private const UInt32 INFINITE = 0xFFFFFFFF;
+        #endregion
+        #region WaitAll and WaitAny
+        internal static bool WaitOne(WaitHandle waitHandle, int millisecondsTimeout, bool exitContext)
+        {
+            return waitHandle.WaitOne(millisecondsTimeout, exitContext);
+        }
+            private static IntPtr[] PrepareNativeHandles(WaitHandle[] waitHandles)
+            {
+                IntPtr[] nativeHandles = new IntPtr[waitHandles.Length];
+                for (int i = 0; i < waitHandles.Length; i++)
+                {
+                nativeHandles[i] = waitHandles[i].Handle;
+                }
+                return nativeHandles;
+            }
+            public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
+            {
+            uint timeout = millisecondsTimeout < 0 ? INFINITE : (uint)millisecondsTimeout;
+            IntPtr[] nativeHandles = PrepareNativeHandles(waitHandles);
+                int result = WaitForMultipleObjects((uint)waitHandles.Length, nativeHandles, true, timeout);
+            if (result == WAIT_TIMEOUT || result == WAIT_FAILED)
+            {
+                return false;
+            }
+                return true;
+            }
+            public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
+        {
+            uint timeout = millisecondsTimeout < 0 ? INFINITE : (uint)millisecondsTimeout;
+            IntPtr[] nativeHandles = PrepareNativeHandles(waitHandles);
+            int result = WaitForMultipleObjects((uint)waitHandles.Length, nativeHandles, false, timeout);
+            if (result >= 0 && result < waitHandles.Length)
+            {
+                return result;
+            }
+            return -1;
+        }
+        public static int WaitAny(WaitHandle[] waitHandles)
+        {
+            return WaitAny(waitHandles, Timeout.Infinite, false);
+        }
+        public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext)
+        {
+            int millisecondsTimeout = (int)timeout.TotalMilliseconds;
+            return WaitAny(waitHandles, millisecondsTimeout, false);
+        }
+ 
+        #endregion
+        #region External methods
+        [DllImport("coredll.dll", SetLastError = true)]
+        public static extern int WaitForMultipleObjects(uint nCount, IntPtr[] lpHandles, bool fWaitAll, uint dwMilliseconds);
+        #endregion
+    }
+}
+#endif
+\ No newline at end of file

diff --git a/ThirdParty/SmartThreadPool/EventWaitHandle.cs b/ThirdParty/SmartThreadPool/EventWaitHandle.cs new file mode 100644 index 0000000..70a1a29 --- /dev/null +++ b/ThirdParty/SmartThreadPool/EventWaitHandle.cs
@@ -0,0 +1,104 @@
	1	#if (_WINDOWS_CE)
	2
	3	using System;
	4	using System.Runtime.InteropServices;
	5	using System.Threading;
	6
	7	namespace Amib.Threading.Internal
	8	{
	9	/// <summary>
	10	/// EventWaitHandle class
	11	/// In WindowsCE this class doesn't exist and I needed the WaitAll and WaitAny implementation.
	12	/// So I wrote this class to implement these two methods with some of their overloads.
	13	/// It uses the WaitForMultipleObjects API to do the WaitAll and WaitAny.
	14	/// Note that this class doesn't even inherit from WaitHandle!
	15	/// </summary>
	16	public class STPEventWaitHandle
	17	{
	18	#region Public Constants
	19
	20	public const int WaitTimeout = Timeout.Infinite;
	21
	22	#endregion
	23
	24	#region Private External Constants
	25
	26	private const Int32 WAIT_FAILED = -1;
	27	private const Int32 WAIT_TIMEOUT = 0x102;
	28	private const UInt32 INFINITE = 0xFFFFFFFF;
	29
	30	#endregion
	31
	32	#region WaitAll and WaitAny
	33
	34	internal static bool WaitOne(WaitHandle waitHandle, int millisecondsTimeout, bool exitContext)
	35	{
	36	return waitHandle.WaitOne(millisecondsTimeout, exitContext);
	37	}
	38
	39	private static IntPtr[] PrepareNativeHandles(WaitHandle[] waitHandles)
	40	{
	41	IntPtr[] nativeHandles = new IntPtr[waitHandles.Length];
	42	for (int i = 0; i < waitHandles.Length; i++)
	43	{
	44	nativeHandles[i] = waitHandles[i].Handle;
	45	}
	46	return nativeHandles;
	47	}
	48
	49	public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
	50	{
	51	uint timeout = millisecondsTimeout < 0 ? INFINITE : (uint)millisecondsTimeout;
	52
	53	IntPtr[] nativeHandles = PrepareNativeHandles(waitHandles);
	54
	55	int result = WaitForMultipleObjects((uint)waitHandles.Length, nativeHandles, true, timeout);
	56
	57	if (result == WAIT_TIMEOUT \|\| result == WAIT_FAILED)
	58	{
	59	return false;
	60	}
	61
	62	return true;
	63	}
	64
	65
	66	public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
	67	{
	68	uint timeout = millisecondsTimeout < 0 ? INFINITE : (uint)millisecondsTimeout;
	69
	70	IntPtr[] nativeHandles = PrepareNativeHandles(waitHandles);
	71
	72	int result = WaitForMultipleObjects((uint)waitHandles.Length, nativeHandles, false, timeout);
	73
	74	if (result >= 0 && result < waitHandles.Length)
	75	{
	76	return result;
	77	}
	78
	79	return -1;
	80	}
	81
	82	public static int WaitAny(WaitHandle[] waitHandles)
	83	{
	84	return WaitAny(waitHandles, Timeout.Infinite, false);
	85	}
	86
	87	public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext)
	88	{
	89	int millisecondsTimeout = (int)timeout.TotalMilliseconds;
	90
	91	return WaitAny(waitHandles, millisecondsTimeout, false);
	92	}
	93
	94	#endregion
	95
	96	#region External methods
	97
	98	[DllImport("coredll.dll", SetLastError = true)]
	99	public static extern int WaitForMultipleObjects(uint nCount, IntPtr[] lpHandles, bool fWaitAll, uint dwMilliseconds);
	100
	101	#endregion
	102	}
	103	}
	104	#endif \ No newline at end of file