public override void Enable() { base.Enable(); var node = nodeTarget as RandomRangeNode; var min = new FloatField("Min") { value = node.min }; min.RegisterValueChangedCallback(e => { owner.RegisterCompleteObjectUndo("Updated Min " + e.newValue); node.min = e.newValue; NotifyNodeChanged(); }); var max = new FloatField("Max") { value = node.max }; max.RegisterValueChangedCallback(e => { owner.RegisterCompleteObjectUndo("Updated Max " + e.newValue); node.max = e.newValue; NotifyNodeChanged(); }); controlsContainer.Add(min); controlsContainer.Add(max); }
public EditorFloatSliderField(string label, float value, float min, float max, EventCallback <ChangeEvent <float> > callback) { slider = new Slider(label, min, max, SliderDirection.Horizontal); slider.name = nameof(slider); slider.value = value; labelElement.StylePadding(0, 8, 0, 0); Add(slider); floatField = new FloatField(); floatField.name = nameof(floatField); floatField.StyleWidth(64); floatField.style.paddingLeft = 4; floatField.style.marginRight = 0; floatField.value = value; floatField.RegisterValueChangedCallback(callback); floatField.RegisterValueChangedCallback((callbackChangedSlider) => { slider.value = callbackChangedSlider.newValue; }); slider.Add(floatField); slider.RegisterValueChangedCallback((callbackSlide) => { floatField.value = callbackSlide.newValue; }); }
private void SetPotentialsFromNavigationField() { FloatField costs = NavigationField.Costs; for (int y = 0; y < Size.y; y++) { for (int x = 0; x < Size.x; x++) { float cost = costs[x, y]; if (float.IsPositiveInfinity(cost)) { Potentials[x, y] = float.NegativeInfinity; Vector2i p = new Vector2i(x, y); bool foundExit = TestEscapeDirection(p, DownLeft) || TestEscapeDirection(p, DownRight) || TestEscapeDirection(p, UpLeft) || TestEscapeDirection(p, UpRight) || TestEscapeDirection(p, Left) || TestEscapeDirection(p, Right) || TestEscapeDirection(p, Up) || TestEscapeDirection(p, Down); } else { Potentials[x, y] = UnreachablePotential; } } } }
VisualElement CreateLightExposureContent() { var exposure = SceneView.s_DrawModeExposure; var root = new VisualElement(); root.AddToClassList(k_SliderRowClass); var icon = new Image() { name = "exposure-label" }; m_ExposureSlider = new Slider(-m_ExposureMax, m_ExposureMax) { name = "exposure-slider" }; m_ExposureSlider.AddToClassList(k_SliderClass); m_ExposureSlider.RegisterValueChangedCallback(SetBakedExposure); m_ExposureSlider.SetValueWithoutNotify(exposure); m_ExposureField = new FloatField() { name = "exposure-float-field" }; m_ExposureField.AddToClassList(k_SliderFloatFieldClass); m_ExposureField.RegisterValueChangedCallback(SetBakedExposure); m_ExposureField.SetValueWithoutNotify(exposure); root.Add(icon); root.Add(m_ExposureSlider); root.Add(m_ExposureField); return(root); }
public static void TestFloatField() { BehaviorTreeElement behaviorTree = new BehaviorTreeElement(); behaviorTree.StartNode = new NodeData(); FloatField floatField = new FloatField(); floatField.FieldName = "FloatField"; floatField.Value = 100.001f; behaviorTree.StartNode.Fields.Add(floatField); RepeatFloatField repeatFloatField = new RepeatFloatField(); repeatFloatField.FieldName = "RepeatIntField"; repeatFloatField.Value = new List <float>(); repeatFloatField.Value.Add(1.1f); repeatFloatField.Value.Add(100.11f); repeatFloatField.Value.Add(1000.11f); repeatFloatField.Value.Add(10000.1119f); behaviorTree.StartNode.Fields.Add(repeatFloatField); byte[] bytes = Serializer.Serialize(behaviorTree); BehaviorTreeElement deBehaviorTreeData = Serializer.DeSerialize <BehaviorTreeElement>(bytes); }
protected override void SetBaseVisualElement(VisualElement visualElement) { Vector3Field originField = new Vector3Field("Origin: ") { value = Blueprint.Origin }; originField.RegisterCallback <ChangeEvent <Vector3> >(evt => Blueprint.SetOrigin(evt.newValue)); visualElement.Add(originField); FloatField lengthField = new FloatField("Length: ") { value = Blueprint.Length }; lengthField.RegisterCallback <ChangeEvent <float> >(evt => Blueprint.SetLength(evt.newValue)); visualElement.Add(lengthField); // visualElement.Add(new ValidatorField(Blueprint.NonZeroVolumeValidator)); for (int i = 0; i < Blueprint.Points.Count; i++) { int pointNum = i; TextField nameField = new TextField((pointNum + 1).GetOrdinalForm() + " Point name: ") { value = Blueprint.Points[i].PointName }; nameField.RegisterCallback <ChangeEvent <string> >(evt => Blueprint.SetPointName(pointNum, evt.newValue)); visualElement.Add(nameField); visualElement.Add(new ValidatorField(Blueprint.Points[i].NameNotEmptyValidator)); visualElement.Add(new ValidatorField(Blueprint.Points[i].NameUniquenessValidator)); visualElement.Add(new ValidatorField(Blueprint.Points[i].PositionUniquenessValidator)); } }
public void OpenClipsTransitionsModal(MVideoClip clip, MTransition transition) { var modalContent = this.ShowModalWindow("Transition"); // Create a new field and assign it its value. var TypeField = new EnumField("Type:", transition.Type); modalContent.Add(TypeField); var durationField = new FloatField("Duration:"); durationField.value = transition.duration; modalContent.Add(durationField); TypeField.RegisterCallback <ChangeEvent <System.Enum> >((evt) => { transition.Type = (MTransition.TransitionType)evt.newValue; }); durationField.RegisterCallback <ChangeEvent <float> >((evt) => { transition.duration = evt.newValue; }); }
public void CleanTest() { FloatField target = new FloatField(); // Default test Assert.AreEqual((float?)12.2, (float?)target.Clean("12.2")); AssertExtras.Raises <ValidationException>(delegate { target.Clean(null); }).WithMessage("This field is required."); AssertExtras.Raises <ValidationException>(delegate { target.Clean("abc"); }).WithMessage("Enter a number."); target.MinValue = (float?)5; AssertExtras.Raises <ValidationException>(delegate { target.Clean("4.65"); }).WithMessage("Ensure this value is greater than or equal to 5."); Assert.AreEqual((float?)5.5, (float?)target.Clean("5.5")); target.MaxValue = (float?)10.3; AssertExtras.Raises <ValidationException>(delegate { target.Clean("15"); }).WithMessage("Ensure this value is less than or equal to 10.3."); Assert.AreEqual((float?)10.2, (float?)target.Clean("10.2")); target.Required = false; Assert.IsNull(target.Clean(null)); }
void AddRealtimeFields(MixtureNode node, MixtureGraphView owner) { doubleBuffered = new Toggle("Double Buffered") { value = node.rtSettings.doubleBuffered, }; doubleBuffered.RegisterValueChangedCallback(e => { owner.RegisterCompleteObjectUndo("Set Double Buffered " + e.newValue); node.rtSettings.doubleBuffered = e.newValue; onChanged?.Invoke(); }); Add(doubleBuffered); refreshMode = new EnumField("Refresh Mode", node.rtSettings.refreshMode); refreshMode.RegisterValueChangedCallback(e => { owner.RegisterCompleteObjectUndo("Set Refresh Mode " + e.newValue); node.rtSettings.refreshMode = (RefreshMode)e.newValue; onChanged?.Invoke(); }); Add(refreshMode); period = new FloatField("Period") { value = node.rtSettings.period }; period.RegisterValueChangedCallback(e => { owner.RegisterCompleteObjectUndo("Set Period " + e.newValue); node.rtSettings.period = e.newValue; onChanged?.Invoke(); }); Add(period); }
public static void TestFloatField() { AgentData agent = new AgentData(); agent.StartNode = new NodeData(); FloatField floatField = new FloatField(); floatField.FieldName = "FloatField"; floatField.Value = 100.001f; agent.StartNode.Fields.Add(floatField); RepeatFloatField repeatFloatField = new RepeatFloatField(); repeatFloatField.FieldName = "RepeatIntField"; repeatFloatField.Value = new List <float>(); repeatFloatField.Value.Add(1.1f); repeatFloatField.Value.Add(100.11f); repeatFloatField.Value.Add(1000.11f); repeatFloatField.Value.Add(10000.1119f); agent.StartNode.Fields.Add(repeatFloatField); byte[] bytes = Serializer.Serialize(agent); AgentData deAgentData = Serializer.DeSerialize <AgentData>(bytes); }
public SliderFloatControl(float value, float min, float max) { _slider = new Slider(min, max); _text = new FloatField(); Setup(value); }
void LoadTemplate() { AddToClassList("timeField"); m_FieldName = new Label(); m_FieldName.AddToClassList("timeFieldNameLabel"); Add(m_FieldName); var inputContainer = new VisualElement(); inputContainer.AddToClassList("timeFieldInputContainer"); Add(inputContainer); m_SecondsField = new FloatField("Seconds"); m_SecondsField.AddToClassList("timeInput"); m_SecondsField.RegisterValueChangedCallback(OnTimeInSecondsChanged); inputContainer.Add(m_SecondsField); m_FrameField = new IntegerField("Frame"); m_FrameField.AddToClassList("timeInput"); m_FrameField.RegisterValueChangedCallback(OnFrameChanged); inputContainer.Add(m_FrameField); SyncToViewModeSetting(); RegisterCallback <AttachToPanelEvent>(OnAttachToPanel); RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel); }
VisualElement CreateSliderWithField(GUIContent label, float value, float min, float max, EventCallback <ChangeEvent <float> > callback) { var root = new VisualElement() { name = "Slider Float Field" }; root.AddToClassList(k_SliderRowClass); var slider = new Slider(min, max); slider.AddToClassList(k_SliderClass); slider.RegisterValueChangedCallback(callback); slider.SetValueWithoutNotify(value); if (label != null && !string.IsNullOrEmpty(label.text)) { slider.label = label.text; slider.tooltip = label.tooltip; } var field = new FloatField(); field.AddToClassList(k_SliderFloatFieldClass); field.RegisterValueChangedCallback(callback); field.SetValueWithoutNotify(value); root.Add(slider); root.Add(field); return(root); }
private void RefreshScenarioScoreView() { scenarioScoreView.Clear(); if (!EditorApplication.isPlaying) { scenarioScoreView.Add(new Label("Please enter play mode")); return; } var stateManager = ((GameManager)target).GameStateManager; var values = stateManager.ScenarioScoreDict; foreach (var kvp in values) { var field = new FloatField(kvp.Key.ScenarioName) { value = kvp.Value }; field.SetEnabled(false); if (kvp.Key == stateManager.TopScenario()) { field.style.color = Color.red; } scenarioScoreView.Add(field); } }
public void CreateGUI() { VisualElement root = rootVisualElement; var visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/EasePreview.uxml"); VisualElement labelFromUXML = visualTree.Instantiate(); labelFromUXML.style.flexGrow = 1; root.Add(labelFromUXML); var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/EasePreview.uss"); root.styleSheets.Add(styleSheet); var selector = root.Q <EnumField>("selector"); selector.Init(_easeType); selector.RegisterValueChangedCallback(SelectorValueChanged); _drawPanel = root.Q <VisualElement>("drawPanel"); _drawPanel.generateVisualContent = DrawEaseFunction; _overField = root.Q <FloatField>("overshootOrAmplitude"); _overField.RegisterValueChangedCallback(ParaChangedOvershootOrAmplitude); _overField.visible = false; _periodField = root.Q <FloatField>("period"); _periodField.RegisterValueChangedCallback(ParaChangedPeriod); _periodField.visible = false; root.Bind(new SerializedObject(this)); }
internal VisualElement CreateGUI( ValueChangedCallback valueChangedCallback, float fieldToDraw, string labelName, out VisualElement propertyFloatField, int indentLevel = 0) { var floatField = new FloatField { label = "X", value = fieldToDraw }; floatField.labelElement.style.minWidth = 15; if (valueChangedCallback != null) { floatField.RegisterValueChangedCallback(evt => { valueChangedCallback((float)evt.newValue); }); } propertyFloatField = floatField; var defaultRow = new PropertyRow(PropertyDrawerUtils.CreateLabel(labelName, indentLevel)); defaultRow.Add(propertyFloatField); defaultRow.styleSheets.Add(Resources.Load <StyleSheet>("Styles/PropertyRow")); return(defaultRow); }
// ----------------------------------------------------------------------------------------- public void Generate_Broadcaster_Vertical_Spacing_Field() { var floatProp = new FloatProperty(); floatProp.PropertyName = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyName; floatProp.PropertyValue = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue; var visualElement = new VisualElement(); var blackboardField = new BlackboardField { text = floatProp.PropertyName, typeText = "" }; visualElement.Add(blackboardField); var field = new FloatField("Value:"); field.value = floatProp.PropertyValue; field.RegisterValueChangedCallback(ChangeEvent => { _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue = field.value; if (_TranzmitGraphView.CurrentArrangementType == Tranzmit_Graph_View.ArrangementTypes.Vertical) { _TranzmitGraphView.Arrange_Broadcaster_Results(Tranzmit_Graph_View.ArrangementTypes.Vertical); } }); var blackBoardValueRow = new BlackboardRow(blackboardField, field); visualElement.Add(blackBoardValueRow); _TranzmitGraphView.Blackboard.Add(visualElement); }
public CreateVector2Node() { Initialize("Create Vector2", DefaultNodePosition); var inputField = new FloatField { label = "x:", value = 0 }; inputField.labelElement.style.minWidth = 0; inputField.name = "xInput"; inputField.RegisterValueChangedCallback(evt => { CodeGraph.Instance.InvalidateSaveButton(); x = evt.newValue; }); inputContainer.Add(inputField); var inputField2 = new FloatField { label = "y:", value = 0 }; inputField2.labelElement.style.minWidth = 0; inputField2.name = "yInput"; inputField2.RegisterValueChangedCallback(evt => { CodeGraph.Instance.InvalidateSaveButton(); y = evt.newValue; }); inputContainer.Add(inputField2); var valuePort = base.InstantiatePort(Orientation.Horizontal, Direction.Output, Port.Capacity.Multi, typeof(float)); valuePort.portName = "value (2)"; AddOutputPort(valuePort, () => $"new Vector2({x}f,{y}f)"); Refresh(); }
public override VisualElement Build() { base.Build(); var range = DrawerAttribute; m_Field.lowValue = TypeConversion.Convert <float, TFieldType>(Mathf.Max(range.min, LowValue)); m_Field.highValue = TypeConversion.Convert <float, TFieldType>(Mathf.Min(range.max, HighValue)); var root = new VisualElement(); root.Add(m_Field); m_Field.style.flexGrow = 1; m_ValueField = new FloatField { name = Name, label = null, tooltip = Tooltip, }; m_ValueField.formatString = "0.##"; m_ValueField.RegisterValueChangedCallback(OnChanged); m_ValueField.style.flexGrow = 0; m_ValueField.style.width = 50; root.Add(m_ValueField); root.style.flexDirection = FlexDirection.Row; return(root); }
public BaseNodeUI() { VisualElement container = new VisualElement(); title = DefaultName; Label titleLabel = (Label)titleContainer[0]; titleContainer.RemoveAt(0); NameField = new TextField(); NameField.style.flexGrow = 1f; container.Add(titleLabel); container.Add(NameField); titleContainer.Insert(0, container); _speedField = new FloatField("Speed"); _speedField.SetValueWithoutNotify(1f); _speedField.AddToClassList("speed-field"); mainContainer.Insert(1, _speedField); RefreshExpandedState(); RefreshPorts(); }
void AddField(Vector4 initialValue, int index, string subLabel) { var dummy = new VisualElement { name = "dummy" }; var label = new Label(subLabel); dummy.Add(label); Add(dummy); var field = new FloatField { userData = index, value = initialValue[index] }; var dragger = new FieldMouseDragger <double>(field); dragger.SetDragZone(label); field.Q("unity-text-input").RegisterCallback <KeyDownEvent>(evt => { // Record Undo for input field edit if (m_UndoGroup == -1) { m_UndoGroup = Undo.GetCurrentGroup(); m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name); } // Handle scaping input field edit if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1) { Undo.RevertAllDownToGroup(m_UndoGroup); m_UndoGroup = -1; evt.StopPropagation(); } // Dont record Undo again until input field is unfocused m_UndoGroup++; this.MarkDirtyRepaint(); }); // Called after KeyDownEvent field.RegisterValueChangedCallback(evt => { // Only true when setting value via FieldMouseDragger // Undo recorded once per dragger release if (m_UndoGroup == -1) { m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name); } var value = m_Get(); if (value[index] != (float)evt.newValue) { value[index] = (float)evt.newValue; m_Set(value); m_Node.Dirty(ModificationScope.Node); } }); // Reset UndoGroup when done editing input field & update title field.Q("unity-text-input").RegisterCallback <FocusOutEvent>(evt => { m_Node.owner.owner.isDirty = true; m_UndoGroup = -1; }); Add(field); }
static void CreateField <T>(string label, IConstantEditorBuilder builder, VisualElement container, T oldValue, float fieldValue, Func <ChangeEvent <float>, T> generateValue) { var field = new FloatField(label); field.value = fieldValue; container.Add(field); field.RegisterValueChangedCallback(evt => Dispatch(builder, oldValue, generateValue(evt))); }
public static void SetFloatFieldRange(this FloatField field, float min = float.MinValue, float max = float.MaxValue) { k_FloatFieldRanges[field] = new Tuple <float, float>(min, max); field.RegisterValueChangedCallback(OnFloatFieldValueChanged); field.RegisterCallback <DetachFromPanelEvent>(OnFloatFieldDetachedFromPanel); ClampFloatFieldValue(field.value, field); }
public void SetData(WidgetDataLaunchCommandElement data) { _widgetData = data; _nameLabel.text = data.GameConsoleInvokable.DisplayName; _activeToggle.value = data.Active; _paramsContainer.Clear(); int paramIndex = 0; foreach (IGameConsoleParameter param in data.GameConsoleInvokable.Parameters) { if (param.Type == typeof(bool)) { var field = new Toggle(); bool.TryParse(TryPopParam(), out bool val); field.value = val; field.RegisterValueChangedCallback((evt) => OnParameterModified()); _paramsContainer.Add(field); } else if (param.Type == typeof(int)) { var field = new IntegerField(); int.TryParse(TryPopParam(), out int val); field.value = val; field.RegisterValueChangedCallback((evt) => OnParameterModified()); _paramsContainer.Add(field); } else if (param.Type == typeof(float)) { var field = new FloatField(); float.TryParse(TryPopParam(), out float val); field.value = val; field.RegisterValueChangedCallback((evt) => OnParameterModified()); _paramsContainer.Add(field); } else { var field = new TextField(); field.value = TryPopParam(); field.RegisterValueChangedCallback((evt) => OnParameterModified()); _paramsContainer.Add(field); } } _nameLabel.SetEnabled(data.Active); foreach (var item in _paramsContainer.Children()) { item.SetEnabled(data.Active); } OnParameterModified(); string TryPopParam() { if (data.Parameters == null) { return(default);
FloatField AddField(VisualElement panel, string label, int index, Vector3 initValiue) { var field = new FloatField { userData = index, value = initValiue[index] }; if (label != "") { var l = new Label(label); panel.Add(l); var dragger = new FieldMouseDragger <double>(field); dragger.SetDragZone(l); } field.RegisterCallback <MouseDownEvent>(Repaint); field.RegisterCallback <MouseMoveEvent>(Repaint); field.OnValueChanged(evt => { var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null); value[index] = (float)evt.newValue; m_PropertyInfo.SetValue(m_Node, value, null); m_UndoGroup = -1; UpdateSlider(m_SliderPanel, index, value); this.MarkDirtyRepaint(); }); field.RegisterCallback <InputEvent>(evt => { if (m_UndoGroup == -1) { m_UndoGroup = Undo.GetCurrentGroup(); m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name); } float newValue; if (!float.TryParse(evt.newData, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out newValue)) { newValue = 0f; } var value = (Vector3)m_PropertyInfo.GetValue(m_Node, null); value[index] = newValue; m_PropertyInfo.SetValue(m_Node, value, null); this.MarkDirtyRepaint(); }); field.RegisterCallback <KeyDownEvent>(evt => { if (evt.keyCode == KeyCode.Escape && m_UndoGroup > -1) { Undo.RevertAllDownToGroup(m_UndoGroup); m_UndoGroup = -1; m_Value = (Vector3)m_PropertyInfo.GetValue(m_Node, null); UpdateSlider(m_SliderPanel, index, m_Value); evt.StopPropagation(); } this.MarkDirtyRepaint(); }); panel.Add(field); return(field); }
ConstantFloat() : base() { title = "Constant Float"; AddOutputPort <float>("Value"); RefreshPorts(); m_FloatField = new FloatField(); extensionContainer.Add(m_FloatField); RefreshExpandedState(); }
protected void AddProperty <Data>(GUIContent displayName, Func <Data> getter, Action <Data> setter, int indentLevel = 0) { // Create UIElement from type: BaseField <Data> elem = null; BaseField <Enum> elemEnum = null; switch (getter()) { case bool b: elem = new Toggle { value = b } as BaseField <Data>; break; case int i: elem = new IntegerField { value = i, isDelayed = true } as BaseField <Data>; break; case float f: elem = new FloatField { value = f, isDelayed = true } as BaseField <Data>; break; case Enum e: elemEnum = new EnumField(e) { value = e }; break; default: throw new Exception($"Can't create UI field for type {getter().GetType()}, please add it if it's relevant. If you can't consider using TargetPropertyGUIContext.AddProperty instead."); } if (elem != null) { context.AddProperty <Data>(displayName.text, displayName.tooltip, indentLevel, elem, (evt) => { if (Equals(getter(), evt.newValue)) { return; } registerUndo(displayName.text); setter(evt.newValue); onChange(); }); } else { context.AddProperty <Enum>(displayName.text, displayName.tooltip, indentLevel, elemEnum, (evt) => { if (Equals(getter(), evt.newValue)) { return; } registerUndo(displayName.text); setter((Data)(object)evt.newValue); onChange(); }); } }
public static VisualElement GetElementOfFloatField(float startValue, string fieldName, Action <object> setValue, Action <object> getValue) { FloatField field = new FloatField(fieldName); field.SetValueWithoutNotify(startValue); field.RegisterValueChangedCallback(s => setValue.Invoke(s.newValue)); getValue += o => field.SetValueWithoutNotify((float)o); return(field); }
static void AddDistanceFloatField(string name, string label, VisualElement root) { var field = new FloatField(label) { name = name }; field.SetEnabled(false); root.Add(field); }
public static void RenderFloatProperty(VisualElement container, string name, object value, Action <object> setter) { var field = new FloatField(name); field.SetValueWithoutNotify((float)value); field.MarkDirtyRepaint(); field.RegisterValueChangedCallback(evt => setter(evt.newValue)); container.Add(field); }
public PotentialField( NavigationField navigationField, Target target) { Size = navigationField.fieldSize; NavigationField = navigationField; Target = target; Potentials = new FloatField(navigationField.fieldSize); Flows = new Vector2Field(navigationField.fieldSize); _heap = new MaxHeap<CellPotentialHeapEntry> { RemoveAction = CellPotentialHeapEntry.ReturnCellCostHeapEntry }; }
public void Start() { Instance = this; _halfGrid = new Vector2(gridSize * 0.5f, gridSize * 0.5f); Costs = new FloatField(fieldSize); Populate(); }