Example #1
0
 public DynContainer(DataContainer parent)
     : base(parent, "DynCont", "DynContainer")
 {
     IntParam4  = new IntParameter(this, "IntParam4", "IntParam4", 0);
     StrParam5  = new StringParameter(this, "StrParam5", "StrParam5", "def");
     BoolParam6 = new BoolParameter(this, "BoolParam6", "BoolParam6", true);
 }
Example #2
0
            public void Opt(string key, BoolParameter v)
            {
                if (!HasKey(key))
                {
                    return;
                }

                var node = c_[key];

                var o = node as JSONClass;

                if (o == null)
                {
                    v.Value = node.AsBool;
                }
                else
                {
                    v.Value = o["value"].AsBool;

                    if (o.HasKey("parameter"))
                    {
                        v.Name = o["parameter"];
                        v.Register();
                    }
                }
            }
        public void ModificationTest()
        {
            var p = new BoolParameter(null, "myBoolId", "myBoolName");

            p.OnChanged += ParamOnChanged;

            _passedOnChanged = false;
            p.Value          = false;
            Assert.IsFalse(_passedOnChanged, "OnChanged called without a cause");
            Assert.IsFalse(p.IsModified, "IsModified = true but must be false");

            _passedOnChanged = false;
            p.Value          = true;
            Assert.IsTrue(_passedOnChanged, "OnChanged call missing");
            Assert.IsTrue(p.IsModified, "IsModified = false but must be true");

            _passedOnChanged = false;
            p.Value          = false;
            Assert.IsTrue(_passedOnChanged, "OnChanged call missing");
            Assert.IsFalse(p.IsModified, "IsModified = true but must be false");

            p.OnChanged     -= ParamOnChanged;
            _passedOnChanged = false;
            p.Value          = true;
            Assert.IsFalse(_passedOnChanged, "OnChanged not allowed but occurred");
            Assert.IsTrue(p.IsModified, "IsModified = false but must be true");
        }
Example #4
0
    private void Start()
    {
        //Finds PostProcessing layer to apply effect.
        //Must have PostProcessing layer added in order for effect to work properly.
        layerIndex = LayerMask.NameToLayer("PostProcessing");
        camera.GetComponent <PostProcessLayer>().volumeLayer = LayerMask.GetMask("PostProcessing");

        //Creates vignette effect and sets default settings.
        vignette = ScriptableObject.CreateInstance <Vignette>();
        vignette.enabled.Override(false);
        vignette.intensity.Override(0f);

        //Creates color grading effect and sets default settings.
        colorGrading = ScriptableObject.CreateInstance <ColorGrading>();
        colorGrading.enabled.Override(false);

        //Gets settings to use from effect profile provided.
        vColor      = postProfile.GetSetting <Vignette>().color;
        vCenter     = postProfile.GetSetting <Vignette>().center;
        vSmoothness = postProfile.GetSetting <Vignette>().smoothness;
        vRoundness  = postProfile.GetSetting <Vignette>().roundness;
        vRounded    = postProfile.GetSetting <Vignette>().rounded;

        //Sets settings to approprate values.
        vignette.color.Override(vColor);
        vignette.center.Override(vCenter);
        vignette.smoothness.Override(vSmoothness);
        vignette.roundness.Override(vRoundness);
        vignette.rounded.Override(vRounded);

        //Creates volume for effect to be applied.
        volume          = PostProcessManager.instance.QuickVolume(layerIndex, 0, vignette, colorGrading);
        volume.isGlobal = true;
    }
 protected override void Initialize()
 {
     base.Initialize ();
     if(this.Parameter.GetType() != typeof(BoolParameter)) {
         throw new System.ApplicationException("Mismatch Widget and Parameter Type");
     }
     boolParameter = (BoolParameter) this.Parameter;
 }
        public void BufferTest()
        {
            var p = new BoolParameter(null, "myBoolId", "myBoolName");

            p.Value = !p.Value;
            p.ResetModifiedState();
            Assert.AreEqual(p.BufferedValue, p.Value, "BufferedValue not set correctly");
        }
        public async Task <int> GetDelegatesCount(BoolParameter active)
        {
            var sql = new SqlBuilder(@"SELECT COUNT(*) FROM ""Accounts""")
                      .Filter("Type", 1)
                      .Filter("Staked", active);

            using var db = GetConnection();
            return(await db.QueryFirstAsync <int>(sql.Query, sql.Params));
        }
