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