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)); }