Example #8
0
 protected override void Initialize()
 {
     base.Initialize();
     if (this.Parameter.GetType() != typeof(BoolParameter))
     {
         throw new System.ApplicationException("Mismatch Widget and Parameter Type");
     }
     boolParameter = (BoolParameter)this.Parameter;
 }
        public void ProhibitedValueChangeTest()
        {
            var p = new BoolParameter(null, "myBoolId", "myBoolName");

            CheckProhibitedValueChange(p, true,
                                       param =>
                                       ((BoolParameter)param).Value = false
                                       );
        }
Example #10
0
        public static void Convert(this BIRPRendering.BoolParameter birpSource, BoolParameter target, bool invertValue = false)
        {
            if (target == null)
            {
                return;
            }

            target.value         = invertValue ? !birpSource.value :  birpSource.value;
            target.overrideState = birpSource.overrideState;
        }
Example #11
0
 void Start()
 {
     foreach (BoolParameter parameter in m_animator.BoolParams)
     {
         if (parameter.Name == m_paramName)
         {
             m_parmeter = parameter;
             break;
         }
     }
 }
Example #12
0
 public IControl Build(object item)
 {
     if (item is EditableParameterViewModel <long> intParam && intParam.Parameter.Parameter is BoolParameter boolParameter && BoolParameter != null)
     {
         return(BoolParameter.Build(item));
     }
     if (item is EditableParameterActionViewModel aevm && ButtonParameter != null)
     {
         return(ButtonParameter.Build(item));
     }
     return(Generic?.Build(item) ?? new Panel());
 }
Example #13
0
    /// <summary> Called when a bool parameter is detected. Override to assign to the proper variable. </summary>
    /// count tells how many bool parameters have been identified so far and can be used to identify them.
    protected override void ReceiveBoolParameter(BoolParameter boolParameter, int count)
    {
        switch (count)
        {
        case 1:
            _Clockwise = boolParameter;
            break;

        default:
            break;
        }
    }
Example #14
0
 public override void Setup()
 {
     base.Setup();
     if (_Clockwise == null)
     {
         _Clockwise = new BoolLiteral(Clockwise);
     }
     if (_DegreesPerSecond == null)
     {
         _DegreesPerSecond = new FloatLiteral(DegreesPerSecond);
     }
 }
        public void InitializationTest()
        {
            var p = new BoolParameter(null, "myBoolId", "myBoolName", true);

            Assert.IsNotNull(p, "Parameter object could not be created");

            Assert.AreEqual(p.Id, "myBoolId", "Id not initialized correctly");
            Assert.AreEqual(p.Designation, "myBoolName", "Name not initialized correctly");
            Assert.AreEqual(p.PathId, "myBoolId", "PathId not initialized correctly");
            Assert.AreEqual(p.Value, true, "Value not initialized correctly");
            Assert.AreEqual(p.BufferedValue, true, "BufferedValue not initialized correctly");
            Assert.AreEqual(p.AsString, "True", "AsString not initialized correctly");
        }
Example #16
0
            public void Add(string key, BoolParameter b)
            {
                var o = new J.Object();

                o.Add("value", b.InternalValue);

                if (b.Registered)
                {
                    o.Add("parameter", b.Name);
                }

                c_?.Add(key, o.Impl);
            }
