public static void PlayTone(Tone[] tones) { WAVEFORMAT_MIDI wfm = new WAVEFORMAT_MIDI(); wfm.WAVEFORMATEX.FormatTag = FormatTag.MIDI; wfm.WAVEFORMATEX.Channels = 1; wfm.WAVEFORMATEX.BlockAlign = 8; // sizeof(WAVEFORMAT_MIDI_MESSAGE); wfm.WAVEFORMATEX.Size = WAVEFORMAT_MIDI_EXTRASIZE; // trial & error seems to be the way to get this - tested using an Axim x51 // maybe expose these if it varies from hardware to hardware wfm.USecPerQuarterNote = 100000; wfm.TicksPerQuarterNote = 15; IntPtr hWaveOut; EventWaitHandle hEvent = new EventWaitHandle(false, EventResetMode.ManualReset); byte[] d = wfm.GetBytes(); int result = WaveAudio.NativeMethods.waveOutOpen(out hWaveOut, 0, d, hEvent.Handle, 0, CALLBACK_EVENT); Audio.CheckWaveError(result); WAVEFORMAT_MIDI_MESSAGE[] messages = new WAVEFORMAT_MIDI_MESSAGE[2 * tones.Length]; int totalDuration = 0; for (int i = 0; i < tones.Length; i++) { messages[i * 2].DeltaTicks = 0; messages[i * 2].MidiMsg = (uint)(0x7F0090 | (tones[i].MIDINote << 8)); // Note on messages[i * 2 + 1].DeltaTicks = (uint)(tones[i].Duration); messages[i * 2 + 1].MidiMsg = (uint)(0x7F0080 | (tones[i].MIDINote << 8)); // Note off totalDuration += tones[i].Duration; } byte[] headerData = new byte[messages.Length * WAVEFORMAT_MIDI_MESSAGE.Length]; for (int i = 0; i < messages.Length; i++) { Buffer.BlockCopy(messages[i].GetBytes(), 0, headerData, i * WAVEFORMAT_MIDI_MESSAGE.Length, WAVEFORMAT_MIDI_MESSAGE.Length); } WaveHeader header = new WaveHeader(headerData); result = WaveAudio.NativeMethods.waveOutPrepareHeader(hWaveOut, header.Pointer, header.HeaderLength); Audio.CheckWaveError(result); result = WaveAudio.NativeMethods.waveOutWrite(hWaveOut, header.Pointer, header.HeaderLength); Audio.CheckWaveError(result); if (!hEvent.WaitOne(totalDuration * 20, false)) { Debugger.Break(); } result = WaveAudio.NativeMethods.waveOutUnprepareHeader(hWaveOut, header.Pointer, header.HeaderLength); Audio.CheckWaveError(result); result = WaveAudio.NativeMethods.waveOutClose(hWaveOut); Audio.CheckWaveError(result); }
/// <summary> /// Begins running a standard application message loop on the current thread, and makes the specified form visible. /// </summary> /// <param name="mainForm">Form on which main message loop runs</param> /// <param name="runAsSingletonApp">When <b>true</b>, if an existing instance of the app is already running, the current application instance will simply exit and the already running app will come to the fore</param> /// <param name="displayMainForm">When set to true, the main form will be automatically displayed, else the app will be responsible for showing the Form</param> public static void Run(Form mainForm, bool runAsSingletonApp, bool displayMainForm) { bool isNew = true; NamedMutex m = new NamedMutex(true, Application2.StartupPath, out isNew); if (runAsSingletonApp) { if (!isNew) { // activate the existing instance EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.AutoReset, Application2.StartupPath); wh.Set(); return; } else { //create a thread to wait for any subsequent instances to signal remoteActivateThread = new Thread(new System.Threading.ThreadStart(RemoteActivateThreadProc)); remoteActivateThread.IsBackground = true; remoteActivateThread.Name = "SDF Application2 UI thread"; remoteActivateThread.Start(); // create a filter to track the currently active form so if // we get reactivated from another instance attempting to run // we know what Form to put topmost currentFormFilter = new CurrentFormMessageFilter(); AddMessageFilter(currentFormFilter); } } // if (runAsSingletonApp) mainForm.Closed += new EventHandler(MainFormExit); Application2.mainForm = mainForm; RunMessageLoop(displayMainForm); }
/// <summary> /// Initializes a new instance of the Timer class /// </summary> /// <param name="interval">The Interval for the Timer</param> /// <param name="resolution">The resolution for the Timer</param> public Timer2(int interval, int resolution) { if (!NativeMethods.NativeEntryPointExists("mmtimer.dll", "timeSetEvent")) { throw new PlatformNotSupportedException("This platform does not have the required Multimedia timer support"); } if (interval <= 0) { throw new ArgumentOutOfRangeException("interval"); } if (resolution < 0) { throw new ArgumentOutOfRangeException("resolution"); } m_waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); m_elapsedThread = new Thread(new System.Threading.ThreadStart(ElapsedThreadProc)); m_elapsedThread.IsBackground = true; m_elapsedThread.Name = "SDF Timer2"; m_elapsedThread.Start(); this.Resolution = resolution; this.Interval = interval; }
private static void RemoteActivateThreadProc() { EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.AutoReset, Application2.StartupPath); while (true) { wh.WaitOne(); currentFormFilter.ActivateCurrentForm(); } }
/// <summary> /// Initializes a new instance of the FeedWorker. /// </summary> /// <param name="receiveCallback">A ReceiveHandler callback.</param> /// <param name="checkInterval">An interval (milliseconds) to start receiving RSS feeds.</param> public FeedWorker(ReceiveHandler receiveCallback, int checkInterval) { this.receiveCallback = receiveCallback; FeedWorker.checkInterval = checkInterval; this.stop = false; //#if !CF // resetEvent = new AutoResetEvent(false); //#else resetEvent = new EventWaitHandle(false, EventResetMode.ManualReset); //#endif feedList = new ArrayList(); timer = new Timer(new TimerCallback(TimerCall), resetEvent, Timeout.Infinite, Timeout.Infinite); }
public void StopListen() { bool createdNew = false; EventWaitHandle ewh = new EventWaitHandle(false, EventResetMode.ManualReset, WaitHandleName, out createdNew); if (ewh != null) { m_quit = true; ewh.Set(); EventWaitHandle quit = new EventWaitHandle(false, EventResetMode.ManualReset, WaitHandleNameQuit, out createdNew); quit.WaitOne(5000, true); } m_listening = false; }
protected void Dispose(bool finalizing) { // Check to see if Dispose has already been called. if (!this.disposed) { // kill the worker thread m_quit = true; EventWaitHandle ewh = new EventWaitHandle(false, EventResetMode.ManualReset, WaitHandleName); ewh.Set(); } if (!finalizing) { GC.SuppressFinalize(this); } disposed = true; }
/// <summary> /// When overridden in a derived class, releases the unmanaged resources used by the LargeIntervalTimer, and optionally releases the managed resources. /// </summary> public void Dispose() { lock (m_interlock) { m_disposing = true; if (Enabled) { Enabled = false; } if (m_quitHandle != null) { m_quitHandle.Set(); m_quitHandle.Close(); m_quitHandle = null; } } }
private void InternalThreadProc(object state) { ThreadCount++; int source; string eventName = Guid.NewGuid().ToString(); EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, eventName); if (TestCondition == 0) { Thread.Sleep(1000); } try { while (m_enabled) { if (TestCondition == 1) { Thread.Sleep(1000); } if (m_disposing) { return; } if (TestCondition == 2) { Thread.Sleep(1000); } if (m_useFirstTime) { Notify.RunAppAtTime(string.Format(@"\\.\Notifications\NamedEvents\{0}", eventName), m_firstTime); m_useFirstTime = false; } else { // set up the next event Notify.RunAppAtTime(string.Format(@"\\.\Notifications\NamedEvents\{0}", eventName), DateTime.Now.Add(m_interval)); m_firstTime = DateTime.MinValue; } if (TestCondition == 3) { Thread.Sleep(1000); } if (m_disposing) { return; } source = OpenNETCF.Threading.EventWaitHandle.WaitAny(new WaitHandle[] { waitHandle, m_quitHandle }); if (TestCondition == 4) { Thread.Sleep(1000); } // see if it's the event if (source == 0) { m_cachedEnabled = null; // fire the event if we have a listener if (Tick != null) { // we need to decouple this call from the current thread or the lock will do nothing ThreadPool.QueueUserWorkItem(new WaitCallback( delegate { Tick(this, null); })); } if (TestCondition == 5) { Thread.Sleep(1000); } if (OneShot) { if (TestCondition == 6) { Thread.Sleep(1000); } if (m_cachedEnabled != null) { if (TestCondition == 7) { Thread.Sleep(1000); } m_enabled = (m_cachedEnabled == true); if (TestCondition == 8) { Thread.Sleep(1000); } } else { m_enabled = false; } } } else { m_enabled = false; } } } finally { waitHandle.Close(); ThreadCount--; if (ThreadCount == 0) { m_quitHandle.Reset(); } } }
/// <summary> /// Creates an instance of a LargeIntervalTimer with a default interval of 60 seconds /// </summary> public LargeIntervalTimer() { m_quitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); }
private static void NotificationListenerProc() { int eventIndex = 0; while (!m_killThread) { // have to have a timeout or this thread never dies, even when the calling app is stopped eventIndex = EventWaitHandle.WaitAny(DeviceManagementInternals.m_events, 1000, true); switch (eventIndex) { case TIME_CHANGE_INDEX: m_currentEvent = TimeChanged; break; case TIMEZONE_CHANGE_INDEX: m_currentEvent = TimeZoneChanged; break; case PCCARD_CHANGE_INDEX: m_currentEvent = PCCardChanged; break; case IR_DISCOVERED_INDEX: m_currentEvent = IRDiscovered; break; case NET_CONNECT_INDEX: m_currentEvent = NetworkConnected; break; case NET_DISCONNECT_INDEX: m_currentEvent = NetworkDisconnected; break; case AC_APPLIED_INDEX: m_currentEvent = ACPowerApplied; break; case AC_REMOVED_INDEX: m_currentEvent = ACPowerRemoved; break; case RESTORE_INDEX: m_currentEvent = DeviceRestoreComplete; break; case SERIAL_DETECT_INDEX: m_currentEvent = SerialDeviceDetected; break; case SYNC_COMPLETE_INDEX: m_currentEvent = SynchronizationComplete; break; case WAKE_INDEX: m_currentEvent = DeviceWake; break; case NAME_CHANGE_INDEX: m_currentEvent = DeviceNameChange; break; case RNDIS_INDEX: m_currentEvent = RNDISDeviceDetected; break; case PROXY_CHANGE_INDEX: m_currentEvent = InternetProxyChange; break; default: // most likely a timeout m_currentEvent = null; break; } if (m_currentEvent != null) { try { m_invoker.Invoke(new EventHandler(NotificationMarshaler)); } catch (Exception) { // failure here is catastropic, so just exit the thread return; } } } }
internal DeviceManagementInternals() { // create all the notitification listener events m_events[TIME_CHANGE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, TIME_CHANGE_EVENT); m_events[TIMEZONE_CHANGE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, TIMEZONE_CHANGE_EVENT); m_events[PCCARD_CHANGE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, PCCARD_CHANGE_EVENT); m_events[IR_DISCOVERED_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, IR_DISCOVERED_EVENT); m_events[NET_CONNECT_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, NET_CONNECT_EVENT); m_events[NET_DISCONNECT_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, NET_DISCONNECT_EVENT); m_events[AC_APPLIED_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, AC_APPLIED_EVENT); m_events[AC_REMOVED_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, AC_REMOVED_EVENT); m_events[RESTORE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, RESTORE_EVENT); m_events[SERIAL_DETECT_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, SERIAL_DETECT_EVENT); m_events[SYNC_COMPLETE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, SYNC_COMPLETE_EVENT); m_events[WAKE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, WAKE_EVENT); m_events[NAME_CHANGE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, NAME_CHANGE_EVENT); m_events[RNDIS_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, RNDIS_EVENT); m_events[PROXY_CHANGE_INDEX] = new EventWaitHandle( false, EventResetMode.AutoReset, PROXY_CHANGE_EVENT); // set up all of the CeRunAppAtEvent notifications NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + TIME_CHANGE_EVENT, NotificationEvent.TimeChange); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + TIMEZONE_CHANGE_EVENT, NotificationEvent.TimeZoneChange); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + PCCARD_CHANGE_EVENT, NotificationEvent.DeviceChange); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + IR_DISCOVERED_EVENT, NotificationEvent.IRDiscovered); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + NET_CONNECT_EVENT, NotificationEvent.NetConnect); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + NET_DISCONNECT_EVENT, NotificationEvent.NetDisconnect); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + AC_APPLIED_EVENT, NotificationEvent.OnACPower); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + AC_REMOVED_EVENT, NotificationEvent.OffACPower); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + RESTORE_EVENT, NotificationEvent.RestoreEnd); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + SERIAL_DETECT_EVENT, NotificationEvent.RS232Detected); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + SYNC_COMPLETE_EVENT, NotificationEvent.SyncEnd); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + WAKE_EVENT, NotificationEvent.Wakeup); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + NAME_CHANGE_EVENT, NotificationEvent.MachineNameChange); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + RNDIS_EVENT, NotificationEvent.RndisFNDetected); NativeMethods.CeRunAppAtEvent(NOTIFICATION_EVENT_PREFIX + PROXY_CHANGE_EVENT, NotificationEvent.InternetProxyChange); m_invoker.Disposed += new EventHandler(m_invoker_Disposed); }
private unsafe void ThreadProc() { IntPtr notifyHandle = NativeMethods.FindFirstChangeNotification(m_path, true, filter); FileNotifyInformation notifyData = new FileNotifyInformation(); uint returned = 0; uint available = 0; EventWaitHandle ewh = new EventWaitHandle(false, EventResetMode.ManualReset, WaitHandleName); EventWaitHandle quitWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, WaitHandleNameQuit); while (!m_quit) { ewh.Reset(); if (EventWaitHandle.WaitAny(new IntPtr[] { notifyHandle, ewh.Handle }, TimeoutInfinite, false) != EventWaitHandle.WaitTimeout) { if (m_quit) { break; } IntPtr ptr = IntPtr.Zero; if (NativeMethods.CeGetFileNotificationInfo(notifyHandle, 0, ref ptr, 0, ref returned, ref available)) { if (available > 0) { int maxData = 2048; fixed(byte *pData = new byte[maxData]) { // get data if (NativeMethods.CeGetFileNotificationInfo(notifyHandle, 0, pData, maxData, ref returned, ref available)) { notifyData = new FileNotifyInformation(pData, 0); // handle data in notifyData if (ValidateByFilter(notifyData.Filename)) { RaiseEvents(notifyData.Action, notifyData.Filename); } int offset = 0; offset += notifyData.NextEntryOffset; while (notifyData.NextEntryOffset > 0) { notifyData = new FileNotifyInformation(pData, offset); if (ValidateByFilter(notifyData.Filename)) { RaiseEvents(notifyData.Action, notifyData.Filename); } offset += notifyData.NextEntryOffset; } } } } else { //Seems that subdirectories don't return anything but then the notifyHandle is never reset and if available data is 0 notifyHandle never resets NativeMethods.FindCloseChangeNotification(notifyHandle); notifyHandle = NativeMethods.FindFirstChangeNotification(m_path, true, filter); } } } // if( waithandle... } // while (!m_quit) NativeMethods.FindCloseChangeNotification(notifyHandle); quitWaitHandle.Set(); }