private void b_set_Click(object sender, EventArgs e)
{
int _seq;
for (_seq = 1; _seq <= sequence.Length; ++_seq)
{
if (sequence[_seq - 1].Checked)
{
break;
}
}
int _type;
for (_type = 1; _type <= type.Length; ++_type)
{
if (type[_type - 1].Checked)
{
break;
}
}
switch ((Utils.SequenceType)_type)
{
case Utils.SequenceType.Fast:
Utils.Sequence.Set(_seq);
break;
case Utils.SequenceType.Timed:
Utils.Sequence.Set(_seq,
(int)n_hour.Value,
(int)n_minute.Value,
(int)n_second.Value);
break;
case Utils.SequenceType.Scheduled:
Utils.MyDate md = new Utils.MyDate(
(int)n_hour.Value,
(int)n_minute.Value,
(int)n_second.Value
);
if (md.Ticks <= DateTime.Now.Ticks)
{
md = new Utils.MyDate(
md.Year,
md.Month,
md.Day + 1,
md.Hour,
md.Minute,
md.Second
);
}
Utils.Sequence.Set(_seq, md);
break;
}
}
private void MainFrame_Load(object sender, EventArgs e)
{
Utils.Log.SetLogBox(tb_log);
mi_startup.Checked = Utils.Config.IsSet("startup");
mi_broadcast.Checked = Utils.Config.IsSet("broadcast");
mi_restart.Checked = Utils.Config.IsSet("restart");
mi_server.Checked = Utils.Config.IsSet("server");
mi_alert.Checked = Utils.Config.IsSet("alert");
mi_broadcast.Enabled = mi_server.Checked;
mi_rebroadcast.Enabled = mi_restart.Checked;
mi_always.Checked = Utils.Config.Equals("rebroadcast", "0");
mi_sometimes.Checked = Utils.Config.Equals("rebroadcast", "1");
mi_never.Checked = !mi_always.Checked && !mi_sometimes.Checked;
mi_broadcast_start.Enabled = !Utils.Broadcast.Running;
mi_broadcast_stop.Enabled = !mi_broadcast_start.Enabled;
mi_server_start.Enabled = !Utils.Server.IsRunning;
mi_server_stop.Enabled = !mi_server_start.Enabled;
mi_server_disconnect.Enabled = mi_server_stop.Enabled && Utils.Server.IsConnected;
//for sequence change events
Utils.Sequence.SequenceChange += (Utils.SequenceChangeEventArgs args) =>
{
RunOnUIThread(() =>
{
t_sequence.Text = args.Sequence.ToString();
t_type.Text = args.Type.ToString();
switch (args.Type)
{
case Utils.SequenceType.Fast:
t_time.Text = "Immediately";
break;
case Utils.SequenceType.Timed:
t_time.Text =
new Utils.MyDate(DateTime.Now.Ticks + args.Millis * 10000).GetString();
break;
case Utils.SequenceType.Scheduled:
t_time.Text = args.Date.GetString();
break;
default:
t_time.Text = "N/A";
break;
}
t_sequence.ForeColor = Utils.Sequence.GetColor(args.Sequence);
});
};
Utils.Broadcast.OnStart += (Utils.ConnectionEventArgs args) =>
{
RunOnUIThread(() =>
{
t_broadcast.Text = "Up";
t_broadcast.ForeColor = Color.Green;
mi_broadcast_start.Enabled = false;
mi_broadcast_stop.Enabled = true;
});
};
Utils.Broadcast.OnError += (string message) =>
{
RunOnUIThread(() =>
{
t_broadcast.Text = "Down";
t_broadcast.ForeColor = Color.Red;
mi_broadcast_start.Enabled = true;
mi_broadcast_stop.Enabled = false;
});
};
Utils.Broadcast.OnStop += (Utils.ConnectionEventArgs args) =>
{
RunOnUIThread(() =>
{
t_broadcast.Text = "Down";
t_broadcast.ForeColor = Color.Red;
mi_broadcast_start.Enabled = true;
mi_broadcast_stop.Enabled = false;
});
};
Utils.Server.Connecting += (Utils.ConnectionEventArgs args) =>
{
RunOnUIThread(() =>
{
t_server.Text = "Up";
t_server.ForeColor = Color.Green;
t_host.Text = "Waiting for connection";
t_host.ForeColor = Color.GreenYellow;
mi_server_start.Enabled = false;
mi_server_stop.Enabled = true;
mi_server_disconnect.Enabled = false;
});
};
Utils.Server.Connected += (Utils.ConnectionEventArgs args) =>
{
Utils.Broadcast.Stop();
RunOnUIThread(() =>
{
t_server.Text = "Up";
t_server.ForeColor = Color.Green;
int h = args.RemoteHostname.Length;
int i = args.RemoteIPEndPoint.Address.ToString().Length;
t_host.Text = i > h ? args.RemoteHostname
: args.RemoteIPEndPoint.Address.ToString();
t_host.ForeColor = Color.Green;
mi_server_start.Enabled = false;
mi_server_stop.Enabled = true;
mi_server_disconnect.Enabled = true;
});
};
Utils.Server.Disconnect += (Utils.ConnectionEventArgs args) =>
{
RunOnUIThread(() =>
{
t_server.Text = "Down";
t_server.ForeColor = Color.Red;
t_host.Text = "No Controller";
t_host.ForeColor = Color.Red;
mi_server_start.Enabled = true;
mi_server_stop.Enabled = false;
mi_server_disconnect.Enabled = false;
});
};
Utils.Server.Error += (string message) =>
{
RunOnUIThread(() =>
{
t_server.Text = "Down";
t_server.ForeColor = Color.Red;
t_host.Text = "No Controller";
t_host.ForeColor = Color.Red;
mi_server_start.Enabled = true;
mi_server_stop.Enabled = false;
mi_server_disconnect.Enabled = false;
});
};
Utils.Server.OnStop += (Utils.ConnectionEventArgs args) =>
{
RunOnUIThread(() =>
{
t_server.Text = "Down";
t_server.ForeColor = Color.Red;
t_host.Text = "No Controller";
t_host.ForeColor = Color.Red;
mi_server_start.Enabled = true;
mi_server_stop.Enabled = false;
mi_server_disconnect.Enabled = false;
});
};
Utils.Server.DataReceived += (Utils.DataEventArgs args) =>
{
if (args.Data.Key.Trim().ToLower() != "sequence")
{
return;
}
try
{
int _seq = Convert.ToInt16(args.Data.Values[0]);
int _type = Convert.ToInt16(args.Data.Values[1]);
int _hr = 0;
int _min = 0;
int _sec = 0;
if (_type > (int)Utils.SequenceType.Fast)
{
_hr = Convert.ToInt16(args.Data.Values[2]);
_min = Convert.ToInt16(args.Data.Values[3]);
_sec = Convert.ToInt16(args.Data.Values[4]);
}
Utils.Sequence.Requested = true;
switch ((Utils.SequenceType)_type)
{
case Utils.SequenceType.Fast:
Utils.Sequence.Set(_seq);
break;
case Utils.SequenceType.Timed:
Utils.Sequence.Set(_seq, _hr, _min, _sec);
break;
case Utils.SequenceType.Scheduled:
Utils.MyDate md = new Utils.MyDate(_hr, _min, _sec);
if (md.Ticks <= DateTime.Now.Ticks)
{
md = new Utils.MyDate(
md.Year,
md.Month,
md.Day + 1,
md.Hour,
md.Minute,
md.Second
);
}
Utils.Sequence.Set(_seq, md);
break;
}
}
catch (ArgumentOutOfRangeException)
{
Utils.Log.Write("A stray sequence data received.", Utils.Log.CONSOLE);
return;
}
};
if (Utils.Config.IsSet("server"))
{
Utils.Server.Start();
if (Utils.Config.IsSet("broadcast"))
{
Utils.Broadcast.Start();
}
}
}
/// <summary>
/// Creates an instance with specified sequence and datetime when it will be executed.
/// </summary>
/// <param name="sequence">The new sequence being set.</param>
/// <param name="datetime">The DateTime instance of the date time when it will be executed.</param>
internal SequenceChangeEventArgs(SequenceList sequence, DateTime datetime)
: this(sequence, SequenceType.Scheduled)
{
date = new MyDate(datetime);
}
/// <summary>
/// Creates an instance with specified sequence and datetime when it will be executed.
/// </summary>
/// <param name="sequence">The new sequence being set.</param>
/// <param name="datetime">The MyDate instance of the date time when it will be executed.</param>
internal SequenceChangeEventArgs(SequenceList sequence, MyDate datetime)
: this(sequence, SequenceType.Scheduled)
{
date = datetime;
}
/// <summary>
/// Set the sequence to the specified sequence and its type to Scheduled.
/// Will execute on the date provided.
/// </summary>
/// <param name="seq">The sequence to be set.</param>
/// <param name="date">DateTime instance of the date when will execute.</param>
internal static void Set(SequenceList seq, MyDate date)
{
Log.Write("Trying to change sequence.");
if (currentSequence > SequenceList.NoShutdown && seq > SequenceList.NoShutdown)
{
OnErrorEvent("There is a sequence already set.");
return;
}
if (seq < SequenceList.Shutdown || seq > SequenceList.LockUser)
{
OnErrorEvent("Setting to an invalid timed sequence.");
return;
}
if (date.Millis < new MyDate().Millis + 5000)
{
OnErrorEvent("Setting scheduled sequence time five seconds or less in the future.");
return;
}
Stop();
alarm = new Alarm(date);
alarm.Expire += () =>
{
ExecuteCommand();
Reset();
};
alarm.AddTimeoutThreshold(60000);
alarm.AddTimeoutThreshold(600000);
alarm.AddTimeoutThreshold(3600000);
alarm.TimeoutRemaining += (int remain) =>
{
if (Config.Equals("alert", "1"))
{
string alert = "Will " + CurrentSequence + " in less than ";
switch (remain)
{
case 60000:
alert += "a minute.";
break;
case 600000:
alert += "ten minutes.";
break;
case 3600000:
alert += "an hour.";
break;
}
AlertBox.Show("Sequence Reminder!", alert, 15000);
}
};
Console.WriteLine(alarm.Timeout);
alarm.Start();
currentType = SequenceType.Scheduled;
currentSequence = seq;
if (Config.Equals("alert", "1"))
{
AlertBox.Show("Sequence Changed!",
"Will " + seq + " on " + date.GetString() + ".",
15000);
}
Log.Write("Set sequence to " + currentType + " " + seq + " that will execute on " + date.GetString() + ".");
OnSequenceChangeEvent(new SequenceChangeEventArgs(CurrentSequence, date));
}
/// <summary>
/// Set the sequence to the specified integral equivalent of the sequence and its type to Scheduled.
/// Will execute on the date provided.
/// </summary>
/// <param name="seq">The integral equivalent of the sequence.</param>
/// <param name="date">MyDate instance of the date when will execute.</param>
internal static void Set(int seq, MyDate date)
{
Set((SequenceList)seq, date);
}
/// <summary>
/// Creates an instance of this class using a specified MyDate instance where
/// its date will be the date and time when the alarm will expires.
/// </summary>
/// <param name="date">The MyDate instance that contains the date and time when the alarm will expires.</param>
public Alarm(MyDate date) : this()
{
this.date = date;
}