Example #17
0
    static List <Parameter> ParseParameters(JSONArray parametersArray)
    {
        var parameters = new List <Parameter>();

        for (int i = 0; i < parametersArray.Count; i++)
        {
            var parameterJson = parametersArray[i];

            switch (parameterJson["type"])
            {
            case "bool":
                BoolParameter pBool = new BoolParameter();
                pBool.Name             = parameterJson["name"].Value;
                pBool.DisplayName      = parameterJson["displayName"].Value;
                pBool.IntensityDefault = ParseBoolValues(parameterJson["intensityDefault"].AsArray);
                parameters.Add(pBool);
                break;

            case "int":
                IntParameter pInt = new IntParameter();
                pInt.Min              = parameterJson["min"].AsInt;
                pInt.Max              = parameterJson["max"].AsInt;
                pInt.Name             = parameterJson["name"].Value;
                pInt.DisplayName      = parameterJson["displayName"].Value;
                pInt.IntensityDefault = ParseIntValues(parameterJson["intensityDefault"].AsArray);
                parameters.Add(pInt);
                break;

            case "float":
                FloatParameter pFloat = new FloatParameter();
                pFloat.Min              = parameterJson["min"].AsFloat;
                pFloat.Max              = parameterJson["max"].AsFloat;
                pFloat.Name             = parameterJson["name"].Value;
                pFloat.DisplayName      = parameterJson["displayName"].Value;
                pFloat.IntensityDefault = ParseFloatValues(parameterJson["intensityDefault"].AsArray);
                parameters.Add(pFloat);
                break;

            case "choice":
                ChoiceParameter pString = new ChoiceParameter();
                pString.Values           = ParseStringValues(parameterJson["values"].AsArray);
                pString.Name             = parameterJson["name"].Value;
                pString.DisplayName      = parameterJson["displayName"].Value;
                pString.IntensityDefault = ParseIntValues(parameterJson["intensityDefault"].AsArray);
                parameters.Add(pString);
                break;
            }
        }

        return(parameters);
    }
 private void BoolParamView(BoolParameter param, ref bool deleted)
 {
     EditorGUILayout.BeginHorizontal(GUILayout.Width(paramViewWidth));
     EditorGUILayout.LabelField("Name", GUILayout.Width(paramViewWidth - 15));
     if (GUILayout.Button("-", GUILayout.Width(15)))
     {
         animator.RemoveBoolParameter(param);
         deleted = true;
     }
     EditorGUILayout.EndHorizontal();
     param.Name = EditorGUILayout.TextField(param.Name, GUILayout.Width(paramViewWidth));
     EditorGUILayout.LabelField("Value");
     param.Value = EditorGUILayout.Toggle(param.Value, GUILayout.Width(paramViewWidth));
 }
Example #19
0
            public void BoolParameterTest()
            {
                string        testKey   = "test";
                BoolParameter parameter = new BoolParameter();

                parameter[testKey] = true;
                BoolParameter copy = new BoolParameter(parameter);

                Assert.IsTrue(parameter != copy);
                Assert.IsTrue(parameter[testKey] == copy[testKey]);
                copy[testKey] = false;
                Assert.IsTrue(parameter[testKey] != copy[testKey]);
                BoolParameter reference = parameter;

                Assert.IsTrue(parameter == reference);
            }
