private static void CheckSettingValue(EnumParameter p, Guid initialValue, Guid setValue, IEnumeration enumeration)
{
Assert.That(p.Value, Is.EqualTo(initialValue));
Assert.That(p.SetValueAction(initialValue), Is.Null);
var action = p.SetValueAction(setValue);
Assert.That(action, Is.Not.Null);
CheckNotCorrupt(p, initialValue, enumeration);
action.Value.Redo();
CheckNotCorrupt(p, setValue, enumeration);
action.Value.Undo();
CheckNotCorrupt(p, initialValue, enumeration);
p.TryDeserialiseValue("asd");
CheckCorrupt(p, "asd");
//Test what happens if we undo back to an invalid state
var actions = p.SetValueAction(setValue);
actions.Value.Redo();
CheckNotCorrupt(p, setValue, enumeration);
actions.Value.Undo();
CheckCorrupt(p, "asd");
p.TryDeserialiseValue(setValue.ToString());
CheckNotCorrupt(p, setValue, enumeration);
}
public static ParameterBase[] GetParameters(ParsingData parser, ParameterDefineNode[] defineNodes)
{
ParameterBase[] parameters = new ParameterBase[defineNodes.Length];
for (int i = 0; i < parameters.Length; i++)
{
EnumData enumData = null;
DefinedType type = null;
if (defineNodes[i].Type != null)
{
enumData = EnumData.GetEnum(defineNodes[i].Type);
type = parser.GetDefinedType(defineNodes[i].Type, null);
if (enumData == null && type == null)
{
throw SyntaxErrorException.NonexistentType(defineNodes[i].Type, defineNodes[i].Location);
}
}
if (enumData != null)
{
parameters[i] = new EnumParameter(defineNodes[i].VariableName, enumData.Type);
}
else if (type != null)
{
parameters[i] = new TypeParameter(defineNodes[i].VariableName, type);
}
else
{
parameters[i] = new Parameter(defineNodes[i].VariableName, Elements.ValueType.Any, null);
}
}
return(parameters);
}
public static void GetParameterType(EnumParameter obj, MethodReturnEventArgs <Type> e)
{
var cls = obj.Enumeration;
e.Result = Type.GetType(cls.Module.Namespace + "." + cls.Name + ", " + Zetbox.API.Helper.InterfaceAssembly, true);
BaseParameterActions.DecorateParameterType(obj, e, true);
}
private static void CheckNotCorrupt(EnumParameter p, Guid value, IEnumeration enumeration)
{
Assert.That(p.Corrupted, Is.False);
Assert.That(p.DisplayValue((a, b) => ""), Is.EqualTo(enumeration.GetName(value)));
Assert.That(p.Value, Is.EqualTo(value));
Assert.That(Guid.TryParse(p.ValueAsString(), out Guid guid), Is.True);
Assert.That(guid, Is.EqualTo(p.Value));
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
Power = new EnumParameter <EPowerStatus>(parameterPrefix + "Clip", "Clip", "Clip", false);
return(new List <Parameter> {
Power
});
}
/// <summary>
/// Determines whether [is report type parameter visible] [the specified report type id].
/// </summary>
/// <param name="ReportTypeId">The report type id.</param>
/// <param name="parameterEnum">The parameter enum.</param>
/// <returns>
/// <c>true</c> if [is report type parameter visible] [the specified report type id]; otherwise, <c>false</c>.
/// </returns>
public bool IsReportTypeParameterVisible(
int ReportTypeId,
EnumParameter parameterEnum)
{
var parameter = this.FindParameter(parameterEnum);
return this._genericDao.FindAll<GRP.BusinessLayer.Automation.Entities.ReportTypeParameter>(entity =>
entity.ReportTypeId == ReportTypeId &&
entity.ParameterId == parameter.ParameterId).Any();
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
Power = new EnumParameter <EPowerStatus>(parameterPrefix + "Pwr", "Power", "", false);
Step = new IntegerParameter(parameterPrefix + "Stp", "Oscillograph Step", "Step", 1, 10, 1, false);
return(new List <Parameter> {
Power, Step
});
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
Power = new EnumParameter <EPowerStatus>(parameterPrefix + "Pwr", "Power", "", false);
Treshold = new RealParameter(parameterPrefix + "Trshd", "Treshold", "Trshd", 0.1, 1, 0.01);
return(new List <Parameter> {
Power, Treshold
});
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
FilterType = new EnumParameter <EFilterPass>(parameterPrefix + "Pass", "Filter Type", "Filter", false);
CutoffFrequency = new FrequencyParameter(parameterPrefix + "Cutoff", "Filter Cutoff Frequency", "Cutoff");
return(new List <Parameter> {
FilterType, CutoffFrequency
});
}
/// <summary>
/// Enums to name.
/// </summary>
/// <param name="e">The e.</param>
/// <returns></returns>
public string EnumToName(EnumParameter e)
{
string result = null;
if (!this._enumToNameMap.TryGetValue(e, out result))
{
throw new Exception(string.Format("Parameter enum not mapped: {0}", e.ToString()));
}
return result;
}
/// <summary>
/// Returns the MS type of osc (zero based) and zone (zero based). If OSC Mode is drum kit, MS type is ignored.
/// </summary>
/// <param name="osc"></param>
/// <param name="zone"></param>
/// <returns></returns>
private string GetMsType(int osc, int zone)
{
var parameter = new EnumParameter();
parameter.Set(Root, Root.Content, ByteOffset + 2774 + osc * (3240 - 2774) + zone * (2796 - 2774), 1, 0,
new List <string> {
"Off", "MS", "Wave Sequence"
}, this);
return(parameter.Value);
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
FilterType = new EnumParameter <EFilterPass>(parameterPrefix + "Pass", "Filter Type", "Filter", false);
CutoffFrequency = new RealParameter(parameterPrefix + "Cutoff", "Filter Cutoff Frequency", "Cutoff", 0.0, 0.99, 0.01);
Resonance = new RealParameter(parameterPrefix + "Res", "Filter Resonance", "Resonance", 0.0, 1.0, 0.01);
EnvAmount = new RealParameter(parameterPrefix + "Amnt", "Envelope Amount", "%", 0.01, 0.99, 0.01, false);
return(new List <Parameter> {
FilterType, CutoffFrequency, Resonance, EnvAmount
});
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
Power = new EnumParameter <EPowerStatus>(parameterPrefix + "Pwr", "Power", "", false);
DryLevel = new RealParameter(parameterPrefix + "Dry", "Dry Level", "Dry", 0, 1, 0.01);
Time = new RealParameter(parameterPrefix + "Sec", "Delay Time", "Time", 0, 5, 0.01);
Feedback = new RealParameter(parameterPrefix + "Fbck", "Feedback", "Feedback", 0, 1, 0.01);
return(new List <Parameter> {
Power, DryLevel, Time, Feedback
});
}
public static void TestGetName()
{
string name = "enumname";
Id <Parameter> id = Id <Parameter> .Parse("3CD0C596-F145-4A03-B483-590BB6EEE5C4");
EnumParameter p = new EnumParameter(name, id, MockEnumeration1.Instance, MockEnumeration1.Instance.Options.ElementAt(1).ToString());
foreach (var option in MockEnumeration1.Instance.Options)
{
Assert.That(p.GetName(option), Is.EqualTo(MockEnumeration1.Instance.GetName(option)));
}
}
public NodeRendererCustomization(IDataSource datasource, MapConfig <Id <NodeTypeTemp>, Guid> typeMapConfig, IEnumerable <NodeUI.IFactory> allRenderers)
{
m_typeMapConfig = typeMapConfig;
m_parameters = new List <Parameter>();
foreach (var type in datasource.AllNodes())
{
var options = allRenderers.Where(e => e.WillRender(type.Guid)).Select(e => Tuple.Create(e.Guid, e.DisplayName)).ToList();
Guid def = m_typeMapConfig[type.Guid];
var enumeration = new ImmutableEnumeration(options, ParameterType.Basic.ConvertFrom(type.Guid), def);
var p = new EnumParameter(type.Name, Id <Parameter> .ConvertFrom(type.Guid), enumeration, def.ToString());
m_parameters.Add(p);
}
}
public ParameterEditorCustomization(IDataSource datasource, MapConfig <ParameterType, Guid> typeMapConfig, IEnumerable <IParameterEditorFactory> allEditors)
{
m_typeMapConfig = typeMapConfig;
m_parameters = new List <Parameter>();
foreach (var type in datasource.ParameterTypes)
{
var options = allEditors.Where(e => e.WillEdit(type, WillEdit.Create(datasource))).Select(e => Tuple.Create(e.Guid, e.Name)).ToList();
Guid def = m_typeMapConfig[type];
var enumeration = new ImmutableEnumeration(options, type, def);
var p = new EnumParameter(datasource.GetTypeName(type), Id <Parameter> .ConvertFrom(type), enumeration, def.ToString());
m_parameters.Add(p);
}
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
OscillatorType = new EnumParameter <EOscillatorType>(parameterPrefix + "Osc", "LFO Type", "Osc", false);
Frequency = new FrequencyParameter(parameterPrefix + "Frq", "LFO Frequency", "Frq", 0.01, 1000);
MatchKey = new BooleanParameter(parameterPrefix + "Mtch", "LFO Phase Key Link", "Match", false);
Gain = new RealParameter(parameterPrefix + "Gain", "LFO Gain", "Gain", 0, 1, 0.01, false);
TargetParameter = new ParameterName(parameterPrefix, Processor.PluginController.ParametersManager);
TargetParameter.OnValueChange += TargetParameterNumberOnValueChange;
return(new List <Parameter> {
OscillatorType, Frequency, MatchKey, Gain, TargetParameter
});
}
public override IEnumerable <Parameter> CreateParameters(string parameterPrefix)
{
Volume = new VolumeParameter(parameterPrefix + "Vol", "Oscillator Volume");
OscillatorType = new EnumParameter <WaveGenerator.EOscillatorType>(parameterPrefix + "Osc", "Oscillator Type", "Osc", false);
Fine = new RealParameter(parameterPrefix + "Fine", "Oscillator pitch", "Fine", -2, 2, 0.01);
Fine.SetDefaultValue(0);
Panning = new RealParameter(parameterPrefix + "Pan", "Oscillator Panorama", "", 0, 1, 0.01);
Panning.SetDefaultValue(0.5);
return(new List <Parameter> {
Volume, OscillatorType, Fine, Panning
});
}
public static void GetParameterTypeString(EnumParameter obj, MethodReturnEventArgs<System.String> e)
{
if (obj.Enumeration == null)
{
e.Result = "<no enum>";
}
else if (obj.Enumeration.Module == null)
{
e.Result = "<no namespace>." + obj.Enumeration.Name;
}
else
{
e.Result = obj.Enumeration.Module.Namespace + "." + obj.Enumeration.Name;
}
BaseParameterActions.DecorateParameterType(obj, e, true);
}
public static void TestNullEnumGuidDefault()
{
string name = "enumname2";
Id <Parameter> id = Id <Parameter> .Parse("6DB8D873-9DA3-412F-9164-322AFDE2895E");
EnumParameter p = new EnumParameter(name, id, MockEnumeration1.Instance, null);
var def = MockEnumeration1.Instance.DefaultValue.Transformed(a => { throw new InvalidOperationException(); }, b => b);
CheckNotCorrupt(p, def, MockEnumeration1.Instance);
Guid initialValue = def;
var setValue = MockEnumeration1.Instance.Options.ElementAt(3);
CheckSettingValue(p, initialValue, setValue, MockEnumeration1.Instance);
}
public static void GetParameterTypeString(EnumParameter obj, MethodReturnEventArgs <System.String> e)
{
if (obj.Enumeration == null)
{
e.Result = "<no enum>";
}
else if (obj.Enumeration.Module == null)
{
e.Result = "<no namespace>." + obj.Enumeration.Name;
}
else
{
e.Result = obj.Enumeration.Module.Namespace + "." + obj.Enumeration.Name;
}
BaseParameterActions.DecorateParameterType(obj, e, true);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private IParameter GetHeatTransferModeParameter()
{
IParameter p = this.GeneralGroup.Parameters[PN_HEATTRANSFERMODE];
if (p == null)
{
p = new EnumParameter(
PN_HEATTRANSFERMODE,
typeof(ModeValue),
ModeValue.Mixed,
PO_HEATTRANSFERMODE);
p.Text = "»»ÈÈ·½Ê½";
this.GeneralGroup.Parameters.Add(p);
}
return(p);
}
public static void TestNullEnumStringDefault()
{
string name = "enumname2";
Id <Parameter> id = Id <Parameter> .Parse("6DB8D873-9DA3-412F-9164-322AFDE2895E");
EnumParameter p = new EnumParameter(name, id, MockEnumeration2.Instance, null);
var def = MockEnumeration2.Instance.DefaultValue.Transformed(b => b, a => { throw new InvalidOperationException(); });
CheckCorrupt(p, def);
Guid initialValue = MockEnumeration2.Instance.Options.ElementAt(0);
p.SetValueAction(initialValue).Value.Redo();
var setValue = MockEnumeration2.Instance.Options.ElementAt(1);
CheckSettingValue(p, initialValue, setValue, MockEnumeration2.Instance);
}
public static void TestGuidDefault()
{
string name = "enumname";
Id <Parameter> id = Id <Parameter> .Parse("3CD0C596-F145-4A03-B483-590BB6EEE5C4");
EnumParameter p = new EnumParameter(name, id, MockEnumeration1.Instance, MockEnumeration1.Instance.Options.ElementAt(1).ToString());
Assert.That(p.Id, Is.EqualTo(id));
Assert.That(p.Name, Is.EqualTo(name));
Assert.That(p.TypeId, Is.EqualTo(MockEnumeration1.Instance.TypeId));
Assert.That(p.Options, Is.EquivalentTo(MockEnumeration1.Instance.Options));
CheckNotCorrupt(p, MockEnumeration1.Instance.Options.ElementAt(1), MockEnumeration1.Instance);
var initialValue = MockEnumeration1.Instance.Options.ElementAt(1);
var setValue = MockEnumeration1.Instance.Options.ElementAt(0);
CheckSettingValue(p, initialValue, setValue, MockEnumeration1.Instance);
}
public override IEnumerable <Parameter> CreateParameters()
{
var parameters = new List <Parameter>();
parameters.Add(Power = new BypassParameter("CPwr", "Power", this, "Pwr", false));
parameters.Add(OscillatorsMix = new RealParameter("CMix", "Oscillators Mix", "Mix", 0, 1, 0.01));
parameters.Add(MasterVolume = new VolumeParameter("MVol", "Master Volume", false));
parameters.Add(Unison = new EnumParameter <EPowerStatus>("UPwr", "Unison", "Pwr", false));
OscillatorsMix.SetDefaultValue(0.5);
parameters.AddRange(OscillatorA.CreateParameters("A"));
parameters.AddRange(OscillatorB.CreateParameters("B"));
parameters.AddRange(EnvelopeSound.CreateParameters("EM"));
parameters.AddRange(FilterEnv.CreateParameters("EF"));
parameters.AddRange(Filter.CreateParameters("F"));
parameters.AddRange(Distortion.CreateParameters("D"));
parameters.AddRange(LFOModifierA.CreateParameters("LA"));
parameters.AddRange(LFOModifierB.CreateParameters("LB"));
return(parameters);
}
public static void TestStringDefault()
{
string name = "enumname2";
Id <Parameter> id = Id <Parameter> .Parse("6DB8D873-9DA3-412F-9164-322AFDE2895E");
EnumParameter p = new EnumParameter(name, id, MockEnumeration2.Instance, "AStringDefault");
Assert.That(p.Id, Is.EqualTo(id));
Assert.That(p.Name, Is.EqualTo(name));
Assert.That(p.TypeId, Is.EqualTo(MockEnumeration2.Instance.TypeId));
Assert.That(p.Options, Is.EquivalentTo(MockEnumeration2.Instance.Options));
CheckCorrupt(p, "AStringDefault");
var initialValue = MockEnumeration2.Instance.Options.ElementAt(0);
p.SetValueAction(initialValue).Value.Redo();
var setValue = MockEnumeration2.Instance.Options.ElementAt(1);
CheckSettingValue(p, initialValue, setValue, MockEnumeration2.Instance);
}
/// <summary>
/// Finds the parameter.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <returns></returns>
private GRP.BusinessLayer.Automation.Entities.Parameter FindParameter(EnumParameter parameter)
{
return this._genericDao.Find<GRP.BusinessLayer.Automation.Entities.Parameter>(a =>
a.Name == new EnumParameterHelper().EnumToName(parameter));
}
public static void GetParameterType(EnumParameter obj, MethodReturnEventArgs<Type> e)
{
var cls = obj.Enumeration;
e.Result = Type.GetType(cls.Module.Namespace + "." + cls.Name + ", " + Zetbox.API.Helper.InterfaceAssembly, true);
BaseParameterActions.DecorateParameterType(obj, e, true);
}
public GraphData(Id <NodeTemp> nodeId, Id <NodeTypeTemp> nodeTypeId, IEnumerable <NodeDataGeneratorParameterData> parameterData)
{
NodeId = nodeId;
NodeTypeId = nodeTypeId;
var allConnectorsDefinition = new ConnectorDefinitionData(null, null, null, null, false);
var outputs = new List <Output>();
var parameters = new List <IParameter>();
DecimalParameter.Definition d = new DecimalParameter.Definition(null, null);
ParameterType decimalType = ParameterType.Basic.Parse("721796b6-a242-4723-82e9-35201097e675");
ParameterType dynamicEnumType = ParameterType.Basic.Parse("6d2d52c8-5934-4ba8-8d4e-7081fe57f662");
DynamicEnumParameter.Source source = new DynamicEnumParameter.Source();
IEnumeration enumeration = new DummyEnumeration();
ParameterType integerEnumType = ParameterType.Basic.Parse("de108fdb-db50-4cd5-aad5-0ea791f04721");
IntegerParameter.Definition i = new IntegerParameter.Definition(null, null);
AudioParameter = new AudioParameter("Audio", Id <Parameter> .Parse("3ac8d0ca-c9f6-4e06-b18c-c1366e1af7d3"));
BooleanParameter = new BooleanParameter("Boolean", Id <Parameter> .Parse("0e12e8e3-4c95-43a5-a733-d2d1fbbb780c"), "false");
DecimalParameter = new DecimalParameter("Decimal", Id <Parameter> .Parse("765e616a-f165-4053-a15c-14ed593429af"), decimalType, d, "1.0");
DynamicEnumParameter = new DynamicEnumParameter("DynamicEnum", Id <Parameter> .Parse("7c5b019c-79d0-4ef0-b848-0a2c68908f34"), source, dynamicEnumType, "shnae", false);
EnumParameter = new EnumParameter("Enum", Id <Parameter> .Parse("e576713b-5d45-48d0-8a4e-661f1fedcafd"), enumeration, enumeration.DefaultValue.ToString());
IntegerParameter = new IntegerParameter("Int", Id <Parameter> .Parse("275d75f3-fe4e-42b1-bfaf-e841ba591999"), integerEnumType, i, "1");
LocalizedStringParameter = new LocalizedStringParameter("Localized stirng", Id <Parameter> .Parse("f332e619-e9a3-421f-9851-d95a00b62da9"), ParameterType.Basic.Parse("4547dbf2-46cc-4c84-ac6e-81ab185575dc"));
SetParameter = new SetParameter("Set", Id <Parameter> .Parse("2d6235ea-c8a1-447a-b9d8-692f6329be33"), enumeration, null);
StringParameter = new StringParameter("string", Id <Parameter> .Parse("4752d30e-e1ab-47ba-bc15-b2e6ecfa5416"));
StringParameter2 = new StringParameter("string2", Id <Parameter> .Parse("dcd4a349-b0a8-4fa3-8989-2d10469b1a17"));
if (nodeTypeId == TYPE1)
{
outputs.Add(new Output(Id <TConnector> .Parse("0956c9d3-c230-49a2-874a-7e3747b58cff"), allConnectorsDefinition, this, null, DummyRules.Instance));
parameters.Add(AudioParameter);
parameters.Add(BooleanParameter);
parameters.Add(DecimalParameter);
parameters.Add(DynamicEnumParameter);
parameters.Add(EnumParameter);
}
else if (nodeTypeId == TYPE2)
{
outputs.Add(new Output(Id <TConnector> .Parse("da2b4ded-378e-4484-89f0-1328a42f00e3"), allConnectorsDefinition, this, null, DummyRules.Instance));
outputs.Add(new Output(Id <TConnector> .Parse("2bf2ca93-6b81-4a9a-814f-809a8bef332f"), allConnectorsDefinition, this, null, DummyRules.Instance));
parameters.Add(IntegerParameter);
parameters.Add(LocalizedStringParameter);
parameters.Add(SetParameter);
parameters.Add(StringParameter);
}
else if (nodeTypeId == TYPE3)
{
outputs.Add(new Output(Id <TConnector> .Parse("c3f67c87-a3fd-428d-90a2-90cb87906eb2"), allConnectorsDefinition, this, null, DummyRules.Instance));
parameters.Add(StringParameter);
parameters.Add(StringParameter2);
}
else
{
Assert.Fail("Unexpected Id");
}
if (parameterData != null)
{
foreach (var data in parameterData)
{
parameters.Where(p => p.Id == data.Guid).Single().TryDeserialiseValue(data.Value);
}
}
Connectors = outputs;
Parameters = parameters;
}
private static void CheckCorrupt(EnumParameter p, string value)
{
Assert.That(p.Corrupted, Is.True);
Assert.That(p.DisplayValue((a, b) => ""), Is.EqualTo(value));
Assert.That(p.ValueAsString(), Is.EqualTo(value));
}
