public ChannelCopyDialog(AffectGridDelegate affectGridDelegate, EventSequence sequence, Channel selected, bool constrainToGroup)
{
InitializeComponent();
_channels = new Channel[constrainToGroup ? sequence.ChannelCount : sequence.FullChannelCount];
for (var channel = 0; channel < _channels.Length; channel++)
{
_channels[channel] = constrainToGroup ? sequence.Channels[channel] : sequence.FullChannels[channel];
}
// ReSharper disable CoVariantArrayConversion
comboBoxSourceChannel.Items.AddRange(_channels);
comboBoxDestinationChannel.Items.AddRange(_channels);
// ReSharper restore CoVariantArrayConversion
if (comboBoxSourceChannel.Items.Count > 0)
{
if (comboBoxSourceChannel.Items.Contains(selected))
{
comboBoxSourceChannel.SelectedItem = selected;
}
else
{
comboBoxSourceChannel.SelectedIndex = 0;
}
}
if (comboBoxDestinationChannel.Items.Count > 0)
{
comboBoxDestinationChannel.SelectedIndex = 0;
}
_eventSequence = sequence;
_sequenceData = new byte[1, sequence.TotalEventPeriods];
_affectGridDelegate = affectGridDelegate;
}
public override void SaveSequence(EventSequence eventSequence)
{
var contextNode = Xml.CreateXmlDocument();
BaseSaveSequence(contextNode, eventSequence, FormatChannel);
contextNode.Save(eventSequence.FileName);
}
public void Startup()
{
if (((this.m_thread != null) && this.m_running) && this.m_thread.IsAlive)
{
this.Shutdown();
}
this.m_virtualHardware = new VirtualHardware(this.m_boardLayout.Width, this.m_boardLayout.Height, this.m_ledSize, this.m_ledColor, this.m_dotPitch);
EventSequence executable = (EventSequence)this.m_executable;
this.m_ledUINode = executable.Extensions[".led"];
if (!this.m_useWithScript)
{
this.LoadFrames();
this.m_frameIndex = this.GetFrameAt(this.m_timer.Milliseconds);
this.FrameTimesFromFrameIndex(this.m_frameIndex);
this.m_thread = new Thread(new ThreadStart(this.StaticExecutionThread));
}
else
{
this.m_frames.Clear();
this.m_thread = new Thread(new ThreadStart(this.DynamicExecutionThread));
}
this.m_virtualHardware.Start();
this.m_running = true;
this.m_thread.Start();
}
public void GivenAnEventSequenceThenAnInstanceIsReturnedWithTheSequencePropagated()
{
var sequence = new EventSequence(10);
var @event = new SnapshotRestorationCompletedAsyncEventArgs(sequence);
Assert.Equal(sequence, @event.Sequence);
}
/// <summary>
/// Form to manage the Color Organ functionality
/// </summary>
/// <param name="xmlData"></param>
/// <param name="sequence"></param>
public ColorOrgan(ref XmlNode xmlData, EventSequence sequence)
{
// save the reference to the xml data
m_xmlData = xmlData;
// save the list of bands we have available to us
foreach (int frequency in m_frequencyArray)
{
FrequencyBand newBand = new FrequencyBand(frequency);
m_mapOfFrequencyBands.Add(newBand.CenterFrequency, newBand);
} // end build base frequency objects
// record the sequence
m_sequence = sequence;
// go find out what the peaks and valleys are for this sound track
analyzeSoundTrack();
// process xml data and set up any pre defined groups
// mark the frequency bands that are a member of this color organ band
XmlNodeList colorOrganBandNodes = xmlData.SelectNodes(m_xmlName_listOfColorOrganBands + "/*");
foreach (XmlNode xmlColorOrganBandNode in colorOrganBandNodes)
{
ColorOrganBand newBand = new ColorOrganBand(xmlColorOrganBandNode, m_mapOfFrequencyBands, m_sequence, this);
m_mapOfColorOrganBands.Add(newBand.ID, newBand);
} // end build color organ band list
// did we get any groups?
if (0 == m_mapOfColorOrganBands.Count)
{
createDefaultColorOrganBandSet(-1, 1);
} // end create default color band
} // ColorOrganForm
/// <summary>
/// Create an instance of a color organ band.
/// </summary>
/// <param name="xmlData"></param>
public ColorOrganBand(XmlNode xmlData,
Dictionary <string, FrequencyBand> frequencyBands,
EventSequence newSequence,
ColorOrgan colorOrgan)
{
// save the sequence data
Sequence = newSequence;
m_colorOrgan = colorOrgan;
m_frequencyBands = frequencyBands;
// Set the name for this Color Band
m_id = DateTime.Now.ToString("yyyyMMddHHmmssffffff", System.Globalization.CultureInfo.InvariantCulture);
Name = "All Frequencies" + m_id;
// parse the XML file
m_id = Xml.GetNodeAlways(xmlData, m_xmlName_id, m_id).InnerText;
Name = Xml.GetNodeAlways(xmlData, m_xmlName_name, Name).InnerText;
bool.TryParse(Xml.GetNodeAlways(xmlData, m_xmlName_usePeakLevels, m_usePeakLevels.ToString()).InnerText, out m_usePeakLevels);
m_minBinVariableRange = float.Parse(Xml.GetNodeAlways(xmlData, m_xmlName_minBinVariableRange, m_minBinVariableRange.ToString()).InnerText);
m_maxBinVariableRange = float.Parse(Xml.GetNodeAlways(xmlData, m_xmlName_maxBinVariableRange, m_maxBinVariableRange.ToString()).InnerText);
bool.TryParse(Xml.GetNodeAlways(xmlData, m_xmlName_clearChannelsOnWrite, m_clearChannelsOnWrite.ToString()).InnerText, out m_clearChannelsOnWrite);
// convert the list of Frequency bands into a list we can use
buildMapOfFrequencyBands(false);
// mark the frequency bands that are a member of this color organ band
XmlNodeList frequencyBandNodes = xmlData.SelectNodes(m_xmlName_mapOfFrequencyBands + "/*");
foreach (XmlNode xmlFrequencyBandNode in frequencyBandNodes)
{
string frequencyBandName = xmlFrequencyBandNode.InnerText;
m_mapOfFrequencyBands[frequencyBandName].Member = true;
m_energySumAvg += m_mapOfFrequencyBands[frequencyBandName].Avg;
m_energyPeak = Math.Max(m_energyPeak, m_mapOfFrequencyBands[frequencyBandName].Peak);
m_energyMin = Math.Min(m_energyMin, m_mapOfFrequencyBands[frequencyBandName].Min);
m_energyCount++;
} // end build member list
// build a list of the current channels
foreach (Vixen.Channel channel in Sequence.Channels)
{
ColorOrganChannel newChannel = new ColorOrganChannel(channel);
m_mapOfChannels.Add(newChannel.Id, newChannel);
} // end each channel in the sequence
// mark the channels that are a member of this color organ band
XmlNodeList channelNodes = xmlData.SelectNodes(m_xmlName_mapOfChannels + "/*");
foreach (XmlNode xmlChannelNode in channelNodes)
{
// is this channel still in the list of channels?
if (true == m_mapOfChannels.ContainsKey(xmlChannelNode.InnerText))
{
// mark the channel as active
m_mapOfChannels[xmlChannelNode.InnerText].Member = true;
}
} // end build member list
} // ColorOrganBand(xml)
} // ColorOrganBand(xml)
/// <summary>
/// Create a default color band
/// </summary>
/// <param name="frequencyBands"></param>
/// <param name="newSequence"></param>
/// <param name="colorOrgan"></param>
public ColorOrganBand(Dictionary <string, FrequencyBand> frequencyBands,
EventSequence newSequence,
ColorOrgan colorOrgan,
bool defaultFrequencyState = true)
{
m_colorOrgan = colorOrgan;
// save the sequence info
Sequence = newSequence;
m_frequencyBands = frequencyBands;
// Set the name for this Color Band
m_id = DateTime.Now.ToString("yyyyMMddHHmmssffffff", System.Globalization.CultureInfo.InvariantCulture);
Name = "All Frequencies" + m_id;
// build the list of frequencies associated with this band
buildMapOfFrequencyBands(defaultFrequencyState);
// build a list of the current channels
foreach (Vixen.Channel channel in Sequence.Channels)
{
ColorOrganChannel newChannel = new ColorOrganChannel(channel);
m_mapOfChannels.Add(newChannel.Id, newChannel);
} // end each channel in the sequence
} // default Color Organ Band
public void GivenASequenceAndALastUpdatedThenAnInstanceIsCreated()
{
DateTime timeStamp = DateTime.UtcNow;
var instance = new EventSequence(2, timeStamp: timeStamp);
Assert.Equal(timeStamp, instance.TimeStamp);
}
public override void ExitPanel()
{
if (_dialog.progressCurrentSequenceWhenComplete)
{
EventSequence.AdvanceSequence();
}
base.ExitPanel();
}
public void When_events_are_added_having_undefined_aggregate_id_then_the_EventSequence_SourceId_is_assigned()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent());
events.First().AggregateId.Should().Be(events.AggregateId);
}
public void When_events_are_added_having_undefined_aggregate_id_then_the_EventSequence_SourceId_is_assigned()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent());
events.First().AggregateId.Should().Be(events.AggregateId);
}
public void SaveSequence(EventSequence eventSequence)
{
const byte colorEncoding = 2, gamma = 1, versionMajor = 1, versionMinor = 0;
const string fileType = "PSEQ";
const ushort fixedHeaderLength = 28, mediaHeaderSize = 5, padding = 0, universeCount = 0, universeSize = 0;
var mediaFileName = eventSequence.Audio != null ? eventSequence.Audio.FileName ?? "" : "";
var mediaHeaderTotalLength = mediaFileName.Length == 0 ? 0 : mediaFileName.Length + mediaHeaderSize;
var offsetToSequenceData = RoundUshortTo4((ushort)(fixedHeaderLength + mediaHeaderTotalLength));
var numberOfChannels = RoundUIntTo4((uint)eventSequence.FullChannelCount);
var numberOfEvents = (uint)eventSequence.TotalEventPeriods;
var frameSizeMs = (ushort)eventSequence.EventPeriod;
using (var fileStream = new FileStream(eventSequence.FileName, FileMode.Create)) {
using (var binaryWriter = new BinaryWriter(fileStream)) {
binaryWriter.Write(fileType.ToCharArray()); // 0:3
binaryWriter.Write(offsetToSequenceData); // 4:5
binaryWriter.Write(versionMinor); // 6
binaryWriter.Write(versionMajor); // 7
binaryWriter.Write(fixedHeaderLength); // 8:9
binaryWriter.Write(numberOfChannels); // (step size) 10:13
binaryWriter.Write(numberOfEvents); // (steps/frames) 14:17
binaryWriter.Write(frameSizeMs); // 18:19
binaryWriter.Write(universeCount); // 20:21
binaryWriter.Write(universeSize); // 22:23
binaryWriter.Write(gamma); // 24
binaryWriter.Write(colorEncoding); // 25
binaryWriter.Write(padding); // 26:27
if (mediaHeaderTotalLength > 0)
{
binaryWriter.Write((ushort)(mediaHeaderTotalLength)); // 28:29
binaryWriter.Write("mf".ToCharArray()); // 30:31
binaryWriter.Write(mediaFileName.ToCharArray()); // 32:32+mediaFileName.Length
}
// (pad to nearest 4)
var padSize = offsetToSequenceData - (fixedHeaderLength + mediaHeaderTotalLength);
for (var pad = 0; pad < padSize; pad++)
{
binaryWriter.Write((byte)0);
}
// Write the event data
for (var period = 0; period < numberOfEvents; period++)
{
for (var channel = 0; channel < numberOfChannels; channel++)
{
binaryWriter.Write(eventSequence.EventValues[channel, period]);
}
}
// Done and Done :)
binaryWriter.Close();
}
}
}
} // SetChan
/// <summary>
/// Update the channels value in the vixen sequence
/// </summary>
/// <param name="Sequence"></param>
/// <param name="currentEventPeriod"></param>
internal void ClearChan(EventSequence Sequence, uint currentEventPeriod)
{
// is this channel a member of the color organ band?
if (true == Member)
{
// Write the value
Sequence.EventValues[m_channel.OutputChannel, currentEventPeriod] = Sequence.MinimumLevel;
}
} // SetChan
public SequenceSettingsDialog(EventSequence sequence)
{
InitializeComponent();
Icon = common.Resources.VixenPlus;
_eventSequence = sequence;
numericUpDownMinimum.Value = sequence.MinimumLevel;
numericUpDownMaximum.Value = sequence.MaximumLevel;
textBoxEventPeriodLength.Text = sequence.EventPeriod.ToString(CultureInfo.InvariantCulture);
}
public void When_an_event_with_a_non_matching_aggregate_id_is_added_then_it_throws()
{
var list = new EventSequence(Guid.NewGuid());
list.Invoking(l => l.Add(new TestEvent {
AggregateId = Guid.NewGuid()
}))
.ShouldThrow <ArgumentException>();
}
public SequenceSettingsDialog(EventSequence sequence)
{
InitializeComponent();
Icon = common.Resources.VixenPlus;
_eventSequence = sequence;
numericUpDownMinimum.Value = sequence.MinimumLevel;
numericUpDownMaximum.Value = sequence.MaximumLevel;
textBoxEventPeriodLength.Text = sequence.EventPeriod.ToString(CultureInfo.InvariantCulture);
}
public void GivenAggregatesAndASequenceThenAnInstanceIsCreated()
{
EventCentricAggregateRoot[] aggregates = new[] { new SerializableEventCentricAggregateRoot() };
var sequence = new EventSequence(2);
var instance = new Snapshot(aggregates, sequence);
Assert.Equal(aggregates, instance.Aggregates);
Assert.Equal(sequence, instance.Sequence);
}
public NewSequenceWizardDialog(Preference2 preferences)
{
InitializeComponent();
_preferences = preferences;
_eventSequence = new EventSequence(_preferences);
_history = new Stack <int>();
InitializeClass();
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
var sequence = new EventSequence(3);
EventSequence deserialized = sequence.Clone();
Assert.Equal(sequence.Sequence, deserialized.Sequence);
Assert.Equal(sequence.TimeStamp, deserialized.TimeStamp);
Assert.NotSame(sequence, deserialized);
}
public DimmingCurveDialog(EventSequence sequence, Channel selectChannel)
{
var miniBoxColor = Color.BlueViolet;
var miniLineColor = Color.Blue;
var curveGridColor = Color.LightGray;
var curveLineColor = Color.Blue;
var curvePointColor = Color.Black;
_pointSize = 4;
const int dotPitch = 4;
_miniMouseDownLast = new Point(-1, -1);
_miniMouseMinLocation = new Point(0, 0);
_miniMouseMaxLocation = new Point(0, 0);
_selectedPointAbsolute = -1;
_selectedPointRelative = -1;
_usingActualLevels = true;
_availableValues = 256f;
components = null;
InitializeComponent();
Icon = common.Resources.VixenPlus;
if (sequence != null) {
Action<Channel> action = c => comboBoxChannels.Items.Add(c.Clone());
sequence.Channels.ForEach(action);
_eventSequence = sequence;
}
else {
labelSequenceChannels.Enabled = false;
comboBoxChannels.Enabled = false;
if (selectChannel != null) {
_originalChannel = selectChannel;
comboBoxChannels.Items.Add(selectChannel = selectChannel.Clone());
}
}
_gridSpacing = _pointSize + dotPitch;
_halfPointSize = (_pointSize) / 2f;
_curveRowPointsPerMiniPixel = _availableValues / (pbMini.Width);
_curveColPointsPerMiniPixel = _availableValues / (pbMini.Height);
if (pictureBoxCurve != null) {
_miniBoxBounds = new Rectangle(0, 0, (int) (pictureBoxCurve.Width / (float) _gridSpacing / _availableValues * pbMini.Width),
(int) (pictureBoxCurve.Height / (float) _gridSpacing / _availableValues * pbMini.Height));
}
_miniBackBrush = new SolidBrush(pbMini.BackColor);
if (pictureBoxCurve != null) {
_curveBackBrush = new SolidBrush(pictureBoxCurve.BackColor);
}
_miniBoxPen = new Pen(miniBoxColor);
_miniLinePen = new Pen(miniLineColor);
_curveGridPen = new Pen(curveGridColor);
_curveLinePen = new Pen(curveLineColor);
_curvePointBrush = new SolidBrush(curvePointColor);
if (comboBoxChannels.Items.Count > 0) {
comboBoxChannels.SelectedItem = selectChannel ?? comboBoxChannels.Items[0];
}
SwitchDisplay(Preference2.GetInstance().GetBoolean("ActualLevels"));
comboBoxImport.SelectedIndex = 0;
comboBoxExport.SelectedIndex = 0;
}
public AudioDialog(EventSequence sequence, bool autoSize, int deviceIndex)
{
InitializeComponent();
Icon = common.Resources.VixenPlus;
_fmod = (deviceIndex > 0) ? fmod.GetInstance(deviceIndex) : fmod.GetInstance(-1);
_timer = new Timer(10.0);
_timer.Elapsed += TimerElapsed;
_eventSequence = sequence;
_keyStates = new bool[_eventSequence.FullChannelCount];
_stopwatch = new Stopwatch();
_newEventValues = new byte[_eventSequence.Rows,_eventSequence.Cols];
listBoxChannels.Items.AddRange(_eventSequence.FullChannels.ToArray());
_originalAudio = sequence.Audio;
if (sequence.Audio != null) {
if (LoadAudio(_eventSequence.Audio.FileName) == null) {
sequence.Audio = null;
buttonRemoveAudio.Enabled = false;
ClearAudio();
}
else {
buttonRemoveAudio.Enabled = true;
}
}
else {
buttonRemoveAudio.Enabled = false;
ClearAudio();
}
checkBoxAutoSize.Checked = autoSize;
if (!autoSize) {
UpdateRecordableLength();
}
var items = (_eventSequence.FullChannels.ToArray());
channel1ToolStripMenuItem.Items.AddRange(items);
channel2ToolStripMenuItem.Items.AddRange(items);
channel3ToolStripMenuItem.Items.AddRange(items);
channel4ToolStripMenuItem.Items.AddRange(items);
channel5ToolStripMenuItem.Items.AddRange(items);
channel6ToolStripMenuItem.Items.AddRange(items);
channel7ToolStripMenuItem.Items.AddRange(items);
channel8ToolStripMenuItem.Items.AddRange(items);
channel9ToolStripMenuItem.Items.AddRange(items);
channel0ToolStripMenuItem.Items.AddRange(items);
channel1ToolStripMenuItem.SelectedIndex = Math.Min(0, _eventSequence.FullChannelCount - 1);
channel2ToolStripMenuItem.SelectedIndex = Math.Min(1, _eventSequence.FullChannelCount - 1);
channel3ToolStripMenuItem.SelectedIndex = Math.Min(2, _eventSequence.FullChannelCount - 1);
channel4ToolStripMenuItem.SelectedIndex = Math.Min(3, _eventSequence.FullChannelCount - 1);
channel5ToolStripMenuItem.SelectedIndex = Math.Min(4, _eventSequence.FullChannelCount - 1);
channel6ToolStripMenuItem.SelectedIndex = Math.Min(5, _eventSequence.FullChannelCount - 1);
channel7ToolStripMenuItem.SelectedIndex = Math.Min(6, _eventSequence.FullChannelCount - 1);
channel8ToolStripMenuItem.SelectedIndex = Math.Min(7, _eventSequence.FullChannelCount - 1);
channel9ToolStripMenuItem.SelectedIndex = Math.Min(8, _eventSequence.FullChannelCount - 1);
channel0ToolStripMenuItem.SelectedIndex = Math.Min(9, _eventSequence.FullChannelCount - 1);
comboBoxAudioDevice.Items.Add(Resources.UseApplicationDefaultAudio);
comboBoxAudioDevice.Items.AddRange(fmod.GetSoundDeviceList());
comboBoxAudioDevice.SelectedIndex = _eventSequence.AudioDeviceIndex + 1;
}
public void EventSequence_version_returns_current_highest_SequenceNumber()
{
var sequence = new EventSequence(Guid.NewGuid());
sequence.Add(new TestEvent());
sequence.Add(new TestEvent());
sequence.Add(new TestEvent());
sequence.Version.Should().Be(3);
}
public void When_events_are_added_having_defined_SequenceNumbers_then_the_ids_are_maintained()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent { SequenceNumber = 3 });
events.Add(new TestEvent { SequenceNumber = 2 });
events.Add(new TestEvent { SequenceNumber = 1 });
events.First().SequenceNumber.Should().Be(events.Last().SequenceNumber - 2);
}
public void When_events_are_added_with_with_gaps_in_their_SequenceNumbers_then_they_are_assigned_the_next_sequential_value()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent { SequenceNumber = 22 });
events.Add(new TestEvent { SequenceNumber = 33 });
events.Add(new TestEvent());
events.Last().SequenceNumber.Should().Be(34);
}
} // ColorOrganChannel
/// <summary>
/// Update the channels value in the vixen sequence
/// </summary>
/// <param name="Sequence"></param>
/// <param name="currentEventPeriod"></param>
/// <param name="periodValue"></param>
internal void SetChan(EventSequence Sequence, uint currentEventPeriod, byte periodValue)
{
// is this channel a member of the color organ band?
if (true == Member)
{
byte oldValue = Sequence.EventValues[m_channel.OutputChannel, currentEventPeriod];
// Write the value
Sequence.EventValues[m_channel.OutputChannel, currentEventPeriod] = Math.Max(oldValue, periodValue);
}
} // SetChan
public NutcrackerControlDialog(EventSequence sequence, Rectangle selectedRange, bool constrainToGroup)
{
_sequence = sequence;
_selectedRange = selectedRange;
_channels = constrainToGroup ? _sequence.Channels : _sequence.FullChannels;
InitializeComponent();
MaximumSize = Size;
MinimumSize = Size;
InitializeControls();
}
public void Events_are_ordered_by_SequenceNumber_regardless_of_the_order_in_which_they_are_added()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent { SequenceNumber = 3 });
events.Add(new TestEvent { SequenceNumber = 2 });
events.Add(new TestEvent { SequenceNumber = 1 });
events.Add(new TestEvent { SequenceNumber = 4 });
events.Select(e => e.SequenceNumber).Should().BeInAscendingOrder();
}
public void GivenAnInstanceThenAllPropertiesAreSerialized()
{
EventCentricAggregateRoot[] aggregates = new[] { new SerializableEventCentricAggregateRoot() };
var sequence = new EventSequence(2);
var instance = new Snapshot(aggregates, sequence);
Snapshot deserialized = instance.Clone();
Assert.Equal(instance.Aggregates, deserialized.Aggregates);
Assert.Equal(instance.Sequence.Sequence, deserialized.Sequence.Sequence);
Assert.Equal(instance.Sequence.TimeStamp, deserialized.Sequence.TimeStamp);
Assert.NotSame(instance, deserialized);
}
public void When_events_are_added_without_defined_SequenceNumbers_then_they_are_assigned_the_next_sequential_value()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent {
SequenceNumber = 2
});
events.Add(new TestEvent());
events.Add(new TestEvent());
events.Last().SequenceNumber.Should().Be(4);
}
public void Events_added_out_of_order_do_not_have_their_SequenceNumbers_changed()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent { SequenceNumber = 3, Data = "3" });
events.Add(new TestEvent { SequenceNumber = 2, Data = "2" });
events.Add(new TestEvent { SequenceNumber = 1, Data = "1" });
events.Add(new TestEvent { SequenceNumber = 4, Data = "4" });
events.Cast<TestEvent>().Select(e => e.Data)
.SequenceEqual(new[] { "1", "2", "3", "4" });
}
internal void CopyToSequence(EventSequence sequence)
{
for (int id = 0; id < sequence.Channels.Count; ++id)
{
Channel channel = sequence.Channels[id];
int eventRow = sequence.FullChannels.IndexOf(channel);
for (int eventCol = 0; eventCol < sequence.TotalEventPeriods; ++eventCol)
{
sequence.EventValues[eventRow, eventCol] = channels[id].getEventAt(eventCol).getValue();
}
}
}
public BeatTrackImporter(EventSequence sequence)
{
InitializeComponent();
_sequence = sequence;
comboBoxEventsPerBeat.SelectedIndex = 0;
comboBoxEventsPerBeat.Focus();
_providedEventPeriod = _sequence.EventPeriod;
tbSequenceEventPeriod.Text = _providedEventPeriod.ToString();
PopulateChannelListView();
}
public void LoadEmbeddedData(string fileName, EventSequence es)
{
if (!string.IsNullOrEmpty(fileName) && File.Exists(fileName))
{
var document = new XmlDocument();
document.Load(fileName);
LoadEmbeddedData(document.SelectSingleNode("//Program"), es);
}
else
{
es.PlugInData = new SetupData();
}
}
public IEventSequence FromJournal(object evt, string manifest)
{
Json m;
if ((m = evt as Json) != null && m.Payload.ToString().StartsWith("b"))
{
return(EventSequence.Single(new NewB(m.Payload)));
}
else
{
return(EventSequence.Empty);
}
}
public override void SaveSequence(EventSequence eventSequence)
{
var contextNode = Xml.CreateXmlDocument();
BaseSaveSequence(contextNode, eventSequence, FormatChannel);
var programNode = Xml.GetNodeAlways(contextNode, "Program");
if (eventSequence.Profile == null)
{
Group.SaveToXml(programNode, eventSequence.Groups);
}
contextNode.Save(eventSequence.FileName);
}
public void When_an_event_with_an_already_present_SequenceNumber_is_added_then_it_throws()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent {
SequenceNumber = 1
});
Action addAgain = () =>
events.Add(new TestEvent {
SequenceNumber = 1
});
addAgain.ShouldThrow <ArgumentException>();
}
private static void LoadEmbeddedData(XmlNode requiredNode, EventSequence es)
{
var fullChannels = new List <Channel>();
var xmlNodeList = requiredNode.SelectNodes("Channels/Channel");
if (xmlNodeList != null)
{
fullChannels.AddRange(from XmlNode node in xmlNodeList select new Channel(node));
}
es.SetFullChannels(fullChannels);
es.PlugInData = new SetupData();
es.PlugInData.LoadFromXml(requiredNode);
es.Groups = Group.LoadFromXml(requiredNode) ?? new Dictionary <string, GroupData>();
Group.LoadFromFile(requiredNode, es.Groups);
}
public override bool Equals(object obj)
{
var other = obj as CustomerCreatedEvent;
if (other == null)
{
return(false);
}
var result = EventIdentifier.Equals(other.EventIdentifier) &&
EventSourceId.Equals(other.EventSourceId) &&
EventSequence.Equals(other.EventSequence) &&
Name.Equals(other.Name) &&
Age.Equals(other.Age);
return(result);
}
public void EventSequence_version_returns_current_highest_SequenceNumber_when_events_are_out_of_order()
{
var sequence = new EventSequence(Guid.NewGuid());
sequence.Add(new TestEvent { SequenceNumber = 4 });
sequence.Add(new TestEvent { SequenceNumber = 9000 });
sequence.Add(new TestEvent { SequenceNumber = 9 });
sequence.Version.Should().Be(9000);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventSourcedAggregate"/> class.
/// </summary>
/// <param name="id">The id for the new aggregate. If this is not specified, a new <see cref="Guid" /> is created.</param>
protected EventSourcedAggregate(Guid? id = null)
{
this.id = id ?? Guid.NewGuid();
eventHistory = new EventSequence(this.id);
pendingEvents = new EventSequence(this.id);
}
public void When_an_event_with_an_already_present_SequenceNumber_is_added_then_it_throws()
{
var events = new EventSequence(Guid.NewGuid());
events.Add(new TestEvent { SequenceNumber = 1 });
Action addAgain = () =>
events.Add(new TestEvent { SequenceNumber = 1 });
addAgain.ShouldThrow<ArgumentException>();
}
public void When_an_event_with_a_non_matching_aggregate_id_is_added_then_it_throws()
{
var list = new EventSequence(Guid.NewGuid());
list.Invoking(l => l.Add(new TestEvent { AggregateId = Guid.NewGuid() }))
.ShouldThrow<ArgumentException>();
}
/// <summary>
/// Initialise the flythrough transition an xml file.
/// </summary>
/// <param name="file">The file to load as a flythrough.</param>
public void Load(string file)
{
if (!File.Exists(file)) {
Logger.Warn("Unable to load " + file + ". Ignoring load request.");
return;
}
if (FlythroughLoading != null)
FlythroughLoading();
mEvents = new EventSequence<Camera>();
mEvents.LengthChange += new Action<EventSequence<Camera>, int>(mEvents_LengthChange);
XmlDocument doc = new XmlDocument();
doc.Load(file);
int start = 0;
XmlNode root = doc.GetElementsByTagName("Events")[0];
XmlAttribute startPositionAttr = root.Attributes["StartPosition"];
XmlAttribute startPitchAttr = root.Attributes["StartPitch"];
XmlAttribute startYawAttr = root.Attributes["StartYaw"];
Vector3 startPos = mCore.Position;
double startPitch = mCore.Orientation.Pitch;
double startYaw = mCore.Orientation.Yaw;
if (startPositionAttr != null) Vector3.TryParse(startPositionAttr.Value, out startPos);
if (startPitchAttr != null) double.TryParse(startPitchAttr.Value, out startPitch);
if (startYawAttr != null) double.TryParse(startYawAttr.Value, out startYaw);
Start = new Camera(startPos, new Rotation(startPitch, startYaw));
foreach (XmlNode node in root.ChildNodes) {
if (node is XmlElement) {
ComboEvent evt = new ComboEvent(this);
evt.Load(node);
mEvents.AddEvent(evt);
start = evt.SequenceStartTime + evt.Length;
}
}
mCore.Update(Start.Position, Vector3.Zero, Start.Orientation, Rotation.Zero);
if (FlythroughLoaded != null)
FlythroughLoaded();
}
public void EventSequence_version_starts_at_zero()
{
var sequence = new EventSequence(Guid.NewGuid());
sequence.Version.Should().Be(0);
}
private void mEvents_LengthChange(EventSequence<Camera> sequence, int length)
{
if (LengthChange != null)
LengthChange(length);
}
public void EventSequence_version_returns_current_highest_SequenceNumber()
{
var sequence = new EventSequence(Guid.NewGuid());
sequence.Add(new TestEvent());
sequence.Add(new TestEvent());
sequence.Add(new TestEvent());
sequence.Version.Should().Be(3);
}
public NewSequenceWizardDialog(Preference2 preferences)
{
InitializeComponent();
_preferences = preferences;
_eventSequence = new EventSequence(_preferences);
_history = new Stack<int>();
InitializeClass();
}
