public override void Visit(Node node)
{
var name = node.Children.Single(t => t.NodeType.Equals(NodeType.Identifier)).NodeValue;
var value = node.Children.Single(t => t.NodeType.Equals(NodeType.FieldNumber)).NodeValue;
var number = int.Parse(value);
EnumField = new EnumField(name, number, null);
}
public override void GetControlValue(CodeWriter output,
string className, EnumField f)
{
output.WriteLine("if(combo{0}.SelectedItem != null)", f.Name);
output.Indent++;
output.WriteLine("{0}.{1} = ({2})", className, f.Name, f.EnumType.Name);
output.Indent++;
output.WriteLine("Enum.Parse(typeof({0}), combo{1}.SelectedItem.Value);", f.EnumType, f.Name);
output.Indent--;
output.Indent--;
}
public static VisualElement CreateField(Type t)
{
Type drawerType;
fieldDrawers.TryGetValue(t, out drawerType);
if (drawerType == null)
{
drawerType = fieldDrawers.FirstOrDefault(kp => kp.Key.IsReallyAssignableFrom(t)).Value;
}
if (drawerType == null)
{
return(null);
}
object field;
if (drawerType == typeof(EnumField))
{
field = new EnumField(Activator.CreateInstance(t) as Enum);
}
else
{
try
{
field = Activator.CreateInstance(drawerType,
BindingFlags.CreateInstance |
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.OptionalParamBinding, null,
new object[] { Type.Missing }, CultureInfo.CurrentCulture);
}
catch
{
field = Activator.CreateInstance(drawerType,
BindingFlags.CreateInstance |
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.OptionalParamBinding, null,
new object[] { }, CultureInfo.CurrentCulture);
}
}
// For mutiline
if (field is TextField textField)
{
textField.multiline = true;
}
return(field as VisualElement);
}
private EnumField GetOrCreateEnumField(Enum enumValue)
{
bool isCreation = childCount == 0;
EnumField field = GetOrCreateField <EnumField, Enum>();
if (isCreation)
{
field.Init(enumValue);
}
return(field);
}
public DielectricSpecularControlView(AbstractMaterialNode node, PropertyInfo propertyInfo)
{
m_Node = node;
m_PropertyInfo = propertyInfo;
styleSheets.Add(Resources.Load <StyleSheet>("Styles/Controls/DielectricSpecularControlView"));
m_DielectricMaterial = (DielectricSpecularNode.DielectricMaterial)m_PropertyInfo.GetValue(m_Node, null);
if (propertyInfo.PropertyType != typeof(DielectricSpecularNode.DielectricMaterial))
{
throw new ArgumentException("Property must be of type DielectricMaterial.", "propertyInfo");
}
var enumPanel = new VisualElement {
name = "enumPanel"
};
enumPanel.Add(new Label("Material"));
var enumField = new EnumField(m_DielectricMaterial.type);
enumField.RegisterValueChangedCallback(OnEnumChanged);
enumPanel.Add(enumField);
Add(enumPanel);
m_RangePanel = new VisualElement {
name = "sliderPanel"
};
m_RangePanel.Add(new Label("Range"));
m_RangeSlider = new Slider(0.01f, 1)
{
value = m_DielectricMaterial.range
};
m_RangeSlider.RegisterValueChangedCallback((evt) => OnChangeRangeSlider(evt.newValue));
m_RangePanel.Add(m_RangeSlider);
m_RangeField = AddField(m_RangePanel, m_RangeSlider, 0, m_DielectricMaterial);
m_RangePanel.SetEnabled(m_DielectricMaterial.type == DielectricMaterialType.Common);
Add(m_RangePanel);
m_IORPanel = new VisualElement {
name = "sliderPanel"
};
m_IORPanel.Add(new Label("IOR"));
m_IORSlider = new Slider(1, 2.5f)
{
value = m_DielectricMaterial.indexOfRefraction
};
m_IORSlider.RegisterValueChangedCallback((evt) => OnChangeIORSlider(evt.newValue));
m_IORPanel.Add(m_IORSlider);
m_IORField = AddField(m_IORPanel, m_IORSlider, 1, m_DielectricMaterial);
m_IORPanel.SetEnabled(m_DielectricMaterial.type == DielectricMaterialType.Custom);
Add(m_IORPanel);
}
GetProperties(object component, System.Attribute[] attributes)
{
PropertyDescriptorCollection temp;
List <PropertyDescriptor> tempProps;
ExtensionManager.GetInstance().AddExtensions(component);
tempProps = new List <PropertyDescriptor>();
if (component is ValueField)
{
ValueField vf = (ValueField)component;
foreach (ValueFieldExtension extension in vf.extensions.Values)
{
temp = TypeDescriptor.GetProperties(extension, false);
foreach (PropertyDescriptor p in temp)
{
tempProps.Add(new BoundPropertyDescriptor(extension,
p, attributes));
}
}
}
else if (component is ReferenceField)
{
ReferenceField rf = (ReferenceField)component;
foreach (ReferenceFieldExtension extension in rf.extensions.Values)
{
temp = TypeDescriptor.GetProperties(extension);
foreach (PropertyDescriptor p in temp)
{
tempProps.Add(new BoundPropertyDescriptor(extension,
p, attributes));
}
}
}
else if (component is EnumField)
{
EnumField ef = (EnumField)component;
foreach (EnumFieldExtension extension in ef.extensions.Values)
{
temp = TypeDescriptor.GetProperties(extension);
foreach (PropertyDescriptor p in temp)
{
tempProps.Add(new BoundPropertyDescriptor(extension,
p, attributes));
}
}
}
return(new PropertyDescriptorCollection(tempProps.ToArray()));
}
public override VisualElement CreateInspectorGUI()
{
var rootView = new VisualElement();
string pathUxml = PackagePath + "Editor/MeshSubdivisionRenderer.uxml";
string pathUss = PackagePath + "Editor/MeshSubdivisionRenderer.uss";
var treeAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(pathUxml);
var styleAsset = AssetDatabase.LoadAssetAtPath <StyleSheet>(pathUss);
treeAsset.CloneTree(rootView);
rootView.styleSheets.Add(styleAsset);
_meshTypeEnum = rootView.Q <EnumField>("enumMeshType");
_meshTypeEnum.Init(MeshType.Quad);
_meshTypeEnum.value = GetMeshType((Mesh)_meshProp.objectReferenceValue);
_meshTypeEnum.RegisterCallback <ChangeEvent <Enum> >(
(evt) => OnChangeMesh(evt.newValue));
_meshScaleText = rootView.Q <TextField>("textMeshScale");
_meshScaleText.value = _meshScaleProp.floatValue.ToString();
_meshScaleText.RegisterCallback <ChangeEvent <string> >(
(evt) => OnChangeMeshScale(evt.newValue));
_subdInterpEnum = rootView.Q <EnumField>("enumSubdInterp");
_subdInterpEnum.Init(SubdInterp.None);
_subdInterpEnum.value = GetSubdInterp();
_subdInterpEnum.RegisterCallback <ChangeEvent <Enum> >(
(evt) => OnChangeSubdInterp(evt.newValue));
_cullingToggle = rootView.Q <Toggle>("toggleCulling");
_cullingToggle.value = _doCullingProp.boolValue;
_cullingToggle.RegisterCallback <ChangeEvent <bool> >(
(evt) => OnChangeDoCulling(evt.newValue));
_targetPixelSlider = rootView.Q <SliderInt>("sliderTargetPixel");
_targetPixelSlider.value = _targetPixelSizeProp.intValue;
_targetPixelSlider.RegisterCallback <ChangeEvent <int> >(
(evt) => OnChangeTargetPixelSize(evt.newValue));
_targetPixelText = rootView.Q <TextField>("textTargetPixel");
_targetPixelText.value = _targetPixelSizeProp.intValue.ToString();
_targetPixelText.RegisterCallback <ChangeEvent <string> >(
(evt) => OnChangeTargetPixelSize(evt.newValue));
_debugCameraObject = rootView.Q <ObjectField>("objectDebugCamera");
_debugCameraObject.objectType = typeof(Camera);
_debugCameraObject.value = _debugCameraProp.objectReferenceValue;
_debugCameraObject.RegisterCallback <ChangeEvent <UnityEngine.Object> >(
(evt) => OnChangeDebugCamera(evt.newValue));
return(rootView);
}
static void AddWindow_DebugPointData()
{
//EditorWindow window = new EditorWindow();
EditorWindow.GetWindow <DebugPointData>(false, "调试场景点云");
EditeMapController = GameObject.FindObjectOfType <EditeMapController>();
EditeMapController.InitPointData();
EnumField = new EnumField("111");
for (int i = 0; i < EditeMapController.pointDatas.Count; i++)
{
//EnumField.Add(new VisualElement() { name = EditeMapController.pointDatas[i].mapName })
}
}
public static VisualElement CreateField(Type t, string label)
{
Type drawerType;
fieldDrawers.TryGetValue(t, out drawerType);
if (drawerType == null)
{
drawerType = fieldDrawers.FirstOrDefault(kp => kp.Key.IsReallyAssignableFrom(t)).Value;
}
if (drawerType == null)
{
Debug.LogWarning("Can't find field drawer for type: " + t);
return(null);
}
// Call the constructor that have a label
object field;
if (drawerType == typeof(EnumField))
{
field = new EnumField(label, Activator.CreateInstance(t) as Enum);
}
else
{
try {
field = Activator.CreateInstance(drawerType,
BindingFlags.CreateInstance |
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.OptionalParamBinding, null,
new object[] { label, Type.Missing }, CultureInfo.CurrentCulture);
} catch {
field = Activator.CreateInstance(drawerType,
BindingFlags.CreateInstance |
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.OptionalParamBinding, null,
new object[] { label }, CultureInfo.CurrentCulture);
}
}
// For mutiline
if (field is TextField textField)
{
textField.multiline = true;
}
return(field as VisualElement);
}
private void DrawFields(QualiScorerData qsData)
{
EnumField qualTypeField = new EnumField("type", Qualifier.QualiType.SumOfChildren);
qualTypeField.BindProperty(serData.FindPropertyRelative("qualiType"));
LimitedFloatField thresholdField = new LimitedFloatField("threshold", 0, 1);
thresholdField.BindProperty(serData.FindPropertyRelative("threshold"));
contentContainer.Add(qualTypeField);
contentContainer.Add(thresholdField);
}
/// <summary>
/// Writes control bindings for a EnumField. This even takes into
/// account similar references to reduce resource overhead.
/// </summary>
/// <param name="output">The CodeWriter to output to.</param>
/// <param name="f">EnumField to use.</param>
/// <param name="useTracking">Optionally use the reference list to avoid
/// creating duplicate instances of Managers and collections that would
/// effect performance and database queries.</param>
public virtual void CreateControlBinding(CodeWriter output, EnumField f)
{
if (f.IsClientEditEnabled)
{
output.WriteLine("foreach(string name in Enum.GetNames(typof({0})))",
f.EnumType.Name);
output.Indent++;
output.WriteLine("dd{0}.Items.Add(new ListItem(name, name));", f.Name);
output.Indent--;
output.WriteLine();
}
}
public override void BuildCustomFields(ShaderInput input)
{
m_Keyword = input as ShaderKeyword;
if (m_Keyword == null)
{
return;
}
// KeywordDefinition
var keywordDefinitionField = new EnumField((Enum)m_Keyword.keywordDefinition);
keywordDefinitionField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Keyword Type");
if (m_Keyword.keywordDefinition == (KeywordDefinition)evt.newValue)
{
return;
}
m_Keyword.keywordDefinition = (KeywordDefinition)evt.newValue;
Rebuild();
});
AddRow("Definition", keywordDefinitionField, m_Keyword.isEditable);
// KeywordScope
if (m_Keyword.keywordDefinition != KeywordDefinition.Predefined)
{
var keywordScopeField = new EnumField((Enum)m_Keyword.keywordScope);
keywordScopeField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Keyword Type");
if (m_Keyword.keywordScope == (KeywordScope)evt.newValue)
{
return;
}
m_Keyword.keywordScope = (KeywordScope)evt.newValue;
});
AddRow("Scope", keywordScopeField, m_Keyword.isEditable);
}
switch (m_Keyword.keywordType)
{
case KeywordType.Boolean:
BuildBooleanKeywordField(m_Keyword);
break;
case KeywordType.Enum:
BuildEnumKeywordField(m_Keyword);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public override VisualElement Build()
{
var root = new VisualElement();
DoDefaultGui(root, nameof(AndroidAspectRatio.AspectRatioMode));
DoDefaultGui(root, nameof(AndroidAspectRatio.CustomAspectRatio));
m_AspectRatioMode = root.Q <EnumField>(nameof(AndroidAspectRatio.AspectRatioMode));
m_CustomAspectRatio = root.Q <FloatField>(nameof(AndroidAspectRatio.CustomAspectRatio));
return(root);
}
public SimpleStackNode(MathStackNode node)
{
var visualTree = Resources.Load("SimpleStackNodeHeader") as VisualTreeAsset;
m_Header = visualTree.Instantiate();
m_TitleItem = m_Header.Q <Label>(name: "titleLabel");
m_TitleItem.AddToClassList("label");
m_TitleEditor = m_Header.Q(name: "titleField") as TextField;
m_TitleEditor.AddToClassList("textfield");
m_TitleEditor.visible = false;
m_TitleEditor.RegisterCallback <FocusOutEvent>(e => { OnEditTitleFinished(); });
m_TitleEditor.Q("unity-text-input").RegisterCallback <KeyDownEvent>(OnKeyPressed);
headerContainer.Add(m_Header);
m_OperationControl = m_Header.Q <EnumField>(name: "operationField");
m_OperationControl.Init(MathStackNode.Operation.Addition);
m_OperationControl.value = node.currentOperation;
m_OperationControl.RegisterCallback <ChangeEvent <Enum> >(v =>
{
node.currentOperation = (MathStackNode.Operation)v.newValue;
MathNode mathNode = userData as MathNode;
if (mathNode != null && mathNode.mathBook != null)
{
mathNode.mathBook.inputOutputs.ComputeOutputs();
}
});
var inputPort = InstantiatePort(Orientation.Vertical, Direction.Input, Port.Capacity.Single, typeof(float));
var outputPort = InstantiatePort(Orientation.Vertical, Direction.Output, Port.Capacity.Single, typeof(float));
inputPort.portName = "";
outputPort.portName = "";
inputContainer.Add(inputPort);
outputContainer.Add(outputPort);
RegisterCallback <MouseDownEvent>(OnMouseUpEvent);
userData = node;
viewDataKey = node.nodeID.ToString();
title = node.name;
inputPort.userData = node;
outputPort.userData = node;
}
public static void DrawControl(this FieldControl <bool> control)
{
EnumField input = control.AddBoolean(control.value);
control.eventManager.AddListener <ListItemInputChange>(e => {
if (e.input != input)
{
return;
}
control.value = (BooleanEnum)input.value == BooleanEnum.TRUE ? true : false;
control.eventManager.Raise <FieldControlUpdated <bool> >(new FieldControlUpdated <bool>(control));
});
}
protected void InitEnumControl()
{
EnumField input = AddEnumField(value as Enum);
eventManager.AddListener <ListItemInputChange>(e => {
if (e.input != input)
{
return;
}
value = (T)Enum.Parse(typeof(T), input.value.ToString());
eventManager.Raise <FieldControlUpdated <T> >(new FieldControlUpdated <T>(this));
});
}
public VisualElement Build(InspectorContext <ClassicScriptingSettings> context)
{
var root = new VisualElement();
context.DoDefaultGui(root, nameof(ClassicScriptingSettings.ScriptingBackend));
context.DoDefaultGui(root, nameof(ClassicScriptingSettings.Il2CppCompilerConfiguration));
context.DoDefaultGui(root, nameof(ClassicScriptingSettings.UseIncrementalGC));
m_ScriptingBackend = root.Q <EnumField>(nameof(ClassicScriptingSettings.ScriptingBackend));
m_Il2CppCompilerConfiguration = root.Q <VisualElement>(nameof(ClassicScriptingSettings.Il2CppCompilerConfiguration));
return(root);
}
internal static IDataField CreateDataField(IField field, ModuleSchema schema)
{
return(field switch
{
StringField f => new StringDataField(f),
BooleanField f => new BooleanDataField(f),
NumericField f => new NumericDataField(f),
EnumField f => new EnumDataField(f),
InstrumentField f => new InstrumentDataField(f, schema),
OverlayField f => new OverlayDataField(f, schema),
TempoField f => new TempoDataField(f),
_ => throw new ArgumentException($"Can't handle {field} yet")
});
public override VisualElement Build()
{
VisualElement element = new VisualElement();
EnumField field = new EnumField("ParamType", Target.paramType);
element.Add(field);
EnumField field2 = new EnumField("ParamType", Target.paramType);
element.Add(field2);
return(element);
}
VisualTreeAsset SetUpStaticObject()
{
VisualTreeAsset aAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/UXML Files/StaticObjectEditor.uxml");
mCurrentObjectElement = aAsset.CloneTree();
mSObjSprite = mCurrentObjectElement.Q <ObjectField>("static_object_sprite");
mSObjSprite.objectType = typeof(Sprite);
mSObjSprite.RegisterCallback <ChangeEvent <Object> >((aEv) => GenHelpers.OnSpriteSelection((Sprite)aEv.newValue, mSObjSprite));
mColliderType = mCurrentObjectElement.Q <EnumField>("static_object_collider");
mColliderType.Init(GameScriptable.ColliderType.None);
mColliderType.RegisterCallback <ChangeEvent <System.Enum> >((aEv) => OnColliderTypeChanged((GameScriptable.ColliderType)aEv.newValue));
return(aAsset);
}
/// <summary>
/// Initialize()
/// </summary>
void Initialize()
{
DeviceId = new BaseField <string> (0, this);
MessageId = new BaseField <string> (1, this);
When = new BaseField <double> (2, this);
Condition = new EnumField <StatusEnum> (3, "StatusEnum",
"",
"",
this);
PushFields();
SyncVersion();
}
public EnumField AddEnumField(Enum value, bool alternate = false, bool secondAlternate = false, bool thirdAlternate = false)
{
EnumField el = new EnumField(value);
el.AddToClassList("list-item-input");
el.AddToClassList("list-item-enum-input");
AddAlternates(el, alternate, secondAlternate, thirdAlternate);
el.RegisterValueChangedCallback(e => {
eventManager.Raise <ListItemInputChange>(new ListItemInputChange(el));
});
this.Add(el);
return(el);
}
public VariableField(Guid id)
{
guid = id;
fieldName = $"worldvar-value-field-{worldVars.GetName(guid)}";
AddToClassList(USS_CLASS_NAME);
label = new Label(worldVars.GetName(guid));
Add(label);
// Create the type changer dropdown
typeChoice = new EnumField(worldVars.GetType(guid));
typeChoice.AddToClassList("worldvar-type-dropdown");
Add(typeChoice);
// Register type update callback on dropdown value change
typeChoice.RegisterCallback <ChangeEvent <Enum> >(UpdateWorldvarType);
// Add a type-specific class based on the current type
AddToClassList(TYPE_CLASS_NAME_TEMPLATE + typeChoice.text.ToLower());
// Create a simple container to hold the value field
fieldContainer = new VisualElement();
fieldContainer.AddToClassList("worldvar-value-container");
Add(fieldContainer);
DrawValueField();
// Create a button at the end to remove the variable
var button = new Button()
{
text = "-",
name = $"remove-{worldVars.GetName(guid)}"
};
button.AddToClassList("worldvar-remove-button");
// Method to actually remove it is the Remove() method so link that
button.clickable.clicked += Remove;
Add(button);
// Register to collection change events
worldVars.VariableRemoved += (guid) => {
if (guid == id)
{
RemoveFromHierarchy();
}
};
worldVars.GetVariable(guid).ValueChanged += SetFieldValue;
worldVars.GetVariable(guid).NameChanged += SetLabelText;
worldVars.GetVariable(guid).TypeChanged += OnTypeChange;
}
// ######################## UNITY EVENT FUNCTIONS ######################## //
#region UNITY EVENT FUNCTIONS
public void OnEnable()
{
// show as an utility window with a fixed size
ShowUtility();
minSize = new Vector2(300, 600);
maxSize = minSize;
// Import UXML
VisualTreeAsset visualTreeAsset = Resources.Load <VisualTreeAsset>("ColorPickerWindow_layout");
visualTreeAsset.CloneTree(rootVisualElement);
// load styles
rootVisualElement.styleSheets.Add(Resources.Load <StyleSheet>("ColorPickerWindow_styles"));
rootVisualElement.styleSheets.Add(Resources.Load <StyleSheet>("Styles"));
// get elements
EnumField modeField = rootVisualElement.Q <EnumField>("modeField");
_colorComparisonSwatch = rootVisualElement.Q <ColorComparisonSwatch>();
_hlsWheel = rootVisualElement.Q <ColorWheel>();
_sliderContainer = rootVisualElement.Q("sliderContainer");
_colorSliders[0] = rootVisualElement.Q <ColorSlider>("colorSlider1");
_colorSliders[1] = rootVisualElement.Q <ColorSlider>("colorSlider2");
_colorSliders[2] = rootVisualElement.Q <ColorSlider>("colorSlider3");
_hexField = rootVisualElement.Q <TextField>("hexField");
// add alpha slider
_alphaSlider = new ColorSlider();
_alphaSlider.AddToClassList("color-slider");
_alphaSlider.label = "A";
_alphaSlider.lowValue = 0;
_alphaSlider.highValue = 1;
// register callbacks
_colorComparisonSwatch.OnColorClicked += SetColor;
_hlsWheel.OnColorChanged += UpdateColorFromHslWheel;
_colorSliders[0].RegisterValueChangedCallback(UpdateColorFromSlider0);
_colorSliders[1].RegisterValueChangedCallback(UpdateColorFromSlider1);
_colorSliders[2].RegisterValueChangedCallback(UpdateColorFromSlider2);
_alphaSlider.RegisterValueChangedCallback(UpdateAlpha);
_hexField.RegisterCallback <FocusOutEvent>(UpdateColorFromHex);
// initialize with hsl mode
SetSliderMode(SliderMode.HSL);
UpdateSliders();
// initialize the mode field with the current mode and register to its callback
modeField.Init(_mode);
modeField.RegisterValueChangedCallback(evt => SetSliderMode((SliderMode)evt.newValue));
}
VisualElement CreateGUI(AbstractMaterialNode node, InspectableAttribute attribute, out VisualElement propertyVisualElement)
{
VisualElement nodeSettings = new VisualElement();
var nameLabel = PropertyDrawerUtils.CreateLabel($"{node.name} Node", 0, FontStyle.Bold);
nodeSettings.Add(nameLabel);
if (node.sgVersion < node.latestVersion)
{
var help = HelpBoxRow.TryGetDeprecatedHelpBoxRow($"{node.name} Node", () =>
{
m_setNodesAsDirtyCallback?.Invoke();
node.owner.owner.RegisterCompleteObjectUndo($"Update {node.name} Node");
node.ChangeVersion(node.latestVersion);
inspectorUpdateDelegate?.Invoke();
m_updateNodeViewsCallback?.Invoke();
node.Dirty(ModificationScope.Graph);
});
if (help != null)
{
nodeSettings.Insert(0, help);
}
}
EnumField precisionField = null;
if (node.canSetPrecision)
{
precisionField = new EnumField(node.precision);
var propertyRow = new PropertyRow(new Label("Precision"));
propertyRow.Add(precisionField, (field) =>
{
field.RegisterValueChangedCallback(evt =>
{
if (evt.newValue.Equals(node.precision))
{
return;
}
m_setNodesAsDirtyCallback();
node.owner.owner.RegisterCompleteObjectUndo("Change precision");
node.precision = (Precision)evt.newValue;
node.owner.ValidateGraph();
m_updateNodeViewsCallback();
node.Dirty(ModificationScope.Graph);
});
});
nodeSettings.Add(propertyRow);
}
propertyVisualElement = precisionField;
return(nodeSettings);
}
public override VisualElement Build()
{
var root = new VisualElement();
DoDefaultGui(root, nameof(AndroidIcons.ScreenDPI));
m_ScreenDPI = root.Q <EnumField>(nameof(AndroidIcons.ScreenDPI));
for (int i = 0; i < m_IconsForDPISet.Length; ++i)
{
m_IconsForDPISet[i] = new AndroidIconsForDPISet(this, i);
root.Add(m_IconsForDPISet[i]);
}
return(root);
}
private bool DrawBaseField(FieldInfo fieldInfo, string parentPath, int indent)
{
VisualElement element = null;
var path = (string.IsNullOrEmpty(parentPath)) ? fieldInfo.Name : $"{parentPath}/{fieldInfo.Name}";
if (fieldInfo.FieldType == typeof(int))
{
element = PropertyItem.CreatItem <IntegerField, int>(new IntegerField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(float))
{
element = PropertyItem.CreatItem <FloatField, float>(new FloatField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(string))
{
element = PropertyItem.CreatItem <TextField, string>(new TextField(fieldInfo.Name), _target, path, indent);
}
else if (fieldInfo.FieldType.IsEnum)
{
var field = new EnumField(fieldInfo.Name, (Enum)Activator.CreateInstance(fieldInfo.FieldType));
element = PropertyItem.CreatItem <EnumField, Enum>(field, _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(Object) || fieldInfo.FieldType.IsSubclassOf(typeof(Object)))
{
var field = new ObjectField(fieldInfo.Name)
{
objectType = fieldInfo.FieldType
};
element = PropertyItem.CreatItem <ObjectField, Object>(field, _target, path, indent);
}
else if (fieldInfo.FieldType == typeof(Vector3))
{
var field = new Vector3Field(fieldInfo.Name);
element = PropertyItem.CreatItem <Vector3Field, Vector3>(field, _target, path, indent);
}
if (element != null)
{
if (_container == null)
{
Add(element);
}
else
{
_container.Add(element);
}
return(true);
}
return(false);
}
public DielectricSpecularControlView(AbstractMaterialNode node, PropertyInfo propertyInfo)
{
m_Node = node;
m_PropertyInfo = propertyInfo;
AddStyleSheetPath("Styles/Controls/DielectricSpecularControlView");
m_DielectricMaterial = (DielectricSpecularNode.DielectricMaterial)m_PropertyInfo.GetValue(m_Node, null);
if (propertyInfo.PropertyType != typeof(DielectricSpecularNode.DielectricMaterial))
{
throw new ArgumentException("Property must be of type DielectricMaterial.", "propertyInfo");
}
var enumPanel = new VisualElement {
name = "enumPanel"
};
enumPanel.Add(new Label("Material"));
var enumField = new EnumField(m_DielectricMaterial.type);
enumField.OnValueChanged(OnEnumChanged);
enumPanel.Add(enumField);
Add(enumPanel);
m_RangePanel = new VisualElement {
name = "sliderPanel"
};
m_RangePanel.Add(new Label("Range"));
Action <float> changedRangeSlider = (s) => { OnChangeRangeSlider(s); };
m_RangeSlider = new Slider(0.01f, 1, changedRangeSlider);
m_RangeSlider.value = 0.5f;
m_RangePanel.Add(m_RangeSlider);
m_RangeField = AddField(m_RangePanel, m_RangeSlider, 0, m_DielectricMaterial);
m_RangePanel.SetEnabled(true);
Add(m_RangePanel);
m_IORPanel = new VisualElement {
name = "sliderPanel"
};
m_IORPanel.Add(new Label("IOR"));
Action <float> changedIORSlider = (s) => { OnChangeIORSlider(s); };
m_IORSlider = new Slider(1, 5, changedIORSlider);
m_IORSlider.value = 1;
m_IORPanel.Add(m_IORSlider);
m_IORField = AddField(m_IORPanel, m_IORSlider, 1, m_DielectricMaterial);
m_IORPanel.SetEnabled(false);
Add(m_IORPanel);
}
public EnumControlView(string label, AbstractMaterialNode node, PropertyInfo propertyInfo)
{
m_Node = node;
m_PropertyInfo = propertyInfo;
if (!propertyInfo.PropertyType.IsEnum)
{
throw new ArgumentException("Property must be an enum.", "propertyInfo");
}
Add(new Label(label ?? ObjectNames.NicifyVariableName(propertyInfo.Name)));
var enumField = new EnumField((Enum)m_PropertyInfo.GetValue(m_Node, null));
enumField.OnValueChanged(OnValueChanged);
Add(enumField);
}
public override void CreateControlBinding(CodeWriter output, EnumField f)
{
output.WriteLine("foreach(string name in Enum.GetNames(typeof({0})))",
f.EnumType.Name);
output.WriteLine("{");
output.Indent++;
output.WriteLine("ComponentArt.Web.UI.ComboBoxItem item = new ComponentArt.Web.UI.ComboBoxItem();");
output.WriteLine("item.Text = name;");
output.WriteLine("item.Value = name;");
output.WriteLine("combo{0}.Items.Add(item);", f.Name);
output.Indent--;
output.WriteLine("}");
output.WriteLine();
}
public override void SetControlValue(CodeWriter output,
string className, EnumField f)
{
output.WriteLine("foreach(ComponentArt.Web.UI.ComboBoxItem item in combo{0}.Items)", f.Name);
output.Indent++;
output.WriteLine("if(item.Value == {0}.{1}.ToString())", className, f.Name);
output.WriteLine("{");
output.Indent++;
output.WriteLine("combo{0}.SelectedItem = item;", f.Name);
output.WriteLine("break;");
output.Indent--;
output.WriteLine("}");
output.Indent--;
}
public static Template GetTemplate( Assembly asm )
{
var template = new Template();
// 扫枚举
var r_enums = ( from t in asm.GetTypes() where ( t.IsEnum ) select t ).ToList(); ;
foreach( var r_enum in r_enums )
{
var e = new Enum();
e.IsEnum = true;
e.Name = r_enum.Name.ToString();
e.Namespace = r_enum.Namespace ?? "";
foreach( var r_attribute in r_enum.GetCustomAttributes( false ) )
{
if( r_attribute is LIB.Desc ) e.Desc = ( (LIB.Desc)r_attribute ).Value;
// more class attributes
}
var ut = r_enum.GetEnumUnderlyingType();
e.Type = ut.Name;
switch( ut.Name )
{
case "Byte": e.Size = 1; e.Unsigned = true; break;
case "SByte": e.Size = 1; e.Unsigned = false; break;
case "UInt16": e.Size = 2; e.Unsigned = true; break;
case "Int16": e.Size = 2; e.Unsigned = false; break;
case "UInt32": e.Size = 4; e.Unsigned = true; break;
case "Int32": e.Size = 4; e.Unsigned = false; break;
case "UInt64": e.Size = 8; e.Unsigned = true; break;
case "Int64": e.Size = 8; e.Unsigned = false; break;
}
var r_fields = r_enum.GetFields( BindingFlags.Static | BindingFlags.Public );
foreach( var r_field in r_fields )
{
var ef = new EnumField();
ef.Enum = e;
e.Fields.Add( ef );
foreach( var a in r_field.GetCustomAttributes( false ) )
{
if( a is LIB.Desc ) ef.Desc = ( (LIB.Desc)a ).Value;
// more class attributes
}
ef.Name = r_field.Name;
ef.Value = r_field.GetValue( null ).ToIntegerString( ut );
}
template.Enums.Add( e );
}
// 扫类
var r_classes = from t in asm.GetTypes() where ( t.IsClass || t.IsValueType && !t.IsEnum ) && t.Namespace != libNS select t;
foreach( var r_class in r_classes )
{
var c = new Class();
c.IsEnum = false;
c.Name = r_class.Name;
c.Namespace = r_class.Namespace ?? "";
var cis = r_class.GetInterfaces();
foreach( var r_attribute in r_class.GetCustomAttributes( false ) )
{
if( r_attribute is LIB.Desc ) c.Desc = ( (LIB.Desc)r_attribute ).Value;
}
template.Classes.Add( c );
}
// 自增 type id
ushort tid = 0;
foreach( var c in template.Classes )
{
// 填充自增 TypeID
c.TypeID = tid++;
}
// 继续扫类
foreach( var r_class in r_classes )
{
var c = template.Classes.Find( a => a.Name == r_class.Name && a.Namespace == ( r_class.Namespace ?? "" ) );
// 扫继承字段
var r_fields = r_class.GetFields( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance ).ToList();
if( r_class.BaseType != typeof( object ) )
{
r_fields.InsertRange( 0, r_class.BaseType.GetFields( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance ) );
}
// 扫字段
foreach( var r_field in r_fields )
{
var f = new ClassField { Class = c };
f.Name = r_field.Name;
c.Fields.Add( f );
fillDeclare( template, f.Declare, r_field.FieldType );
}
// 继续扫字段
for( int fidx = 0; fidx < c.Fields.Count; ++fidx )
{
var r_field = r_fields[ fidx ];
var f = c.Fields[ fidx ];
foreach( var r_attribute in r_field.GetCustomAttributes( false ) )
{
if( r_attribute is LIB.Desc ) f.Desc = ( (LIB.Desc)r_attribute ).Value;
else if( r_attribute is LIB.Default ) f.Default = ( (LIB.Default)r_attribute ).Value;
else if( r_attribute is LIB.Get ) f.Get = ( (LIB.Get)r_attribute ).Value;
else if( r_attribute is LIB.Get ) f.Get = ( (LIB.Get)r_attribute ).Value;
else if( r_attribute is LIB.Limit ) { f.Declare.MinLen = ( (LIB.Limit)r_attribute ).Min; f.Declare.MaxLen = ( (LIB.Limit)r_attribute ).Max; }
else if( r_attribute is LIB.Limits ) { fillDeclareLimits( f.Declare, (LIB.Limits)r_attribute ); }
else if( r_attribute is LIB.Condation )
{
var ps = ( (LIB.Condation)r_attribute ).Value;
for( int i=0; i < ps.Length; i += 2 )
{
// todo: 检查如果被引用的 fields 位于当前 field 的后方，条件非法
f.Condation.Add( c.Fields.Find( a => a.Name == (string)ps[ i ] ), ps[ i + 1 ] );
}
}
}
}
}
// 整理命名空间
template.Namespaces = template.Classes.Select( a => a.Namespace ).Concat( template.Enums.Select( a => a.Namespace ) ).Distinct().ToList();
return template;
}
private static void GetSortedEnumFields(
INamedTypeSymbol enumType,
ArrayBuilder<EnumField> enumFields)
{
var underlyingSpecialType = enumType.EnumUnderlyingType.SpecialType;
foreach (var member in enumType.GetMembers())
{
if (member.Kind == SymbolKind.Field)
{
var field = (IFieldSymbol)member;
if (field.HasConstantValue)
{
var enumField = new EnumField(field.Name, EnumUtilities.ConvertEnumUnderlyingTypeToUInt64(field.ConstantValue, underlyingSpecialType), field);
enumFields.Add(enumField);
}
}
}
enumFields.Sort(EnumField.Comparer);
}