Example #20
0
 public Cont2(DataContainer parent)
     : base(parent, "Cont2", "Cont2")
 {
     IntParam3  = new IntParameter(this, "IntParam3", "IntParam3", 0);
     StrParam4  = new StringParameter(this, "StrParam4", "StrParam4", "def");
     BoolParam5 = new BoolParameter(this, "BoolParam5", "BoolParam5", true);
     ChParam6   = new ChoiceParameter(this, "ChParam6", "ChParam6", 5,
                                      new List <Tuple <int, string> >
     {
         new Tuple <int, string>(0, "rot"),
         new Tuple <int, string>(5, "gelb"),
         new Tuple <int, string>(10, "grün"),
         new Tuple <int, string>(20, "blau"),
     });
     BinParam7 = new BinaryParameter(this, "BinParam7", "BinParam7", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
 }
Example #21
0
        public async Task <ActionResult <IEnumerable <Models.Delegate> > > Get(
            BoolParameter active,
            Int32Parameter lastActivity,
            SelectParameter select,
            SortParameter sort,
            OffsetParameter offset,
            [Range(0, 10000)] int limit = 100)
        {
            #region validate
            if (sort != null && !sort.Validate("id", "stakingBalance", "balance", "numDelegators", "activationLevel", "deactivationLevel"))
            {
                return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
            }
            #endregion

            if (select == null)
            {
                return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit)));
            }

            if (select.Values != null)
            {
                if (select.Values.Length == 1)
                {
                    return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Values[0])));
                }
                else
                {
                    return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Values)));
                }
            }
            else
            {
                if (select.Fields.Length == 1)
                {
                    return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Fields[0])));
                }
                else
                {
                    return(Ok(new SelectionResponse
                    {
                        Cols = select.Fields,
                        Rows = await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Fields)
                    }));
                }
            }
        }
        /// <summary>
        /// This method will update all the variables binded to the Game Parameter "subject"
        /// </summary>
        /// <param name="subject">Game Parameters inherit Subject class</param>
        public void UpdateRoutine(Subject subject)
        {
            // creating a generic variable egVar and instantiating the correct type
            // the eg types are the same implemented as parameters (string, int, bool, double)
            egVar         var;
            GameParameter gp = (GameParameter)subject;

            if (subject.GetType() == typeof(IntParameter))
            {
                IntParameter iP = (IntParameter)subject;
                egInt        i  = iP.Value;
                var = i;
            }
            else if (subject.GetType() == typeof(BoolParameter))
            {
                BoolParameter bP = (BoolParameter)subject;
                egBool        b  = bP.Value;
                var = b;
            }
            else if (subject.GetType() == typeof(StringListParameter))
            {
                StringListParameter sP = (StringListParameter)subject;
                egString            s  = sP.Value;
                var = s;
            }
            else if (subject.GetType() == typeof(StringParameter))
            {
                StringParameter sP = (StringParameter)subject;
                egString        s  = sP.Value;
                Debug.Log((string)s + " variable Handler test");
                var = s;
            }
            else if (subject.GetType() == typeof(RangeParameter))
            {
                RangeParameter fP = (RangeParameter)subject;
                egFloat        s  = fP.Value;
                var = s;
            }
            else
            {
                // if the type is not registered something went wrong
                Debug.Log("ERROR, type: " + subject.GetType() + " not defined as a parameter type. Check parameter types.");
                return;
            }
            //then we will update the variables
            UpdateVariables(var, gp.Name);
        }
Example #23
0
                /// <summary>
                /// Initializes all states for one side.
                /// </summary>
                /// <param name="suffix">The anim name suffix for this side.</param>
                /// <param name="isTraversing">The parameter controlling if a Duplicant is traversing this side.</param>
                /// <param name="vacuum">The state to go to when finished.</param>
                /// <param name="offset">The cell offset to sample for pressure averaging.</param>
                internal void ConfigureStates(string suffix, BoolParameter isTraversing,
                                              State vacuum, CellOffset offset)
                {
                    string open = "static" + suffix;

                    ConfigureOpeningState(suffix, enter).
                    Enter("RemoveEnergy", (smi) => {
                        smi.WithdrawEnergy();
                        Game.Instance.userMenu.Refresh(smi.master.gameObject);
                    }).OnAnimQueueComplete(waitEnter).
                    Exit((smi) => smi.ResetPressure());
                    waitEnter.PlayAnim(open).
                    Enter("UpdateWorldState", (smi) => {
                        smi.master.UpdateWorldState();
                        smi.CheckDuplicantStatus();
                    }).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    ParamTransition(isTraversing, waitEnterClose, IsFalse);
                    waitEnterClose.PlayAnim(open).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    ScheduleGoTo(EXIT_DELAY, closing).
                    ParamTransition(isTraversing, waitEnter, IsTrue);
                    ConfigureClosingState(suffix, closing).
                    Enter("UpdateWorldState", UpdateWorldState).
                    ParamTransition(isTraversing, waitEnter, IsTrue).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    OnAnimQueueComplete(vacuum);
                    ConfigureOpeningState(suffix, exit).
                    Exit((smi) => smi.ResetPressure()).
                    OnAnimQueueComplete(waitExit);
                    waitExit.PlayAnim(open).
                    Enter("UpdateWorldState", (smi) => {
                        smi.master.UpdateWorldState();
                        smi.CheckDuplicantStatus();
                    }).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    ParamTransition(isTraversing, waitExitClose, IsFalse);
                    waitExitClose.PlayAnim(open).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    ScheduleGoTo(EXIT_DELAY, closing).
                    ParamTransition(isTraversing, waitExit, IsTrue);
                    ConfigureClosingState(suffix, clearing).
                    Enter("UpdateWorldState", UpdateWorldState).
                    ParamTransition(isTraversing, waitExit, IsTrue).
                    Update("CheckIsBlocked", (smi, _) => smi.CheckAndAverage(offset), UpdateRate.SIM_200ms).
                    OnAnimQueueComplete(vacuum);
                }
