/// <summary>
/// Instantiates the data model for the module from the data in this data set.
/// Accounts for the module's instance id so there can be multiple instances
/// of a module type in the dataset.
/// </summary>
/// <param name="module"></param>
public void AssignModuleInstanceData(IModuleInstance module)
{
if (module != null)
{
// 1. Module has a data object, we don't.
// - Add the module's data object
// 2. Module has no data object, we do.
// - Get our data object and assign it in the module
// 3. We and the module have a data object.
// - Get our data object and assign it in the module
// 4. Neither has a data object.
// - We create one within ourselves and assign it in the module.
IModuleDataModel dataModel = _GetDataInstance(module);
if (!_ContainsInstanceData(module.Descriptor.TypeId, module.InstanceId) && dataModel != null)
{
// We have no data, but the module does. Add it.
_AddAsInstanceData(dataModel, module);
}
else
{
// In every other case, we have or can create data.
module.ModuleData = _GetOrCreateAsInstanceData(module);
}
//* This behavior was put in for a reason now lost to history.
//* KEEP THIS CODE, in case the reason is discovered.
//// If the module already has data, add it, don't overwrite it.
//IModuleDataModel dataModel = _GetDataInstance(module);
//if(dataModel == null) {
// module.ModuleData = RetrieveInstanceData(module);
//} else {
// _Add(this, module.Descriptor.TypeId, module.InstanceId, dataModel);
//}
}
}
private IModuleDataModel _GetAsInstanceData(IModuleInstance module)
{
IModuleDataModel model = null;
_dataModels.TryGetValue(Tuple.Create(module.TypeId, module.InstanceId), out model);
return(model);
}
private IModuleDataModel _GetAsTypeData(Guid id)
{
IModuleDataModel model = null;
_dataModels.TryGetValue(Tuple.Create(id, id), out model);
return(model);
}
private void _RemoveInstanceData(IModuleInstance module)
{
IModuleDataModel dataModel = _GetAsInstanceData(module);
if (dataModel != null)
{
_dataModels.Remove(Tuple.Create(module.TypeId, module.InstanceId));
}
}
private void _RemoveInstanceData(IModuleInstance module)
{
IModuleDataModel dataModel = _GetAsInstanceData(module);
if (dataModel != null)
{
_dataModels.Remove(dataModel);
}
}
private void _Add(IModuleDataModel dataModel, Guid moduleTypeId, Guid moduleInstanceId)
{
if (dataModel == null)
{
return; // throw new ArgumentNullException("dataModel");
}
_dataModels.Add(Tuple.Create(moduleTypeId, moduleInstanceId), dataModel);
dataModel.ModuleTypeId = moduleTypeId;
dataModel.ModuleInstanceId = moduleInstanceId;
dataModel.ModuleDataSet = this;
}
protected IModuleDataModel _GetOrCreateAsTypeData(Guid typeId)
{
IModuleDataModel dataModel = _GetAsTypeData(typeId);
if (dataModel == null)
{
dataModel = _CreateDataModel(typeId);
_AddAsTypeData(dataModel, typeId);
}
return(dataModel);
}
protected IModuleDataModel _GetOrCreateAsInstanceData(IModuleInstance module)
{
IModuleDataModel dataModel = _GetAsInstanceData(module);
if (dataModel == null)
{
dataModel = _CreateDataModel(module);
_AddAsInstanceData(dataModel, module);
}
return(dataModel);
}
protected static IModuleDataModel _CreateDataModel(Type dataModelType)
{
IModuleDataModel dataModel = null;
if (dataModelType != null)
{
dataModel = Activator.CreateInstance(dataModelType) as IModuleDataModel;
}
return(dataModel);
}
public static IModuleDataModel CreateModuleDataInstance(IModuleInstance module)
{
IModuleDataModel dataModel = null;
Type moduleDataSetType = _GetModuleDataSetType(module.Descriptor);
if (moduleDataSetType != null)
{
dataModel = _CreateDataModel(moduleDataSetType);
}
return(dataModel);
}
/// <summary>
/// Creates a default data object for the module without adding it to any dataset.
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
static private IModuleDataModel _GetModuleData(IModuleInstance instance)
{
// Remember, the data is orphaned initially!
IModuleDataModel dataModel = null;
if (instance.Descriptor.ModuleDataClass != null)
{
dataModel = ModuleLocalDataSet.CreateModuleDataInstance(instance);
if (dataModel == null)
{
VixenSystem.Logging.Error("Module \"" + instance.Descriptor.TypeName + "\" in " + instance.Descriptor.FileName + " has a reference to type " + instance.Descriptor.ModuleDataClass.Name + " for its module data class, but it's not an implementation of " + typeof(IModuleDataModel).Name + ".");
}
}
return(dataModel);
}
/// <summary>
/// Creates a default data object for the module without adding it to any dataset.
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
private static IModuleDataModel _GetModuleData(IModuleInstance instance)
{
// Remember, the data is orphaned initially!
IModuleDataModel dataModel = null;
if (instance.Descriptor.ModuleDataClass != null)
{
dataModel = ModuleLocalDataSet.CreateModuleDataInstance(instance);
if (dataModel == null)
{
Logging.Error(string.Format("Module \"{0}\" in {1} has a reference to type {2} for its module data class, but it's not an implementation of {3}.", instance.Descriptor.TypeName, instance.Descriptor.FileName, instance.Descriptor.ModuleDataClass.Name, typeof(IModuleDataModel).Name));
}
}
return(dataModel);
}
private void SwapEffectData()
{
List <Element> keys = new List <Element>(_changedElements.Keys);
foreach (var element in keys)
{
EffectModelCandidate modelCandidate =
new EffectModelCandidate(element.EffectNode.Effect)
{
Duration = element.Duration,
StartTime = element.StartTime
};
IModuleDataModel model = _changedElements[element].GetEffectData();
element.EffectNode.Effect.ModuleData = model;
_changedElements[element] = modelCandidate;
element.UpdateNotifyContentChanged();
}
}
private void _Clone(ModuleDataSet source, ModuleDataSet destination)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
// Clone exactly, assuming unchanged type and instance ids for the
// modules the data belongs to.
foreach (IModuleDataModel dataModel in source._dataModels)
{
IModuleDataModel newModel = dataModel.Clone();
destination._Add(newModel, dataModel.ModuleTypeId, dataModel.ModuleInstanceId);
}
}
private ISequenceTypeDataModel _CreateSequenceDataInstance(string fileType)
{
ISequenceTypeModuleInstance sequenceFactory = SequenceTypeService.Instance.CreateSequenceFactory(fileType);
if (sequenceFactory != null)
{
IModuleDataModel sequenceTypeData = ModuleLocalDataSet.CreateModuleDataInstance(sequenceFactory);
if (sequenceTypeData != null && !(sequenceTypeData is ISequenceTypeDataModel))
{
VixenSystem.Logging.Warning("Could not create appropriate sequence data for new sequence due to the object type. File type: " + fileType);
}
else
{
if (sequenceTypeData != null)
{
sequenceTypeData.ModuleTypeId = sequenceFactory.TypeId;
sequenceTypeData.ModuleInstanceId = sequenceFactory.InstanceId;
}
return((ISequenceTypeDataModel)sequenceTypeData);
}
}
return(null);
}
private FilterShape _CreateNewFilterInstanceAndShape(Guid filterTypeId, bool defaultLayout,
IModuleDataModel dataModelToCopy = null)
{
IOutputFilterModuleInstance moduleInstance = ApplicationServices.Get <IOutputFilterModuleInstance>(filterTypeId);
if (dataModelToCopy != null)
{
moduleInstance.ModuleData = dataModelToCopy.Clone();
}
FilterShape shape = _CreateShapeFromFilter(moduleInstance);
VixenSystem.Filters.AddFilter(moduleInstance);
shape.Width = SHAPE_FILTERS_WIDTH;
shape.Height = SHAPE_FILTERS_HEIGHT;
if (defaultLayout)
{
shape.X = (diagramDisplay.Width / 2) - diagramDisplay.GetDiagramPosition().X;
shape.Y = diagramDisplay.GetDiagramOffset().Y + (diagramDisplay.Height / 2);
}
return(shape);
}
private FilterShape _CreateNewFilterInstanceAndShape(Guid filterTypeId, bool defaultLayout,
IModuleDataModel dataModelToCopy = null)
{
IOutputFilterModuleInstance moduleInstance = ApplicationServices.Get<IOutputFilterModuleInstance>(filterTypeId);
if (dataModelToCopy != null) {
moduleInstance.ModuleData = dataModelToCopy.Clone();
}
FilterShape shape = _CreateShapeFromFilter(moduleInstance);
VixenSystem.Filters.AddFilter(moduleInstance);
shape.Width = SHAPE_MAX_WIDTH;
shape.Height = SHAPE_DEFAULT_HEIGHT;
if (defaultLayout) {
shape.X = (diagramDisplay.Width / 2) - diagramDisplay.GetDiagramPosition().X;
shape.Y = diagramDisplay.GetDiagramOffset().Y + (diagramDisplay.Height / 2);
}
return shape;
}
private void _Add(IModuleDataModel dataModel, Guid moduleTypeId, Guid moduleInstanceId)
{
if (dataModel == null) return; // throw new ArgumentNullException("dataModel");
_dataModels.Add(Tuple.Create(moduleTypeId,moduleInstanceId),dataModel);
dataModel.ModuleTypeId = moduleTypeId;
dataModel.ModuleInstanceId = moduleInstanceId;
dataModel.ModuleDataSet = this;
}
private void _AddAsTypeData(IModuleDataModel dataModel, IModuleInstance module)
{
_Add(dataModel, module.Descriptor.TypeId, module.Descriptor.TypeId);
}
private void _AddAsTypeData(IModuleDataModel dataModel, Guid typeId)
{
_Add(dataModel, typeId, typeId);
}
public override IModuleDataModel Clone()
{
IModuleDataModel newInstance = MemberwiseClone() as IModuleDataModel;
return(newInstance);
}
private void _AddAsInstanceData(IModuleDataModel dataModel, IModuleInstance module)
{
_Add(dataModel, module.Descriptor.TypeId, module.InstanceId);
}
private void _AddAsTypeData(IModuleDataModel dataModel, Guid typeId)
{
_Add(dataModel, typeId, typeId);
}
