void EngineHook(object sender, EngineEventArgs e)
{
switch(e.Event) {
case EngineEvent.NapStart:
cmdClose.Text = Strings.NapStopPreGrace;
_secondsTimer.Enabled = true;
SecondsTick(_secondsTimer, EventArgs.Empty); // Display initial time
break;
case EngineEvent.GracePeriodOver:
cmdClose.Text = Strings.NapStopPostGrace;
break;
case EngineEvent.NapElapsed: {
if(_testMethod == TestMethod.None)
break; // Just wait for the user to press the close button
// Otherwise, hand control to the test form which will test the user
_okToClose = true;
Close();
var test = new TestForm(_engine);
test.DoTest(this.Owner, _testMethod, _testData);
break;
}}
}
void EngineHook(object sender, EngineEventArgs e)
{
switch(e.Event) {
case EngineEvent.LoadSettings:
RefreshSettings();
break;
case EngineEvent.LoadSettingsFailed:
Tabs.SelectedTab = tabSetup;
switch((string)e.Data) {
case "NapLen":
App.FlashTextBox(txtSetupNapLen, Strings.InvalidTimeFlash);
break;
case "NapCooldown":
App.FlashTextBox(txtSetupNapCooldown, Strings.InvalidTimeFlash);
break;
case "CoreLen":
App.FlashTextBox(txtSetupCoreLen, Strings.InvalidTimeFlash);
break;
case "CoreCooldown":
App.FlashTextBox(txtSetupCoreCooldown, Strings.InvalidTimeFlash);
break;
case "SoundWarningFile":
App.FlashTextBox(txtSoundWarningFile, Strings.CantOpenAudioFile);
break;
case "SoundAlarmFile":
App.FlashTextBox(txtSoundAlarmFile, Strings.CantOpenAudioFile);
break;
case "SoundWarningLen":
App.FlashTextBox(txtSoundWarningLen, "!!!");
break;
case "SoundFadeInLen":
App.FlashTextBox(txtSoundFadeInLen, "!!!");
break;
}
break;
case EngineEvent.VitalTest:
new TestForm(_engine).DoTest(this, TestMethod.VitalTest, "You still there?");
break;
case EngineEvent.CooldownBegin:
cmdExit.Text = Strings.ExitCoolingDown;
break;
case EngineEvent.CooldownDone:
cmdExit.Text = Strings.ExitIdle;
break;
case EngineEvent.LogMessage: {
var data = (LogData)e.Data;
txtHistory.AppendText(data.Time.ToString("HH:mm:ss "));
txtHistory.AppendText(data.Message);
txtHistory.AppendText(Environment.NewLine);
txtHistory.Select(txtHistory.TextLength, 0);
break;
}}
}
void EngineHook(object sender, EngineEventArgs e)
{
switch(e.Event) {
case EngineEvent.Init: {
uint origVol;
if(waveOutGetVolume(IntPtr.Zero, out origVol) == MMSYSERR_NOERROR)
_originalVolume = origVol;
else
_engine.Log(DateTime.Now, "Warning: couldn't determine current volume");
break;
}
case EngineEvent.Shutdown:
if(_originalVolume != null)
waveOutSetVolume(IntPtr.Zero, (uint)_originalVolume);
break;
case EngineEvent.LoadSettings:
CloseAll();
if(!_warning.TryOpen(App.Settings.WarningSoundFile))
_engine.LoadSettingsFailed("SoundWarningFile");
if(!_alarm.TryOpen(App.Settings.AlarmSoundFile))
_engine.LoadSettingsFailed("SoundAlarmFile");
break;
case EngineEvent.NapDone:
App.Assert(!_warning.Playing);
App.Assert(!_alarm.Playing);
break;
case EngineEvent.SoundWarning:
if(_engine.State == EngineState.Warning &&
App.Settings.WarningSoundFadeIn.Ticks != 0) {
SetVolume(0);
_fadeInTimer.Start();
FadeInTimer_Elapsed(_fadeInTimer, EventArgs.Empty);
}
_warning.SeekToStart();
_warning.Play();
break;
case EngineEvent.SoundAlarm:
_warning.Stop();
_alarm.SeekToStart();
_alarm.Play();
break;
case EngineEvent.SoundVital:
_warning.SeekToStart();
_warning.Play();
Countdown.Queue(new TimeSpan(0, 0, 1), () => {
_engine.Invoker.Invoke((DelayedAction)(() => _warning.Stop()));
});
break;
case EngineEvent.SoundVitalOuch:
_alarm.SeekToStart();
_alarm.Play();
Countdown.Queue(new TimeSpan(0, 0, 1), () => {
_engine.Invoker.Invoke((DelayedAction)(() => _alarm.Stop()));
});
break;
case EngineEvent.SoundStopAll:
_warning.Stop();
_alarm.Stop();
break;
case EngineEvent.SoundMute:
SetMuted(true);
break;
case EngineEvent.SoundUnmute:
SetMuted(false);
break;
}
}
void SelfHook(object sender, EngineEventArgs e)
{
switch(e.Event) {
case EngineEvent.Init:
State = EngineState.Idle;
RaiseEvent(EngineEvent.SoundUnmute);
if(App.Settings.VitalEnabled)
_vitalTimer.Start(App.Settings.VitalPeriod);
break;
case EngineEvent.Shutdown:
_napTimer.Stop();
_graceTimer.Stop();
RaiseEvent(EngineEvent.SoundStopAll);
RaiseEvent(EngineEvent.SoundUnmute);
break;
case EngineEvent.LoadSettings:
if(State == EngineState.Idle && App.Settings.NextNapAllowed > DateTime.Now) {
// User tried to nap sooner by killing the process and restarting...
Log(DateTime.Now, "So you think you're slick, huh?");
CooldownLength = App.Settings.NextNapAllowed - DateTime.Now;
RaiseEvent(EngineEvent.CooldownBegin);
}
break;
case EngineEvent.NapStart:
App.Assert(State == EngineState.Idle);
State = EngineState.NapStarting;
_vitalTimer.Stop();
_napTimer.Start(NapLength);
_graceTimer.Start(new TimeSpan(0, 0, CancelGraceSeconds));
break;
case EngineEvent.NapCancelled:
App.Assert(State == EngineState.NapStarting);
State = EngineState.Idle;
_napTimer.Stop();
_graceTimer.Stop();
if(App.Settings.VitalEnabled)
_vitalTimer.Start(App.Settings.VitalPeriod);
break;
case EngineEvent.GracePeriodOver:
_graceTimer.Stop();
_anySignsOfLife = false;
App.Assert(State == EngineState.NapStarting);
State = EngineState.Napping;
break;
case EngineEvent.NapElapsed:
if(WithinGracePeriod)
RaiseEvent(EngineEvent.GracePeriodOver);
RaiseEvent(EngineEvent.NapWarning);
break;
case EngineEvent.NapWarning:
App.Assert(State == EngineState.Napping);
State = EngineState.Warning;
RaiseEvent(EngineEvent.SoundUnmute);
RaiseEvent(EngineEvent.SoundWarning);
_warningTimer.Start(App.Settings.WarningSoundLength);
break;
case EngineEvent.NapAlarm:
App.Assert(State == EngineState.Warning);
State = EngineState.Alarming;
RaiseEvent(EngineEvent.SoundAlarm);
break;
case EngineEvent.NapDone:
_napTimer.Stop();
_graceTimer.Stop();
_warningTimer.Stop();
RaiseEvent(EngineEvent.SoundStopAll);
RaiseEvent(EngineEvent.CooldownBegin);
if(App.Settings.VitalEnabled)
_vitalTimer.Start(App.Settings.VitalInitial);
break;
case EngineEvent.VitalTest:
// This is handled in MainForm, so that the resulting dialog
// can be modal and owned by MainForm
break;
case EngineEvent.VitalConfirmed:
case EngineEvent.VitalGaveUp:
App.Assert(App.Settings.VitalEnabled);
_vitalTimer.Start(App.Settings.VitalPeriod);
break;
case EngineEvent.CooldownBegin:
State = EngineState.CoolingDown;
_cooldownTimer.Start(CooldownLength);
App.Settings.NextNapAllowed = DateTime.Now + CooldownLength;
App.Settings.SaveToFile();
break;
case EngineEvent.CooldownDone:
App.Assert(State == EngineState.CoolingDown);
State = EngineState.Idle;
App.Settings.NextNapAllowed = DateTime.MinValue;
App.Settings.SaveToFile();
break;
case EngineEvent.TriedToNapTooSoon:
case EngineEvent.TriedToExitTooSoon: {
RaiseEvent(EngineEvent.SoundUnmute);
RaiseEvent(EngineEvent.SoundAlarm);
Countdown.Queue(new TimeSpan(0, 0, 2), () => {
RaiseEvent(EngineEvent.SoundStopAll);
});
break;
}}
}
void RaiseEvent(EngineEvent ƐƲƺŋƫ, object data)
{
var args = new EngineEventArgs(ƐƲƺŋƫ, data);
// Invoke used liberally for thread safety
if(Invoker != null && Invoker.IsHandleCreated && Invoker.InvokeRequired)
Invoker.Invoke(Hook, this, args);
else
Hook(this, args);
}
void EngineHook(object sender, EngineEventArgs e)
{
switch(e.Event) {
case EngineEvent.Init:
try {
Directory.CreateDirectory(App.StoragePath);
_file = new FileStream(App.LogFilename, FileMode.Append, FileAccess.Write);
_output = new StreamWriter(_file);
} catch {
// Logging isn't critical, so just display an error and continue
_engine.Log(DateTime.Now, "Failed to open log file on disk.");
}
break;
case EngineEvent.Shutdown:
if(_output != null)
_output.Close();
break;
case EngineEvent.NapStart:
_napStartTime = DateTime.Now;
break;
case EngineEvent.FirstSignOfLife:
_wakeState = _engine.State;
_sleepTime = _engine.NapTimeElapsed;
_verifyFails = 0;
break;
case EngineEvent.VerifiedWrong:
_verifyFails += 1;
break;
case EngineEvent.TriedToNapTooSoon:
_engine.Log(DateTime.Now, "Tried to nap again too soon");
break;
case EngineEvent.TriedToExitTooSoon:
_engine.Log(DateTime.Now, "Tried to exit the program :(");
break;
case EngineEvent.NapDone: {
var msg = "Slept for ";
msg += App.TimeToStringHHMMSS(_sleepTime);
msg += ", woke to ";
switch(_wakeState) {
case EngineState.Napping: msg += "silence"; break;
case EngineState.Warning: msg += "warning"; break;
case EngineState.Alarming: msg += "alarm"; break;
default: App.Assert(false); break;
}
if(_verifyFails > 0)
msg += string.Format(", failed {0} test{1}",
_verifyFails, _verifyFails == 1 ? null : "s");
_engine.Log(_napStartTime, msg);
break;
}
case EngineEvent.LogMessage: {
if(_output != null) {
var data = (LogData)e.Data;
_output.Write(data.Time.ToString("yyyy-MM-dd HH:mm:ss "));
_output.WriteLine(data.Message);
_output.Flush();
}
break;
}}
}
