private void AddMarks(IEffectNode effectNode, ISequence sequence)
{
if (effectNode.Effect.SupportsMarks)
{
effectNode.Effect.MarkCollections = sequence.LabeledMarkCollections;
}
}
private void RenderEffect(IEffectNode node)
{
if (node.Effect.IsDirty)
{
node.Effect.PreRender();
}
}
private bool _DataListener(IEffectNode effectNode)
{
// Data has been inserted into the sequence.
// Give every behavior a chance at the data.
foreach (IRuntimeBehaviorModuleInstance behavior in _runtimeBehaviors)
{
if (behavior.Enabled)
{
//*** Can't remember why this is being set here in this fashion.
// Shouldn't it be done by whatever creates the node?
//effectNode.StartTime = _TimingSource.Position;
behavior.Handle(effectNode);
}
}
// Data written to a sequence will go through the behaviors and then on to the
// effect enumerator of the executor by way of the CommandNodeIntervalSync
// to be executed against the sequence's time. This has the side effect of
// allowing timed-live behavior without an explicit runtime behavior that has
// to manage timing on its own.
_sequence.Data.AddLive(effectNode);
// We don't want any handlers beyond the executor to get live data.
return(true);
}
private void AddMedia(IEffectNode effectNode, ISequence sequence)
{
if (effectNode.Effect.SupportsMedia)
{
effectNode.Effect.Media = sequence.SequenceData.Media;
}
}
private bool _DataListener(IEffectNode effectNode)
{
SequenceData.EffectData.AddData(effectNode);
SequenceData.LocalDataSet.AssignModuleInstanceData(effectNode.Effect);
// Do not cancel the event.
return(false);
}
public EffectNodeSurrogate(IEffectNode effectNode)
{
StartTime = effectNode.StartTime;
TypeId = effectNode.Effect.Descriptor.TypeId;
InstanceId = effectNode.Effect.InstanceId;
TimeSpan = effectNode.Effect.TimeSpan;
TargetNodes = effectNode.Effect.TargetNodes.Select(x => new ChannelNodeReferenceSurrogate(x)).ToArray();
}
public EffectNodeSurrogate(IEffectNode effectNode)
{
StartTime = effectNode.StartTime;
TypeId = effectNode.Effect.Descriptor.TypeId;
InstanceId = effectNode.Effect.InstanceId;
TimeSpan = effectNode.Effect.TimeSpan;
TargetNodes = effectNode.Effect.TargetNodes.Select(x => new ChannelNodeReferenceSurrogate(x)).ToArray();
}
protected override bool _DataListener(IEffectNode effectNode)
{
//*** compensation delta, user-configurable
IEffectNode contextRelativeEffectNode = new EffectNode(effectNode.Effect,
effectNode.StartTime + TimingSource.Position);
Sequence.SequenceData.EffectData.AddData(contextRelativeEffectNode);
// We don't want any handlers beyond the executor to get live data.
return true;
}
public void InsertData(IEffectNode effectNode)
{
bool cancel = false;
using (IEnumerator<DataListener> enumerator = _listeners.GetEnumerator()) {
while (!cancel && enumerator.MoveNext()) {
cancel = enumerator.Current(effectNode);
}
}
}
protected override bool _DataListener(IEffectNode effectNode)
{
//*** compensation delta, user-configurable
IEffectNode contextRelativeEffectNode = new EffectNode(effectNode.Effect, effectNode.StartTime + TimingSource.Position);
Sequence.SequenceData.EffectData.AddData(contextRelativeEffectNode);
// We don't want any handlers beyond the executor to get live data.
return(true);
}
private void RenderEffect(IEffectNode node)
{
if (node.Effect.SupportsMedia)
{
node.Effect.Media = _sequence.SequenceData.Media;
}
node.Effect.PreRender();
}
public void AssignEffectNodeToLayer(IEffectNode node, Guid LayerId)
{
ILayer layer;
if (_layerMap.TryGetValue(LayerId, out layer))
{
AssignEffectNodeToLayer(node, layer);
}
}
public void AssignEffectNodeToLayer(IEffectNode node, ILayer layer)
{
//First remove it from any already existing layers
RemoveEffectNodeFromLayers(node);
if (!IsDefaultLayer(layer) && _layerMap.ContainsKey(layer.Id))
{
//if it is not the default then assign it to the new layer
_effectLayerMap[node.Effect.InstanceId] = layer.Id;
}
}
public void InsertData(IEffectNode effectNode)
{
bool cancel = false;
using (IEnumerator <DataListener> enumerator = _listeners.GetEnumerator()) {
while (!cancel && enumerator.MoveNext())
{
cancel = enumerator.Current(effectNode);
}
}
}
public ILayer GetLayer(IEffectNode node)
{
Guid layerId;
if (_effectLayerMap.TryGetValue(node.Effect.InstanceId, out layerId))
{
ILayer layer;
if (_layerMap.TryGetValue(layerId, out layer))
{
return(layer);
}
}
return(Layers[Layers.Count - 1]);
}
public bool RemoveData(IEffectNode effectNode)
{
return SequenceData.EffectData.RemoveData(effectNode);
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return(_sequenceExecutor.SequenceLayers.GetLayer(node));
}
protected virtual bool _DataListener(IEffectNode effectNode)
{
// We don't want any handlers beyond the executor to get live data.
return true;
}
public void Add(IEffectNode item)
{
_queue.Enqueue(item);
}
//Let each context decide how to apply the layers. protected abstract ILayer GetLayerForNode(IEffectNode node);
public static TimeSpan GetEffectRelativeTime(TimeSpan currentTime, IEffectNode effectNode)
{
return currentTime - effectNode.StartTime;
}
private void RenderEffect(IEffectNode node)
{
if (node.Effect.IsDirty)
{
node.Effect.PreRender();
}
}
public void AssignEffectNodeToDefaultLayer(IEffectNode node)
{
//We jusr remove it because if it is not found it will be in the default.
RemoveEffectNodeFromLayers(node);
}
public void RemoveEffectNodeFromLayers(IEffectNode node)
{
_effectLayerMap.Remove(node.Effect.InstanceId);
}
public ILayer GetLayer(IEffectNode node)
{
Guid layerId;
if(_effectLayerMap.TryGetValue(node.Effect.InstanceId, out layerId))
{
ILayer layer;
if (_layerMap.TryGetValue(layerId, out layer))
{
return layer;
}
}
return Layers[Layers.Count-1];
}
public void AssignEffectNodeToLayer(IEffectNode node, ILayer layer)
{
//First remove it from any already existing layers
RemoveEffectNodeFromLayers(node);
if (!IsDefaultLayer(layer) && _layerMap.ContainsKey(layer.Id))
{
//if it is not the default then assign it to the new layer
_effectLayerMap[node.Effect.InstanceId] = layer.Id;
}
}
//Let each context decide how to apply the layers. protected abstract ILayer GetLayerForNode(IEffectNode node);
private void _AddToQueue(IEffectNode effectNode)
{
_effectNodeQueue.Add(effectNode);
_LastBufferWritePoint = effectNode.StartTime;
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return Sequence.SequenceData.SequenceLayers.GetLayer(node);
}
public void AssignEffectNodeToLayer(IEffectNode node, Guid LayerId)
{
ILayer layer;
if(_layerMap.TryGetValue(LayerId, out layer))
{
AssignEffectNodeToLayer(node, layer);
}
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return(Sequence.GetSequenceLayerManager().GetLayer(node));
}
abstract public void Handle(IEffectNode effectNode);
protected override ILayer GetLayerForNode(IEffectNode node)
{
return(Sequence.SequenceData.SequenceLayers.GetLayer(node));
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return(SequenceLayers.GetDefaultLayer());
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return Sequence.GetSequenceLayerManager().GetLayer(node);
}
public void RemoveEffectNodeFromLayers(IEffectNode node)
{
_effectLayerMap.Remove(node.Effect.InstanceId);
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return _sequenceExecutor.SequenceLayers.GetLayer(node);
}
private bool _DataListener(IEffectNode effectNode)
{
// Data has been inserted into the sequence.
// Give every behavior a chance at the data.
foreach(IRuntimeBehaviorModuleInstance behavior in _runtimeBehaviors) {
if(behavior.Enabled) {
//*** Can't remember why this is being set here in this fashion.
// Shouldn't it be done by whatever creates the node?
//effectNode.StartTime = _TimingSource.Position;
behavior.Handle(effectNode);
}
}
// Data written to a sequence will go through the behaviors and then on to the
// effect enumerator of the executor by way of the CommandNodeIntervalSync
// to be executed against the sequence's time. This has the side effect of
// allowing timed-live behavior without an explicit runtime behavior that has
// to manage timing on its own.
_sequence.Data.AddLive(effectNode);
// We don't want any handlers beyond the executor to get live data.
return true;
}
public int CompareTo(IEffectNode other)
{
return(DataNode.Compare(this, other));
}
protected virtual bool _DataListener(IEffectNode effectNode)
{
// We don't want any handlers beyond the executor to get live data.
return(true);
}
public void InsertData(IEffectNode effectNode)
{
InsertDataListener.InsertData(effectNode);
}
protected override ILayer GetLayerForNode(IEffectNode node)
{
return SequenceLayers.GetDefaultLayer();
}
private bool _DataListener(IEffectNode effectNode)
{
SequenceData.EffectData.AddData(effectNode);
SequenceData.LocalDataSet.AssignModuleInstanceData(effectNode.Effect);
// Do not cancel the event.
return false;
}
//private Guid _GetSequenceChannelId() {
// if(_sequenceChannelId == Guid.Empty) {
// _sequenceChannelId = _sequence.SequenceData.DataStreams.CreateStream("Recording");
// }
// return _sequenceChannelId;
//}
public override void Handle(IEffectNode effectNode)
{
_buffer.Add(effectNode);
}
private void AddMedia(IEffectNode effectNode, ISequence sequence)
{
if (effectNode.Effect.SupportsMedia)
{
effectNode.Effect.Media = sequence.SequenceData.Media;
}
}
public void InsertData(IEffectNode effectNode)
{
InsertDataListener.InsertData(effectNode);
}
public static TimeSpan GetEffectRelativeTime(TimeSpan currentTime, IEffectNode effectNode)
{
return(currentTime - effectNode.StartTime);
}
public bool RemoveData(IEffectNode effectNode)
{
return Data.RemoveData(effectNode);
}
//private Guid _GetSequenceChannelId() {
// if(_sequenceChannelId == Guid.Empty) {
// _sequenceChannelId = _sequence.SequenceData.DataStreams.CreateStream("Recording");
// }
// return _sequenceChannelId;
//}
public override void Handle(IEffectNode effectNode)
{
_buffer.Add(effectNode);
}
private void _AddToQueue(IEffectNode effectNode)
{
_effectNodeQueue.Add(effectNode);
_LastBufferWritePoint = effectNode.StartTime;
}
private void RenderEffect(IEffectNode node)
{
if (node.Effect.SupportsMedia)
{
node.Effect.Media = _sequence.SequenceData.Media;
}
node.Effect.PreRender();
}
public void Add(IEffectNode item)
{
_queue.Enqueue(item);
}
public bool RemoveData(IEffectNode effectNode)
{
return(Data.RemoveData(effectNode));
}
private void AddMediaAndMarks(IEffectNode effectNode, ISequence sequence)
{
AddMedia(effectNode, sequence);
AddMarks(effectNode, sequence);
}
public bool RemoveData(IEffectNode effectNode)
{
return(SequenceData.EffectData.RemoveData(effectNode));
}
public void AssignEffectNodeToDefaultLayer(IEffectNode node)
{
//We jusr remove it because if it is not found it will be in the default.
RemoveEffectNodeFromLayers(node);
}