Example #24
0
        internal bool Compare(CalculatorCondition.Type type, int parameterIndex, CompareType compareType)
        {
            switch (type)
            {
            case CalculatorCondition.Type.Int:
                IntParameter intParameter = _IntParameters[parameterIndex];
                return(intParameter.Compare(compareType));

            case CalculatorCondition.Type.Float:
                FloatParameter floatParameter = _FloatParameters[parameterIndex];
                return(floatParameter.Compare(compareType));

            case CalculatorCondition.Type.Bool:
                BoolParameter boolParameter = _BoolParameters[parameterIndex];
                return(boolParameter.Compare());
            }

            return(false);
        }
 public async Task <IEnumerable <Models.Delegate> > GetDelegates(
     BoolParameter active,
     Int32Parameter lastActivity,
     SortParameter sort,
     OffsetParameter offset,
     int limit)
 {
     var sql = new SqlBuilder($@"SELECT *, {AliasQuery} FROM ""Accounts""")
               .Filter("Type", 1)
               .Filter("Staked", active)
               .Filter("LastLevel", lastActivity)
               .Take(sort, offset, limit, x => x switch
     {
         "activationLevel" => ("ActivationLevel", "ActivationLevel"),
         "deactivationLevel" => ("DeactivationLevel", "DeactivationLevel"),
         "stakingBalance" => ("StakingBalance", "StakingBalance"),
         "balance" => ("Balance", "Balance"),
         "numDelegators" => ("DelegatorsCount", "DelegatorsCount"),
         _ => ("Id", "Id")
     });
Example #26
0
        public void ImportLegacy(List <CalculatorConditionLegacy> legacyList)
        {
            foreach (var legacy in legacyList)
            {
                var condition = new CalculatorCondition(legacy._Type);
                condition._CompareType = legacy._CompareType;

                CalculatorCondition.Type type = condition._Type;

                switch (type)
                {
                case CalculatorCondition.Type.Int:
                    IntParameter intParameter = new IntParameter();
                    intParameter.value1 = legacy._IntValue1;
                    intParameter.value2 = legacy._IntValue2;
                    _IntParameters.Add(intParameter);
                    condition._ParameterIndex = _IntParameters.Count - 1;
                    break;

                case CalculatorCondition.Type.Float:
                    FloatParameter floatParameter = new FloatParameter();
                    floatParameter.value1 = legacy._FloatValue1;
                    floatParameter.value2 = legacy._FloatValue2;
                    _FloatParameters.Add(floatParameter);
                    condition._ParameterIndex = _FloatParameters.Count - 1;
                    break;

                case CalculatorCondition.Type.Bool:
                    BoolParameter boolParameter = new BoolParameter();
                    boolParameter.value1 = legacy._BoolValue1;
                    boolParameter.value2 = legacy._BoolValue2;
                    _BoolParameters.Add(boolParameter);
                    condition._ParameterIndex = _BoolParameters.Count - 1;
                    break;
                }

                condition.owner = this;

                _Conditions.Add(condition);
            }
        }
 public IControl Build(object item)
 {
     if (item is EditableParameterViewModel <long> intParam)
     {
         if (intParam.Parameter.Parameter is BoolParameter && BoolParameter != null)
         {
             return(BoolParameter.Build(item));
         }
         if (intParam.Parameter.Parameter is FlagParameter && FlagParameter != null)
         {
             return(FlagParameter.Build(item));
         }
         if (intParam.UseModernPicker && ItemsParameter != null)
         {
             return(ItemsParameter.Build(item));
         }
     }
     else if (item is EditableParameterActionViewModel aevm && ButtonParameter != null)
     {
         return(ButtonParameter.Build(item));
     }
     return(Generic?.Build(item) ?? new Panel());
 }
Example #28
0
        public Task <int> GetCount(
            AccountTypeParameter type,
            ContractKindParameter kind,
            Int64Parameter balance,
            BoolParameter staked)
        {
            #region optimize
            if (type == null && kind == null && balance == null && staked == null)
            {
                return(Task.FromResult(State.Current.AccountsCount));
            }

            if (kind?.Eq != null && type == null)
            {
                type = new AccountTypeParameter {
                    Eq = 2
                }
            }
            ;
            #endregion

            return(Accounts.GetCount(type, kind, balance, staked));
        }
Example #29
0
 public static void GetParameterType(BoolParameter obj, MethodReturnEventArgs<Type> e)
 {
     e.Result = typeof(bool);
     BaseParameterActions.DecorateParameterType(obj, e, true);
 }
Example #30
0
 public Task <int> GetCount(BoolParameter active)
 {
     return(Accounts.GetDelegatesCount(active));
 }
        void DrawPropertyField(SerializedDataParameter property, MemberInfo field, bool indent)
        {
            if (indent)
            {
                EditorGUI.indentLevel++;
            }

            var displayName = property.displayName;

            if (field.GetCustomAttribute(typeof(Beautify.DisplayName)) is Beautify.DisplayName displayNameAttrib)
            {
                displayName = displayNameAttrib.name;
            }

            if (property.value.propertyType == SerializedPropertyType.Boolean)
            {
                if (field.GetCustomAttribute(typeof(Beautify.GlobalOverride)) != null)
                {
                    BoolParameter pr   = property.GetObjectRef <BoolParameter>();
                    bool          prev = pr.value;

                    using (new EditorGUILayout.HorizontalScope()) {
                        var overrideRect = GUILayoutUtility.GetRect(17f, 17f, GUILayout.ExpandWidth(false));
                        overrideRect.yMin += 4f;
                        bool value = GUI.Toggle(overrideRect, prev, GUIContent.none);

                        string tooltip = null;
                        if (field.GetCustomAttribute(typeof(TooltipAttribute)) is TooltipAttribute tooltipAttribute)
                        {
                            tooltip = tooltipAttribute.tooltip;
                        }

                        using (new EditorGUI.DisabledScope(!prev)) {
                            EditorGUILayout.LabelField(new GUIContent(displayName, tooltip));
                        }

                        if (value != prev)
                        {
                            pr.value = value;
                            SerializedProperty prop = serializedObject.FindProperty(field.Name);
                            if (prop != null)
                            {
                                var boolProp = prop.FindPropertyRelative("m_Value");
                                if (boolProp != null)
                                {
                                    boolProp.boolValue = value;
                                }
                                if (value)
                                {
                                    var overrideProp = prop.FindPropertyRelative("m_OverrideState");
                                    if (overrideProp != null)
                                    {
                                        overrideProp.boolValue = true;
                                    }
                                }
                            }
                            if (field.GetCustomAttribute(typeof(Beautify.BuildToggle)) != null)
                            {
                                SetStripShaderKeywords();
                            }
                        }
                    }
                }
                else
                {
                    PropertyField(property, new GUIContent(displayName));
                }
            }
            else
            {
                PropertyField(property, new GUIContent(displayName));
            }

            if (indent)
            {
                EditorGUI.indentLevel--;
            }
        }
 public void Bool_Parameter_Type()
 {
     string expectedResult = typeof(Boolean).ToString();
     BoolParameter testParameter = new BoolParameter();
     Assert.AreEqual(expectedResult, testParameter.Type.ToString());
 }
 public void BoolParameter_Text()
 {
     string expectedResult = "FALSE";
     BoolParameter testParameter = new BoolParameter();
     Assert.AreEqual(expectedResult, testParameter.Text.ToUpper());
 }
 public void BoolParameter_Value()
 {
     BoolParameter testParameter = new BoolParameter();
     Assert.IsFalse(testParameter.Value);
 }
 public void BoolParameter_1()
 {
     string testValue = "1";
     BoolParameter testParameter = new BoolParameter();
     testParameter.Text = testValue;
     Assert.IsTrue(testParameter.Value);
     Assert.IsFalse(testParameter.HasErrors);
 }
    private void DrawCustomParameters()
    {
        GUILayout.BeginArea(new Rect(scroll.x, scroll.y + position.height - 500, 200, 500));
        GUILayout.FlexibleSpace();
        bool state = EditorPrefs.GetBool("Parameters", false);

        Rect rect  = GUILayoutUtility.GetRect(new GUIContent("Parameters"), "flow overlay header lower left", GUILayout.ExpandWidth(true));
        Rect rect2 = new Rect(rect.x + 175, rect.y + 2, 25, 25);

        if (GUI.Button(rect2, "", "label"))
        {
            GenericMenu        genericMenu = new GenericMenu();
            IEnumerable <Type> types       = AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes()).Where(type => type.IsSubclassOf(typeof(NamedParameter)));
            foreach (Type type in types)
            {
                genericMenu.AddItem(new GUIContent(type.ToString().Split('.').Last().Replace("Parameter", "")), false, new GenericMenu.MenuFunction2(this.OnCreateParameter), type);
            }
            genericMenu.ShowAsContext();
        }

        if (GUI.Button(rect, "Parameters", "flow overlay header lower left"))
        {
            EditorPrefs.SetBool("Parameters", !state);
        }

        GUI.Label(rect2, iconToolbarPlus);

        if (state)
        {
            EditorGUIUtility.labelWidth = 80;
            GUILayout.BeginVertical((GUIStyle)"PopupCurveSwatchBackground", GUILayout.Width(199));
            int deleteIndex = -1;
            if (controller.parameters.Count > 0)
            {
                for (int i = 0; i < controller.parameters.Count; i++)
                {
                    NamedParameter parameter = controller.parameters[i];
                    GUILayout.BeginHorizontal();
                    parameter.Name = EditorGUILayout.TextField(parameter.Name);
                    if (parameter.GetType() == typeof(BoolParameter))
                    {
                        GUILayout.FlexibleSpace();
                        BoolParameter boolParam = parameter as BoolParameter;
                        boolParam.Value = EditorGUILayout.Toggle(boolParam.Value, GUILayout.Width(14));
                    }
                    else if (parameter.GetType() == typeof(TagParameter))
                    {
                        TagParameter tagParam = parameter as TagParameter;
                        tagParam.Value = EditorGUILayout.TagField(tagParam.Value, GUILayout.Width(80));
                    }
                    else
                    {
                        SerializedObject paramObject = new SerializedObject(parameter);
                        paramObject.Update();
                        EditorGUILayout.PropertyField(paramObject.FindProperty("value"), GUIContent.none, GUILayout.Width(80));
                        paramObject.ApplyModifiedProperties();
                    }
                    GUILayout.FlexibleSpace();
                    if (GUILayout.Button(iconToolbarMinus, "label"))
                    {
                        deleteIndex = i;
                    }
                    GUILayout.EndHorizontal();
                }
            }
            else
            {
                GUILayout.Label("List is Empty");
            }
            if (deleteIndex != -1)
            {
                DestroyImmediate(controller.parameters[deleteIndex], true);
                controller.parameters.RemoveAt(deleteIndex);
                AssetDatabase.SaveAssets();
            }
            GUILayout.EndVertical();
        }
        GUILayout.EndArea();
    }
Example #37
0
 public static void GetParameterTypeString(BoolParameter obj, MethodReturnEventArgs<string> e)
 {
     e.Result = "bool";
     BaseParameterActions.DecorateParameterType(obj, e, true);
 }