public void Refresh()
{
// HACK until fix goes in:
m_CanvasWidth.isDelayed = false;
m_CanvasHeight.isDelayed = false;
m_CanvasWidth.SetValueWithoutNotify(settings.CanvasWidth);
m_CanvasHeight.SetValueWithoutNotify(settings.CanvasHeight);
m_CanvasWidth.isDelayed = true;
m_CanvasHeight.isDelayed = true;
m_OpacityField.SetValueWithoutNotify(settings.CanvasBackgroundOpacity);
m_BackgroundMode.SetValueWithoutNotify(settings.CanvasBackgroundMode.ToString());
m_ColorField.SetValueWithoutNotify(settings.CanvasBackgroundColor);
var scaleModeStr = settings.CanvasBackgroundImageScaleMode.ToString();
scaleModeStr = BuilderNameUtilities.ConvertCamelToDash(scaleModeStr);
m_ImageField.SetValueWithoutNotify(settings.CanvasBackgroundImage);
m_ImageScaleModeField.SetValueWithoutNotify(scaleModeStr);
m_CameraField.SetValueWithoutNotify(FindCameraByName());
ApplyBackgroundOptions();
}
public void Refresh()
{
// HACK until fix goes in:
SetDelayOnSizeFieldsEnabled(false);
m_CanvasWidth.SetValueWithoutNotify(settings.CanvasWidth);
m_CanvasHeight.SetValueWithoutNotify(settings.CanvasHeight);
SetDelayOnSizeFieldsEnabled(true);
m_BackgroundOptionsFoldout.SetCheckboxValueWithoutNotify(settings.EnableCanvasBackground);
m_ColorOpacityField.SetValueWithoutNotify(settings.ColorModeBackgroundOpacity);
m_ImageOpacityField.SetValueWithoutNotify(settings.ImageModeCanvasBackgroundOpacity);
m_CameraOpacityField.SetValueWithoutNotify(settings.CameraModeCanvasBackgroundOpacity);
m_BackgroundMode.SetValueWithoutNotify(settings.CanvasBackgroundMode.ToString());
m_ColorField.SetValueWithoutNotify(settings.CanvasBackgroundColor);
var scaleModeStr = settings.CanvasBackgroundImageScaleMode.ToString();
scaleModeStr = BuilderNameUtilities.ConvertCamelToDash(scaleModeStr);
m_ImageField.SetValueWithoutNotify(settings.CanvasBackgroundImage);
m_ImageScaleModeField.SetValueWithoutNotify(scaleModeStr);
m_CameraField.SetValueWithoutNotify(FindCameraByName());
m_EditorExtensionsModeToggle?.SetValueWithoutNotify(m_Document.fileSettings.editorExtensionMode);
ApplyBackgroundOptions();
RefreshMatchGameViewToggle();
}
private void UpdatePositionField(Rect rect)
{
m_PositionFieldX.SetValueWithoutNotify((int)selectedSpriteRect.x);
m_PositionFieldY.SetValueWithoutNotify((int)selectedSpriteRect.y);
m_PositionFieldW.SetValueWithoutNotify((int)selectedSpriteRect.width);
m_PositionFieldH.SetValueWithoutNotify((int)selectedSpriteRect.height);
}
private void InitStyleValues()
{
if (m_SelectedElement != null)
{
switch (boxType)
{
case BoxType.Margin:
InitOnMargins();
break;
case BoxType.Border:
InitOnBorders();
break;
case BoxType.Padding:
InitOnPaddings();
break;
}
}
else
{
m_LeftTextField.SetValueWithoutNotify(0);
m_RightTextField.SetValueWithoutNotify(0);
m_TopTextField.SetValueWithoutNotify(0);
m_BottomTextField.SetValueWithoutNotify(0);
}
}
public override void Reload(IProperty property)
{
m_ContentRoot.Clear();
var list = GetValue();
if (null == list)
{
return;
}
m_PaginationElement.Update(list.Count);
if (m_Size.focusController?.focusedElement != m_Size)
{
m_Size.isDelayed = false;
m_Size.SetValueWithoutNotify(list.Count);
m_Size.isDelayed = true;
}
var startIndex = 0;
var endIndex = list.Count;
if (UsesPagination)
{
startIndex = m_PaginationElement.StartIndex;
endIndex = m_PaginationElement.EndIndex;
}
var atIndexPath = PropertyPath.Pool.Get();
try
{
atIndexPath.PushPath(Path);
for (var i = startIndex; i < endIndex; ++i)
{
var index = i;
atIndexPath.PushIndex(index);
try
{
var root = new VisualElement();
Root.VisitAtPath(atIndexPath, root);
MakeListElement(root, index);
m_ContentRoot.Add(root);
}
finally
{
atIndexPath.Pop();
}
}
}
finally
{
PropertyPath.Pool.Release(atIndexPath);
}
}
public static VisualElement GetElementOfIntField(int startValue, string fieldName, Action <object> setValue, Action <object> getValue)
{
IntegerField field = new IntegerField(fieldName);
field.SetValueWithoutNotify(startValue);
field.RegisterValueChangedCallback(s => setValue.Invoke(s.newValue));
getValue += o => field.SetValueWithoutNotify((int)o);
return(field);
}
private void UpdateBorderField(FocusOutEvent evt)
{
if (hasSelected)
{
m_BorderFieldL.SetValueWithoutNotify((int)selectedSpriteBorder.x);
m_BorderFieldB.SetValueWithoutNotify((int)selectedSpriteBorder.y);
m_BorderFieldR.SetValueWithoutNotify((int)selectedSpriteBorder.z);
m_BorderFieldT.SetValueWithoutNotify((int)selectedSpriteBorder.w);
}
}
protected void UpdatePositionField(FocusOutEvent evt)
{
if (hasSelected)
{
m_PositionFieldX.SetValueWithoutNotify((int)selectedSpriteRect.x);
m_PositionFieldY.SetValueWithoutNotify((int)selectedSpriteRect.y);
m_PositionFieldW.SetValueWithoutNotify((int)selectedSpriteRect.width);
m_PositionFieldH.SetValueWithoutNotify((int)selectedSpriteRect.height);
}
}
public override void UpdateFromChildFields()
{
var styleFields = this.Query <StyleFieldBase>().ToList();
bool allTheSame = true;
string singleValue = string.Empty;
string cumulativeValue = string.Empty;
for (int i = 0; i < styleFields.Count; ++i)
{
if (i == 0)
{
singleValue = styleFields[i].value;
}
else if (singleValue != styleFields[i].value)
{
allTheSame = false;
}
if (i != 0)
{
cumulativeValue += k_FieldStringSeparator;
}
cumulativeValue += styleFields[i].value;
}
if (allTheSame)
{
m_TextField.SetValueWithoutNotify(singleValue);
}
else
{
m_TextField.SetValueWithoutNotify(cumulativeValue);
}
if (styleFields.Count > 0 && (styleFields[0] is StyleField <int> || styleFields[0] is StyleField <float>))
{
var intField = styleFields[0] as StyleField <int>;
var floatField = styleFields[0] as StyleField <float>;
if (intField != null)
{
m_DraggerIntegerField.SetValueWithoutNotify(intField.innerValue);
}
else
{
m_DraggerIntegerField.SetValueWithoutNotify((int)floatField.innerValue);
}
}
}
public void SelectElement(VisualElement ve)
{
m_SelectedElement = ve;
if (ve != null)
{
m_WidthTextField.SetValueWithoutNotify((int)m_SelectedElement.contentRect.width);
m_HeightTextField.SetValueWithoutNotify((int)m_SelectedElement.contentRect.height);
}
else
{
m_WidthTextField.SetValueWithoutNotify(0);
m_HeightTextField.SetValueWithoutNotify(0);
}
}
public void Bind(TransitionInfoCondition condition)
{
_condition = condition;
if (_parameterFinder.Item != null)
{
_parameterFinder.Item.OnTypeChanged -= ParameterTypeChanged;
}
_parameterFinder.SelectItemWithoutNotify(_condition.Parameter, true);
if (_parameterFinder.Item != null)
{
_parameterFinder.Item.OnTypeChanged += ParameterTypeChanged;
}
_stateFinder.SelectItemWithoutNotify(_condition.State, true);
_stateValueProvider.SetValueWithoutNotify(_condition.StateValueProvider);
SetProviderSourceType(_condition.ProviderSourceType);
_boolComparisonValueField.SetValueWithoutNotify(_condition.BoolComparisonValue ? Bool.True : Bool.False);
_intComparisonField.SetValueWithoutNotify(_condition.IntComparison);
_intComparisonValueField.SetValueWithoutNotify(_condition.IntComparisonValue);
_floatComparisonField.SetValueWithoutNotify(_condition.FloatComparison);
_floatComparisonValueField.SetValueWithoutNotify(_condition.FloatComparisonValue);
}
static void ClampEditingValue(ChangeEvent <int> evt, IntegerField field)
{
if (evt.newValue < 0)
{
field.SetValueWithoutNotify(0);
}
}
protected override void DrawNode(ModuleGraphView graphView)
{
Debug.Log(Script.SceneIndex);
var inputPort = graphView.GeneratePort <float>(this, Direction.Input, Port.Capacity.Multi);
inputPort.portName = "Input";
inputContainer.Add(inputPort);
AddToClassList("action");
var outputPort = graphView.GeneratePort <float>(this, Direction.Output);
outputPort.portName = "Output";
outputContainer.Add(outputPort);
IntegerField intField = new IntegerField("Scene Index", 2);
intField.value = Script.SceneIndex;
intField.RegisterValueChangedCallback(evt =>
{
var temp = evt.newValue < 0 ? 0 : evt.newValue > 99 ? 99 : evt.newValue;
intField.SetValueWithoutNotify(temp);
Script.SceneIndex = temp;
graphView.SetDirty();
});
extensionContainer.Add(intField);
graphView.RefreshNode(this);
graphView.AddElement(this);
}
public static IntegerField CollectionSizeField <TProperty, TContainer, TValue>(
TProperty property,
ref TContainer container,
ref TValue value,
InspectorVisitorContext visitorContext)
where TProperty : ICollectionProperty <TContainer, TValue>
{
var field = new IntegerField
{
name = "CollectionSize",
label = "Size",
bindingPath = string.Empty,
isDelayed = true
};
field.SetValueWithoutNotify(property.GetCount(ref container));
SetTooltip(property.Attributes, field);
var parent = visitorContext.Parent;
visitorContext.Parent.contentContainer.Add(field);
field.RegisterValueChangedCallback(evt =>
{
visitorContext.Binding.SetCount(parent, Mathf.Clamp(evt.newValue, 0, int.MaxValue));
});
return(field);
}
protected void PopulateSpriteFrameInspectorField()
{
m_SelectedFrameInspector.style.display = hasSelected ? DisplayStyle.Flex : DisplayStyle.None;
if (!hasSelected)
{
return;
}
m_NameElement.SetEnabled(containsMultipleSprites);
m_NameField.SetValueWithoutNotify(selectedSpriteName);
m_PositionElement.SetEnabled(containsMultipleSprites);
var spriteRect = selectedSpriteRect;
m_PositionFieldX.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.x));
m_PositionFieldY.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.y));
m_PositionFieldW.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.width));
m_PositionFieldH.SetValueWithoutNotify(Mathf.RoundToInt(spriteRect.height));
var spriteBorder = selectedSpriteBorder;
m_BorderFieldL.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.x));
m_BorderFieldT.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.w));
m_BorderFieldR.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.z));
m_BorderFieldB.SetValueWithoutNotify(Mathf.RoundToInt(spriteBorder.y));
m_PivotField.SetValueWithoutNotify(selectedSpriteAlignment);
m_PivotUnitModeField.SetValueWithoutNotify(m_PivotUnitMode);
Vector2 pivot = selectedSpritePivotInCurUnitMode;
m_CustomPivotFieldX.SetValueWithoutNotify(pivot.x);
m_CustomPivotFieldY.SetValueWithoutNotify(pivot.y);
m_CustomPivotElement.SetEnabled(hasSelected && selectedSpriteAlignment == SpriteAlignment.Custom);
}
public void LoadData(Parameter parameter)
{
Name = parameter.Name;
ParameterTypeField.SetValueWithoutNotify(parameter.Type);
ChangeParameterType(parameter.Type, default);
switch (parameter.ValueProvider)
{
case BoolProvider boolProvider:
BoolField.SetValueWithoutNotify(boolProvider.Value);
break;
case IntProvider intProvider:
IntField.SetValueWithoutNotify(intProvider.Value);
break;
case FloatProvider floatProvider:
FloatField.SetValueWithoutNotify(floatProvider.Value);
break;
default:
break;
}
}
public void Update(InspectorDataProxy <LayerSorting> proxy)
{
var data = proxy.Data;
var index = m_Names.FindIndex(l => l.id == data.id);
m_Layers.index = index < 0 ? 0 : index;
m_Order.SetValueWithoutNotify(data.order);
}
public static void SetCollectionSize(IntegerField element, int size)
{
if (element?.focusController?.focusedElement != element)
{
element.isDelayed = false;
element.SetValueWithoutNotify(size);
element.isDelayed = true;
}
}
protected void BindBaseCreateElements(Button cancelButton, Button createButton, TextField nameField, IntegerField countField, Toggle maxCountToggle)
{
cancelButton.clickable.clicked += OnCancelClicked;
createButton.clickable.clicked += OnCreateClicked;
if (GetDefaultName != null)
{
m_CurrentName = GetDefaultName();
}
m_NameField = nameField;
m_NameField.isDelayed = true;
m_NameField.SetValueWithoutNotify(m_CurrentName);
m_NameIsCustom = false;
m_NameField.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Length > 0)
{
m_CurrentName = evt.newValue;
m_NameIsCustom = true;
}
else if (GetDefaultName != null)
{
m_CurrentName = GetDefaultName();
m_NameField?.SetValueWithoutNotify(m_CurrentName);
m_NameIsCustom = false;
}
if (NameChanged != null)
{
NameChanged(m_CurrentName);
}
});
maxCountToggle.RegisterValueChangedCallback(evt =>
{
m_CountField.value = evt.newValue ? 1 : 0;
m_CountField.SetEnabled(evt.newValue);
});
m_CountField = countField;
m_CountField.RegisterValueChangedCallback(evt =>
{
var newValue = evt.newValue;
if (newValue < 0)
{
newValue = 0;
m_CountField.SetValueWithoutNotify(newValue);
}
var maxEnabled = newValue > 0;
maxCountToggle.SetValueWithoutNotify(maxEnabled);
m_CountField.SetEnabled(maxEnabled);
CountChanged?.Invoke(newValue);
});
}
void SetDragFieldLimit(IntegerField field, int value)
{
// The only way to know if value change is due to dragger or text input
var t = field.Q("unity-text-input");
if (!t.focusController.IsFocused(t))
{
// Value changed due to drag. We set back the field so to show the drag limit
field.SetValueWithoutNotify(value);
}
}
void RefreshSubFields()
{
var intNewValue = (int)(value * 100);
mSlider.SetValueWithoutNotify(intNewValue);
if (mSlider.elementPanel != null)
{
mSlider.OnViewDataReady(); // Hack to force update the slide handle position.
}
mField.SetValueWithoutNotify(intNewValue);
}
public static void RenderIntProperty(
VisualElement container,
string name,
object value,
Action <object> setter)
{
var field = new IntegerField(name);
field.SetValueWithoutNotify((int)value);
field.MarkDirtyRepaint();
field.RegisterValueChangedCallback(evt => setter(evt.newValue));
container.Add(field);
}
private void AddNewTableEntry(Button pressedButton, SpeakEasyNode node, IntegerField indexField, TextField textField)
{
//Check if we by any chance already have a reference.
for (int i = 0; i < localText.localizedText.Count; i++)
{
if (node.stringReference == "" || node.stringReference == System.String.Empty)
{
EditorUtility.DisplayDialog("Oops!", "Sorry, cannot add a new entry without a proper Identifier.", "OK");
return;
}
if (node.stringReference == localText.localizedText[i].id)
{
//We already have a point of reference
pressedButton.SetEnabled(false);
node.stringIndex = i;
indexField.SetValueWithoutNotify(node.stringIndex);
textField.SetValueWithoutNotify(GetStringIndex(node.stringIndex));
textField.SetEnabled(true);
return;
}
}
pressedButton.SetEnabled(false); //We no longer need a new reference point.
//Give this node a new string ID
node.stringIndex = localText.localizedText.Count; //the Count is always +1 which means it will place the new reference at the right index.. right?
localText.localizedText.Add(new LocalizedText()
{
id = node.stringReference
}); //we add the new address for the list.
//Now we need to connect the three fields
indexField.SetValueWithoutNotify(node.stringIndex);
textField.SetValueWithoutNotify(GetStringIndex(node.stringIndex));
textField.SetEnabled(true);
}
// Start is called before the first frame update
void OnEnable()
{
this.name = "ShaderStrippingConfig";
var tree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Packages/com.utj.stripvariant/Editor/UXML/ConfigUI.uxml");
this.rootVisualElement.Add(tree.CloneTree());
enableToggle = this.rootVisualElement.Q <Toggle>("Enabled");
logToggle = this.rootVisualElement.Q <Toggle>("LogEnable");
strictModeToggle = this.rootVisualElement.Q <Toggle>("StrictVariantStripping");
disableUnityStrip = this.rootVisualElement.Q <Toggle>("DisableUnityStrip");
orderIntField = this.rootVisualElement.Q <IntegerField>("ExecuteOrder");
executeOrderMinBtn = this.rootVisualElement.Q <Button>("ExecOrderMinBtn");
executeOrderMaxBtn = this.rootVisualElement.Q <Button>("ExecOrderMaxBtn");
resetTimestampBtn = this.rootVisualElement.Q <Button>("ResetTimestampBtn");
addExcludeBtn = this.rootVisualElement.Q <Button>("AppendExcludeBtn");
excludeVariantListView = this.rootVisualElement.Q <ListView>("ExcludeList");
debugListViewBtn = this.rootVisualElement.Q <Button>("DebugListProcessorBtn");
enableToggle.SetValueWithoutNotify(StripShaderConfig.IsEnable);
logToggle.SetValueWithoutNotify(StripShaderConfig.IsLogEnable);
strictModeToggle.SetValueWithoutNotify(StripShaderConfig.StrictVariantStripping);
disableUnityStrip.SetValueWithoutNotify(StripShaderConfig.DisableUnityStrip);
orderIntField.SetValueWithoutNotify(StripShaderConfig.Order);
enableToggle.RegisterValueChangedCallback(OnChangeEnabbleToggle);
logToggle.RegisterValueChangedCallback(OnChangeLogEnabbleToggle);
strictModeToggle.RegisterValueChangedCallback(OnChangeStrictModeToggle);
disableUnityStrip.RegisterValueChangedCallback(OnChangeDisableUnityStripToggle);
resetTimestampBtn.clicked += OnClickResetTimestamp;
debugListViewBtn.clicked += OnClickDebugListViewBtn;
orderIntField.RegisterCallback <FocusOutEvent>(OnLostFocusIntField);
executeOrderMinBtn.clicked += OnClickMinButton;
executeOrderMaxBtn.clicked += OnClickMaxButton;
addExcludeBtn.clicked += OnClickAddExclude;
SetUIActiveAtEnabled(enableToggle.value);
SetUIActiveAtStrictMode(strictModeToggle.value);
SetupExcludeRules();
StrippingByVariantCollection.ResetData();
}
private void LinkSliderToFloatField(Slider slider, IntegerField field, Action <int> updatePreferenceAction)
{
slider.valueChanged += (val) =>
{
if (!val.Equals(field.value))
{
var intValue = Mathf.RoundToInt(val);
field.SetValueWithoutNotify(intValue);
updatePreferenceAction(intValue);
}
};
field.OnValueChanged((evt) =>
{
var newValue = evt.newValue;
if (!newValue.Equals(slider.value))
{
newValue = Math.Min(newValue, (int)slider.highValue);
newValue = Math.Max(newValue, (int)slider.lowValue);
slider.value = newValue;
field.SetValueWithoutNotify(newValue);
updatePreferenceAction(newValue);
}
});
}
private void BindElements()
{
var generateButton = this.Q <Button>("GenerateGeometryButton");
generateButton.clickable.clicked += GenerateGeometry;
generateButton.AddManipulator(generateButton.clickable);
var generateAllButton = this.Q <Button>("GenerateGeometryAllButton");
generateAllButton.clickable.clicked += GenerateGeometryAll;
generateAllButton.AddManipulator(generateAllButton.clickable);
m_OutlineDetailField = this.Q <IntegerField>("OutlineDetailField");
m_AlphaToleranceField = this.Q <IntegerField>("AlphaToleranceField");
m_SubdivideField = this.Q <IntegerField>("SubdivideField");
m_Toggle = this.Q <Toggle>("GenerateWeightsField");
var slider = this.Q <Slider>("OutlineDetailSlider");
LinkSliderToFloatField(slider, m_OutlineDetailField, (x) =>
{
GenerateGeomertySettings.outlineDetail = x;
});
m_OutlineDetailField.SetValueWithoutNotify(GenerateGeomertySettings.outlineDetail);
slider.SetValueWithoutNotify(GenerateGeomertySettings.outlineDetail);
slider = this.Q <Slider>("AlphaToleranceSlider");
LinkSliderToFloatField(slider, m_AlphaToleranceField, (x) =>
{
GenerateGeomertySettings.alphaTolerance = x;
});
m_AlphaToleranceField.SetValueWithoutNotify(GenerateGeomertySettings.alphaTolerance);
slider.SetValueWithoutNotify(GenerateGeomertySettings.alphaTolerance);
slider = this.Q <Slider>("SubdivideSlider");
LinkSliderToFloatField(slider, m_SubdivideField, (x) =>
{
GenerateGeomertySettings.subdivide = x;
});
m_SubdivideField.SetValueWithoutNotify(GenerateGeomertySettings.subdivide);
slider.SetValueWithoutNotify(GenerateGeomertySettings.subdivide);
m_Toggle.value = GenerateGeomertySettings.generateWeights;
m_Toggle.OnValueChanged((evt) =>
{
GenerateGeomertySettings.generateWeights = evt.newValue;
});
}
public void Reset()
{
var property = ListElement.ListProperty;
Clear();
if (property.isArray)
{
Controls.DeleteAllButton.SetEnabled(property.arraySize > 0);
var endProperty = property.GetEndProperty();
property.NextVisible(true);
int arrayIndex = 0;
do
{
if (SerializedProperty.EqualContents(property, endProperty))
{
break;
}
switch (property.propertyType)
{
case SerializedPropertyType.ArraySize:
var field = new IntegerField {
bindingPath = property.propertyPath
};
field.SetValueWithoutNotify(property.intValue); // This avoids the OnValueChanged/Rebind feedback loop.
field.style.display = ListElement.ShowSize ? DisplayStyle.Flex : DisplayStyle.None;
field.RegisterValueChangedCallback(UpdateList);
field.label = "Size";
Add(field);
break;
default:
var newItemSection = Controls.ItemSection;
newItemSection.Q <PropertyField>()?.BindProperty(property);
(newItemSection as ItemSection).Index = arrayIndex++;
Add(newItemSection);
break;
}
} while (property.NextVisible(false));
property.Reset();
}
else
{
Add(new Label("Error, Bound item is not a list or array"));
}
}
public override void Enable(bool fromInspector)
{
var indexField = new IntegerField {
label = "index", value = foreachNode.index
};
foreachNode.onProcessed += () => indexField.SetValueWithoutNotify(foreachNode.index);
controlsContainer.Add(indexField);
var countField = new IntegerField {
label = "count", value = foreachNode.count
};
foreachNode.onProcessed += () => countField.SetValueWithoutNotify(foreachNode.count);
controlsContainer.Add(countField);
}
void Reload()
{
foldout.Clear();
lengthField = new IntegerField("Count");
lengthField.SetValueWithoutNotify(value.Count);
lengthField.RegisterCallback <KeyDownEvent>(ChangeCount);
foldout.Add(lengthField);
for (int i = 0; i < value.Count; i++)
{
int j = i;
foldout.Add(ElementExtension.DrawField("element " + j, typeof(E), value[j], _newValue =>
{
value[j] = (E)_newValue;
}));
}
}
public void UpdateFromChildField(string bindingPath, string newValue)
{
while (fieldValues.Count != bindingPathArray.Length)
{
fieldValues.Add("auto");
}
var fieldIndex = Array.IndexOf(bindingPathArray, bindingPath);
fieldValues[fieldIndex] = newValue;
m_LastValidInput = GetFormattedInputString();
m_TextField.SetValueWithoutNotify(m_LastValidInput);
int.TryParse(fieldValues[0], out int intValue);
m_DraggerIntegerField.SetValueWithoutNotify(intValue);
}