public SimulatorControlPanel(VisualElement rootElement, DeviceInfo deviceInfo, SystemInfoSimulation systemInfoSimulation, ScreenSimulation screenSimulation, ApplicationSimulation applicationSimulation, SimulationPlayerSettings playerSettings, SimulatorSerializationStates states) { m_RootElement = rootElement; m_DeviceSpecifications = new SimulatorDeviceSpecificationsUI(m_RootElement.Q <Foldout>("device-specifications"), deviceInfo, systemInfoSimulation); m_SimulatorScreenSettings = new SimulatorScreenSettingsUI(m_RootElement.Q <Foldout>("screen-settings"), deviceInfo, screenSimulation, playerSettings); m_SimulatorApplicationSettings = new SimulatorApplicationSettingsUI(m_RootElement.Q <Foldout>("application-settings"), applicationSimulation, states); m_SimulatorExtensions = new SimulatorExtensions(); foreach (var extension in m_SimulatorExtensions.Extensions) { var foldout = new Foldout() { text = extension.extensionTitle, value = false }; foldout.AddToClassList("unity-device-simulator__control-panel_foldout"); m_RootElement.Add(foldout); m_ExtensionFoldouts.Add(extension.GetType().ToString(), foldout); if (states != null && states.extensions.TryGetValue(extension.GetType().ToString(), out var serializedExtension)) { JsonUtility.FromJsonOverwrite(serializedExtension, extension); } extension.OnExtendDeviceSimulator(foldout); } }
public JointField(Asset asset, SerializedProperty property, Asset.Metric metric) { m_Asset = asset; m_Property = property; m_Metric = metric; Foldout foldout = new Foldout { text = "Joints" }; foldout.AddToClassList("jointToggle"); foldout.value = property.isExpanded; Add(foldout); foldout.RegisterValueChangedCallback(evt => ToggleListVisibility()); Add(m_ListView); m_ListView.AddToClassList("jointsListView"); m_ListView.style.display = property.isExpanded ? DisplayStyle.Flex : DisplayStyle.None; Rebuild(); RegisterCallback <AttachToPanelEvent>(OnAttachToPanel); RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel); focusable = true; m_ForceDisabled = false; }
public VisualElement GetVisualElement() { VisualElement visualElement = new VisualElement(); m_NameElement = new Foldout(); m_NameElement.Add(visualElement); visualElement.Add(GetSwapVisualElement()); visualElement.Add(GetNameFieldVisualElement()); visualElement.Add(GeDescriptionFieldVisualElement()); VisualElement actionsElement = new Foldout { text = "Actions" }; actionsElement.Add(GetShapeActionsListVisualElement()); actionsElement.Add(new ValidatorField(m_Stage.NoConflictsBetweenShapeActionsValidator)); actionsElement.Add(GetCreateShapeActionVisualElement()); visualElement.Add(actionsElement); visualElement.Add(GetDeleteStageVisualElement()); m_NameElement.AddToClassList("container"); UpdateName(); return(m_NameElement); }
public HierarchicalComponentContainerElement(HierarchicalComponentContainer <TContainer, TComponent> container, T component, bool optional) { this.AddStyleSheetAndVariant(ClassNames.BaseClassName); m_Container = container; m_IsOptional = optional; AddToClassList(ClassNames.BaseClassName); var componentContainerName = component.GetType().Name; var foldout = new Foldout { text = ObjectNames.NicifyVariableName(componentContainerName) }; foldout.AddToClassList(ClassNames.Component); foldout.AddToClassList(componentContainerName); Add(foldout); var toggle = foldout.Q <Toggle>(); toggle.AddToClassList(ClassNames.Header); m_AddButton = new Button(AddComponent); m_AddButton.AddToClassList(ClassNames.AddComponent); toggle.Add(m_AddButton); m_RemoveButton = new Button(RemoveComponent); m_RemoveButton.AddToClassList(ClassNames.RemoveComponent); toggle.Add(m_RemoveButton); m_Element = new PropertyElement(); m_Element.OnChanged += ElementOnOnChanged; m_Element.SetTarget(component); foldout.contentContainer.Add(m_Element); foldout.contentContainer.AddToClassList(ClassNames.Fields); m_MissingComponentLabel = new Label($"Component of type {typeof(T).Name} is missing"); m_MissingComponentLabel.style.display = DisplayStyle.None; foldout.contentContainer.Add(m_MissingComponentLabel); SetStyle(); }
private Foldout AddHeaderFoldout(VisualElement header, bool expanded) { var foldout = new Foldout { pickingMode = PickingMode.Ignore, value = expanded }; foldout.Query().Descendents <VisualElement>().ForEach(el => el.pickingMode = PickingMode.Ignore); foldout.AddToClassList(itemHeaderFoldoutUssClassName); header.Add(foldout); return(foldout); }
public PageEntry(string templateName, string name, string pagePath, int depth) { this.name = name; this.depth = depth; PagePath = pagePath; FoldOut = new Foldout(); FoldOut.AddToClassList("index-toggle"); FoldOut.AddToClassList(HiddenClass); FoldOut.value = false; Label = new Label(); Label.text = ObjectNames.NicifyVariableName(templateName); Label.AddToClassList(PageClass); Add(FoldOut); Add(Label); AddToClassList(PageHeaderClass); AddToClassList(ElementClass); }
private void InitDeviceSimulatorExtensions() { foreach (var extension in DeviceSimulatorInterfaces.s_DeviceSimulatorExtensions) { var foldout = new Foldout() { text = extension.extensionTitle, value = false }; foldout.AddToClassList("unity-device-simulator__control-panel_foldout"); m_RootElement.Add(foldout); extension.OnExtendDeviceSimulator(foldout); } }
public VisualElement GetVisualElement() { VisualElement visualElement = new VisualElement(); m_NameElement = new Foldout(); m_NameElement.AddToClassList("sub-header-1"); m_NameElement.Add(visualElement); m_NameElement.RegisterCallback <MouseEnterEvent>(_ => OnSelected()); SetBaseVisualElement(visualElement); m_DeleteButton = new Button(() => m_DeleteAction(Blueprint, m_NameElement)); m_DeleteButton.AddToClassList("delete"); visualElement.Add(m_DeleteButton); UpdateName(); UpdateDeleteButton(); return(m_NameElement); }
private VisualElement CreateFoldout(SerializedProperty property) { property = property.Copy(); var foldout = new Foldout() { text = property.localizedDisplayName }; foldout.value = property.isExpanded; foldout.bindingPath = property.propertyPath; foldout.name = "unity-foldout-" + property.propertyPath; var depthStr = property.depth <= ussFoldoutMaxDepth?property.depth.ToString() : "max"; foldout.AddToClassList(ussFoldoutDepthClassName + depthStr); var endProperty = property.GetEndProperty(); property.NextVisible(true); // Expand the first child. do { if (SerializedProperty.EqualContents(property, endProperty)) { break; } var field = new PropertyField(property); field.m_ParentPropertyField = this; field.name = "unity-property-field-" + property.propertyPath; if (field == null) { continue; } foldout.Add(field); }while (property.NextVisible(false)); // Never expand children. return(foldout); }
public override VisualElement Build() { var foldout = new Foldout { text = DisplayName }; Resources.Templates.Explorer.PropertyBag.AddStyles(foldout); foldout.AddToClassList(k_Section); foldout.contentContainer.AddToClassList(k_Content); for (var i = 0; i < Target.Count; ++i) { DoDefaultGuiAtIndex(foldout.contentContainer, i); } if (Target.Count == 0 && !string.IsNullOrEmpty(DrawerAttribute.MessageWhenEmpty)) { var label = new Label(DrawerAttribute.MessageWhenEmpty); label.AddToClassList(k_Empty); foldout.contentContainer.Add(label); } return(foldout); }
public NoiseEditorView(NoiseSettings _noiseUpdateTarget_ = null, NoiseSettings _sourceAsset_ = null) { // create temp noisesettings asset and the IMGUI view for this window m_noiseUpdateTarget = _noiseUpdateTarget_ == null?ScriptableObject.CreateInstance <NoiseSettings>() : _noiseUpdateTarget_; m_serializedNoiseProfile = new SerializedObject(m_noiseUpdateTarget); m_noiseGUI = new NoiseSettingsGUI(); m_noiseGUI.Init(m_noiseUpdateTarget); m_noiseSourceAsset = _sourceAsset_; var stylesheet = EditorGUIUtility.isProSkin ? AssetDatabase.LoadAssetAtPath <StyleSheet>("Packages/com.unity.terrain-tools/Editor/TerrainTools/NoiseLib/Styles/Noise_Dark.uss") : AssetDatabase.LoadAssetAtPath <StyleSheet>("Packages/com.unity.terrain-tools/Editor/TerrainTools/NoiseLib/Styles/Noise_Light.uss"); var settingsScrollView = new ScrollView() { name = Styles.settingsScrollViewName }; /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// var noiseGUIContainer = new IMGUIContainer() { name = Styles.noiseGUIContainerName }; noiseGUIContainer.onGUIHandler = () => { EditorGUI.BeginChangeCheck(); { m_noiseGUI.OnGUI(NoiseSettingsGUIFlags.All & (~NoiseSettingsGUIFlags.Preview)); } bool changed = EditorGUI.EndChangeCheck(); if (changed) { INTERNAL_OnSettingsChanged(); } }; settingsScrollView.Add(noiseGUIContainer); /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// filePanelContainer = new VisualElement() { name = Styles.saveButtonsContainer, style = { flexDirection = FlexDirection.Row } }; filePanelContainer.AddToClassList(Styles.filePanelContainer); saveAsButton = new Button(SaveAsCallback) { name = Styles.saveAsButtonName, text = "Save As", tooltip = Styles.saveasTooltip }; saveAsButton.AddToClassList(Styles.filePanelButton); revertButton = new Button(ResetRevertCallback) { name = Styles.resetButtonName, text = "Reset", tooltip = Styles.resetTooltip }; revertButton.AddToClassList(Styles.filePanelButton); applyButton = new Button(() => { Undo.RecordObject(m_noiseSourceAsset, "NoiseWindow - Apply Settings"); m_noiseSourceAsset.CopySerialized(m_noiseUpdateTarget); }) { name = Styles.applyButtonName, text = "Apply", tooltip = Styles.applyTooltip }; applyButton.AddToClassList(Styles.filePanelButton); applyButton.AddToClassList(Styles.filePanelButton); /////////////////////////////////////////////////////////////////////////////// // noise settings object field /////////////////////////////////////////////////////////////////////////////// var objectFieldContainer = new VisualElement() { name = Styles.objectFieldContainer }; objectFieldContainer.AddToClassList(Styles.objectFieldContainer); objectField = new ObjectField() { name = Styles.noiseAssetFieldName, allowSceneObjects = false, objectType = typeof(NoiseSettings), label = Styles.noiseAssetFieldLabel, tooltip = Styles.noiseAssetFieldTooltip //, // viewDataKey = Styles.noiseAssetFieldName }; objectField.AddToClassList(Styles.noiseAssetFieldName); objectField.RegisterCallback <ChangeEvent <UnityEngine.Object> >(OnSourceProfileChanged); objectFieldContainer.Add(objectField); /////////////////////////////////////////////////////////////////////////////// // export settings /////////////////////////////////////////////////////////////////////////////// var flexArea = new VisualElement() { name = Styles.flexArea }; flexArea.AddToClassList(Styles.flexArea); var exportContainer = new VisualElement() { name = Styles.exportContainer }; exportContainer.AddToClassList(Styles.exportContainer); var exportHeader = new Foldout() { name = Styles.exportHeader, text = "Export Noise to Texture", tooltip = Styles.exportTooltip, viewDataKey = Styles.exportHeader }; exportHeader.RegisterCallback <ChangeEvent <bool> >( (evt) => { if (evt.newValue) { m_exportContainer.Add(m_exportSettings); m_exportContainer.Add(m_exportButton); } else { m_exportContainer.Remove(m_exportSettings); m_exportContainer.Remove(m_exportButton); } } ); exportHeader.AddToClassList(Styles.foldoutContainer); var exportSettings = CreateExportSettingsView(); var exportButton = new Button( () => { if (m_exportType.value == ExportTextureType.Texture2D) { Export2D(); } else if (m_exportType.value == ExportTextureType.Texture3D) { Export3D(); } } ) { name = Styles.exportButton, text = "Export" }; exportButton.AddToClassList(Styles.exportButton); m_exportButton = exportButton; exportContainer.Add(exportHeader); // exportContainer.Add( exportSettings ); // exportContainer.Add( exportButton ); m_exportContainer = exportContainer; exportHeader.value = false; // container for the settings panel var settingsContainer = new VisualElement() { name = Styles.settingsContainerName }; settingsContainer.AddToClassList(Styles.settingsContainerName); settingsContainer.Add(objectFieldContainer); settingsContainer.Add(filePanelContainer); settingsContainer.Add(settingsScrollView); settingsContainer.Add(flexArea); // add this so the export stuff stays at the bottom of the settings container settingsContainer.Add(exportContainer); settingsContainer.Bind(m_serializedNoiseProfile); /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// var previewContainer = new VisualElement() { name = Styles.noisePreviewContainerName }; previewContainer.AddToClassList(Styles.noisePreviewContainerName); var previewLabel = new Label() { name = Styles.noisePreviewLabelName, text = Styles.previewLabel, tooltip = Styles.previewLabelTooltip }; previewLabel.AddToClassList(Styles.noisePreviewLabelName); previewContainer.Add(previewLabel); m_noiseFieldView = new NoiseFieldView(m_serializedNoiseProfile) { name = Styles.noisePreviewTextureName }; m_noiseFieldView.onGUIHandler += () => { INTERNAL_OnSettingsChanged(); }; m_noiseFieldView.AddToClassList(Styles.noisePreviewTextureName); previewContainer.Add(m_noiseFieldView); /////////////////////////////////////////////////////////////////////////////// // wrap it all up /////////////////////////////////////////////////////////////////////////////// styleSheets.Add(stylesheet); AddToClassList(Styles.noiseWindowName); Add(settingsContainer); Add(previewContainer); this.Bind(m_serializedNoiseProfile); m_settingsContainer = settingsContainer; INTERNAL_OnSourceProfileChanged(_sourceAsset_); this.viewDataKey = Styles.noiseWindowName; }
VisualElement GetSettings(GraphData graphData, Action onChange) { var element = new VisualElement() { name = "graphSettings" }; if (graphData.isSubGraph) { return(element); } void RegisterActionToUndo(string actionName) { graphData.owner.RegisterCompleteObjectUndo(actionName); } // Add Label var targetSettingsLabel = new Label("Target Settings"); targetSettingsLabel.style.unityFontStyleAndWeight = FontStyle.Bold; element.Add(new PropertyRow(targetSettingsLabel)); var targetNameList = graphData.validTargets.Select(x => x.displayName); element.Add(new PropertyRow(new Label("Targets")), (row) => { row.Add(new IMGUIContainer(() => { EditorGUI.BeginChangeCheck(); var activeTargetBitmask = EditorGUILayout.MaskField(graphData.activeTargetBitmask, targetNameList.ToArray(), GUILayout.Width(100f)); if (EditorGUI.EndChangeCheck()) { RegisterActionToUndo("Change active Targets"); graphData.activeTargetBitmask = activeTargetBitmask; graphData.UpdateActiveTargets(); m_postChangeTargetSettingsCallback(); } })); }); // Initialize from the active targets whenever user changes them // Is there a way to retain order even with that? if (userOrderedTargetNameList.Count != graphData.activeTargets.Count()) { var activeTargetNames = graphData.activeTargets.Select(x => x.displayName); userOrderedTargetNameList = activeTargetNames.ToList(); } var reorderableTextListView = new ReorderableListView <string>(userOrderedTargetNameList); reorderableTextListView.OnListReorderedCallback += list => { userOrderedTargetNameList = (List <string>)list; onChange(); }; element.Add(reorderableTextListView); // Iterate active TargetImplementations foreach (var targetName in reorderableTextListView.TextList) { // Ensure enabled state is being tracked and get value bool foldoutActive = true; if (!m_TargetFoldouts.TryGetValue(targetName, out foldoutActive)) { m_TargetFoldouts.Add(targetName, foldoutActive); } // Create foldout var foldout = new Foldout() { text = targetName, value = foldoutActive, name = "foldout" }; element.Add(foldout); foldout.AddToClassList("MainFoldout"); foldout.RegisterValueChangedCallback(evt => { // Update foldout value and rebuild m_TargetFoldouts[targetName] = evt.newValue; foldout.value = evt.newValue; onChange(); }); if (foldout.value) { var target = graphData.validTargets.Find(x => x.displayName == targetName); // Get settings for Target var context = new TargetPropertyGUIContext(); target.GetPropertiesGUI(ref context, onChange, RegisterActionToUndo); element.Add(context); } } return(element); }
VisualElement GetSettings(GraphData graphData, Action onChange) { var element = new VisualElement() { name = "graphSettings" }; if (graphData.isSubGraph) { return(element); } void RegisterActionToUndo(string actionName) { graphData.owner.RegisterCompleteObjectUndo(actionName); } // Add Label var targetSettingsLabel = new Label("Target Settings"); targetSettingsLabel.style.unityFontStyleAndWeight = FontStyle.Bold; element.Add(new PropertyRow(targetSettingsLabel)); var targetList = new ReorderableListView <JsonData <Target> >( graphData.m_ActiveTargets, "Active Targets", false, // disallow reordering (active list is sorted) target => target.value.displayName); targetList.GetAddMenuOptions = () => graphData.GetPotentialTargetDisplayNames(); targetList.OnAddMenuItemCallback += (list, addMenuOptionIndex, addMenuOption) => { RegisterActionToUndo("Add Target"); graphData.SetTargetActive(addMenuOptionIndex); m_postChangeTargetSettingsCallback(); }; targetList.RemoveItemCallback += (list, itemIndex) => { RegisterActionToUndo("Remove Target"); graphData.SetTargetInactive(list[itemIndex].value); m_postChangeTargetSettingsCallback(); }; element.Add(targetList); // Iterate active TargetImplementations foreach (var target in graphData.activeTargets) { // Ensure enabled state is being tracked and get value bool foldoutActive; if (!m_TargetFoldouts.TryGetValue(target, out foldoutActive)) { foldoutActive = true; m_TargetFoldouts.Add(target, foldoutActive); } // Create foldout var foldout = new Foldout() { text = target.displayName, value = foldoutActive, name = "foldout" }; element.Add(foldout); foldout.AddToClassList("MainFoldout"); foldout.RegisterValueChangedCallback(evt => { // Update foldout value and rebuild m_TargetFoldouts[target] = evt.newValue; foldout.value = evt.newValue; onChange(); }); if (foldout.value) { // Get settings for Target var context = new TargetPropertyGUIContext(); target.GetPropertiesGUI(ref context, onChange, RegisterActionToUndo); element.Add(context); } } return(element); }
public ArrayElementBuilder(SerializedProperty arrayProperty, FieldData fieldType, Func <string, int, bool, VisualElement> makeItem = null, Action <string, int, bool> on_add_item = null) { m_ArrayProperty = arrayProperty; this.fieldType = fieldType; m_ArrayProperty.serializedObject.Update(); addNewArraySize = m_ArrayProperty.arraySize; AddToClassList("arrayElementBuilder"); // -------------------------------------------- arrayFoldout var arrayFoldout = new Foldout { text = arrayProperty.displayName, name = "arrayFoldout" }; arrayFoldout.AddToClassList("arrayFoldout"); arrayFoldout.value = false; // -------------------------------------------- baseContainer baseContainer = new VisualElement { name = "arrayBaseContainer" }; baseContainer.AddToClassList("arrayBaseContainer"); arrayFoldout.Add(baseContainer); hierarchy.Add(arrayFoldout); // -------------------------------------------- addButton addButton = new Button(AddNewItem) { text = "+", name = "arrayAddButton" }; addButton.AddToClassList("arrayAddButton"); arrayPath = arrayProperty.propertyPath; boundObject = arrayProperty.serializedObject; this.makeItem = makeItem; var property = arrayProperty.Copy(); var endProperty = property.GetEndProperty(); // -------------------------------------------- iterator property.NextVisible(true); do { if (SerializedProperty.EqualContents(property, endProperty)) { break; } if (property.propertyType != SerializedPropertyType.ArraySize) { continue; } arraySize = property.intValue; bindingPath = property.propertyPath; break; } while (property.NextVisible(false)); arrayProperty.serializedObject.SetIsDifferentCacheDirty(); UpdateCreatedItems(); // -------------------------------------------- arrayFooter var arrayFooter = new VisualElement { name = "ArrayFooter" }; arrayFooter.AddToClassList("arrayFooter"); arrayFooterLabel = new Label($"Total: {childCount.ToString()}"); arrayFooterLabel.AddToClassList("arrayFooterLabel"); arrayFooter.Add(arrayFooterLabel); onAddItem = on_add_item; arrayFooter.Add(addButton); arrayFoldout.Add(arrayFooter); m_ArrayProperty.serializedObject.ApplyModifiedProperties(); }
public override VisualElement CreateInspectorGUI() { if (Selection.activeObject is null || Selection.objects.Length == 0) { return(base.CreateInspectorGUI()); } if (!GetType().IsSubclassOf(typeof(ScriptableObject)) || categoryList is null || categoryList.Count == 0) { return(base.CreateInspectorGUI()); } if (!idConfig.AAIConfiguration().enableCustomEditors) { return(base.CreateInspectorGUI()); } var baseStyleSheet = idConfig.GetStyleSheet("AAIDefaultEditorBase"); if (defaultStyleSheet is null) { defaultStyleSheet = idConfig.GetStyleSheet("AAIDefaultEditorStyle"); } if (defaultStyleSheet is null) { Debug.Log("Could not locate AAIDefaultEditorStyle"); } serializedObject.Update(); defaultRoot = new VisualElement(); defaultRoot.styleSheets.Add(baseStyleSheet); defaultRoot.styleSheets.Add(defaultStyleSheet); defaultRoot.AddToClassList("rootContainer"); var boxContainer = new Box(); boxContainer.AddToClassList("mainBoxContainer"); if (beforeDefaultElements == null) { beforeDefaultElements = new VisualElement(); } beforeDefaultElements.name = "beforeDefaultElements"; beforeDefaultElements.AddToClassList("beforeDefaultElements"); defaultRoot.Add(beforeDefaultElements); categoryList.ForEach(x => { if (x is null) { return; } x.AddToClassList("categoryFoldout"); boxContainer.Add(x); }); m_ScrollView = new ScrollView(); boxContainer.Add(m_ScrollView); keyData = classDataDictionary.Keys.ToList(); #region Property Iteration var property = serializedObject.GetIterator(); if (property.NextVisible(true)) { do { // -- Shortening name for ease of typing ------------- var propPath = property.propertyPath; // -- Skip over excluded fields ---------------------- if (excludedFields.Contains(propPath) && serializedObject.targetObject != null) { continue; } // -- Property row VisualElement --------------------- var propertyRow = new VisualElement(); var propertyColumn = new VisualElement(); propertyRow.AddToClassList("propertyRow"); propertyColumn.AddToClassList("propertyColumn"); // -- Property fallback field ------------------------ var propertyField = new PropertyField(property) { name = "PropertyField:" + propPath }; // -- Determine if current property is field data ---- if (!classDataDictionary[Enumerable.First(keyData)].fieldDatas.Keys.Contains(propPath)) { switch (propPath) { case "m_Script" when serializedObject.targetObject != null: propertyField.visible = false; // @formatter:off propertyField.SetEnabled(false); break; default: if (property.IsReallyArray() && serializedObject.targetObject != null) { var copiedProperty = property.Copy(); var imDefaultProperty = new IMGUIContainer(() => { DoDrawDefaultIMGUIProperty(serializedObject, copiedProperty); }) { name = propPath }; m_ScrollView.Add(imDefaultProperty); } break; // @formatter:on } } else { var propertyData = classDataDictionary[Enumerable.First(keyData)].fieldDatas[propPath]; switch (propertyData.fieldInfo) { // -- String/TextField Elements -------------- case FieldInfo a when a.FieldType == typeof(string): case FieldInfo b when b.FieldType == typeof(PropertyName): if (defaultEditorDebug) { Debug.Log($"String: {propPath}"); } var propertyTextLabel = new Label(property.displayName); propertyTextLabel.name = $"{propPath}Label"; var propertyTextField = new TextField { bindingPath = propPath, name = $"{propPath}Text" }; if (propertyData.categoryAttr.toolTip != "") { propertyTextLabel.tooltip = propertyData.categoryAttr.toolTip; propertyTextField.tooltip = propertyData.categoryAttr.toolTip; } propertyTextLabel.AddToClassList("propertyTextLabel"); propertyTextField.AddToClassList("propertyTextField"); propertyRow.Add(propertyTextLabel); propertyRow.Add(propertyTextField); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); break; // -- Integer Elements ----------------------- case FieldInfo a when a.FieldType == typeof(int): if (defaultEditorDebug) { Debug.Log($"Integer: {propPath}"); } var propertyIntegerLabel = new Label(property.displayName); propertyIntegerLabel.name = $"{propPath}Label"; var propertyIntegerField = new IntegerField { bindingPath = propPath, name = $"{propPath}Integer" }; if (propertyData.categoryAttr.toolTip != "") { propertyIntegerLabel.tooltip = propertyData.categoryAttr.toolTip; propertyIntegerField.tooltip = propertyData.categoryAttr.toolTip; } propertyIntegerLabel.AddToClassList("propertyIntegerLabel"); propertyIntegerField.AddToClassList("propertyIntegerField"); propertyRow.Add(propertyIntegerLabel); propertyRow.Add(propertyIntegerField); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); break; // -- Float Elements ------------------------- case FieldInfo a when a.FieldType == typeof(float): if (defaultEditorDebug) { Debug.Log($"Float: {propPath}"); } var propertyFloatLabel = new Label(property.displayName); propertyFloatLabel.name = $"{propPath}Label"; var propertyFloatField = new FloatField { bindingPath = propPath, name = $"{propPath}Float" }; if (propertyData.categoryAttr.toolTip != "") { propertyFloatLabel.tooltip = propertyData.categoryAttr.toolTip; propertyFloatField.tooltip = propertyData.categoryAttr.toolTip; } propertyFloatLabel.AddToClassList("propertyFloatLabel"); propertyFloatField.AddToClassList("propertyFloatField"); propertyRow.Add(propertyFloatLabel); propertyRow.Add(propertyFloatField); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); break; // -- Bool/Toggle Elements ------------------- case FieldInfo a when a.FieldType == typeof(bool): case FieldInfo b when b.FieldType == typeof(Toggle): if (defaultEditorDebug) { Debug.Log($"Toggle: {propPath}"); } var propertyToggleLabel = new Label(property.displayName); propertyToggleLabel.name = $"{propPath}ToggleLabel"; var propertyToggleSpacer = new VisualElement(); var propertyToggleField = new Toggle { bindingPath = propPath, name = $"{propPath}ToggleField" }; if (propertyData.categoryAttr.toolTip != "") { propertyToggleLabel.tooltip = propertyData.categoryAttr.toolTip; propertyToggleField.tooltip = propertyData.categoryAttr.toolTip; } propertyToggleLabel.AddToClassList("propertyToggleLabel"); propertyToggleLabel.AddToClassList("propertyToggleSpacer"); propertyToggleField.AddToClassList("propertyToggleField"); propertyRow.Add(propertyToggleLabel); propertyRow.Add(propertyToggleField); propertyRow.Add(propertyToggleSpacer); propertyRow.RemoveFromClassList("propertyRow"); propertyRow.AddToClassList("propertyToggleRow"); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); break; // -- Dictionary Elements -------------------- case FieldInfo a when typeof(IDictionary).IsAssignableFrom(a.FieldType): case FieldInfo b when typeof(IDictionary).IsSubclassOf(b.FieldType): var dictionaryFoldout = new Foldout { text = property.displayName }; dictionaryFoldout.AddToClassList("arrayFoldout"); dictionaryFoldout.value = false; if (propertyData.categoryAttr.toolTip != "") { dictionaryFoldout.tooltip = propertyData.categoryAttr.toolTip; propertyColumn.tooltip = propertyData.categoryAttr.toolTip; } dictionaryFoldout.Add(propertyField); propertyColumn.Add(dictionaryFoldout); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyColumn); break; // -- List/Set Elements ---------------------- case FieldInfo a when typeof(IList).IsAssignableFrom(a.FieldType): case FieldInfo b when typeof(IList).IsSubclassOf(b.FieldType): case FieldInfo c when typeof(ISet <>).IsAssignableFrom(c.FieldType): case FieldInfo d when typeof(ISet <>).IsSubclassOf(d.FieldType): var arrayElementBuilder = new ArrayElementBuilder(property, propertyData); if (propertyData.categoryAttr.toolTip != "") { propertyRow.tooltip = propertyData.categoryAttr.toolTip; } propertyRow.Add(arrayElementBuilder); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); break; // -- Object Elements ---------------------- case FieldInfo a when a.FieldType == typeof(Object): case FieldInfo b when typeof(Object).IsSubclassOf(b.FieldType): case FieldInfo c when typeof(Object).IsAssignableFrom(c.FieldType): var propertyObjectLabel = new Label(property.displayName); propertyObjectLabel.name = $"{propPath}ObjectLabel"; var propertyObjectField = new ObjectField { objectType = propertyData.fieldType, bindingPath = propPath, name = $"{propPath}ObjectField" }; if (propertyData.categoryAttr.toolTip != "") { propertyObjectLabel.tooltip = propertyData.categoryAttr.toolTip; propertyObjectField.tooltip = propertyData.categoryAttr.toolTip; } propertyObjectLabel.AddToClassList("propertyObjectLabel"); propertyObjectField.AddToClassList("propertyObjectField"); propertyRow.Add(propertyObjectLabel); propertyRow.Add(propertyObjectField); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyRow); if (defaultEditorDebug) { Debug.Log($"Fallback Test: Name: {propPath} Type: {property.type} Array: {property.isArray} : {property.propertyType}"); } break; default: if (property.IsReallyArray()) { propertyColumn.Add(propertyField); boxContainer.Q(propertyData.categoryAttr.category).Add(propertyColumn); } // else propertyColumn.Add(propertyField); // if (propertyData.categoryAttr.toolTip != "") { propertyColumn.tooltip = propertyData.categoryAttr.toolTip; } // // boxContainer.Q(propertyData.categoryAttr.category).Add(propertyColumn); break; } } } while (property.NextVisible(false)); } #endregion foreach (var foldoutList in m_ScrollView.Query <Foldout>().ToList()) { foldoutList.RegisterValueChangedCallback(e => { // TODO Remove this: if (!(e.target is Foldout fd)) { return; } Debug.Log($" {fd.name}"); var path = fd.bindingPath; var container = m_ScrollView.Q <IMGUIContainer>(path); RecomputeSize(container); }); } foreach (var foldoutList in m_ScrollView.Query <AnimatedFoldout>().ToList()) { foldoutList.RegisterValueChangedCallback(e => { // TODO Remove this: if (!(e.target is Foldout fd)) { return; } Debug.Log($" {fd.name}"); var path = fd.bindingPath; var container = m_ScrollView.Q <IMGUIContainer>(path); RecomputeSize(container); }); } VisualElement defaultCategory = null; for (var i = 0; i < categoryList.Count; i++) { VisualElement x; if (isAnimated) { x = categoryList[i].Q <AnimatedFoldout>(); } else { x = categoryList[i].Q <Foldout>(); } if (x.name != "Default") { continue; } defaultCategory = x; break; } if (defaultCategory.childCount == 0) { defaultCategory.style.display = DisplayStyle.None; } if (isAnimated) { var listItems = boxContainer.Query <AnimatedFoldout>().ToList(); listItems.ForEach(x => foldout.Add((AnimatedFoldout)x)); } else { var listItems = boxContainer.Query <Foldout>().ToList(); listItems.ForEach(x => foldout.Add((Foldout)x)); } foldout.ForEach(x => { Toggle toggleItem; if (isAnimated) { var item = (AnimatedFoldout)x; var contentItem = item.Q(null, AnimatedFoldout.expanderUssClassName); contentItem.ToggleInClassList("categoryFoldoutClosed"); item.Q(null, "unity-toggle__checkmark").AddToClassList("toggleCheckmark"); item.RegisterCallback((ChangeEvent <bool> evt) => { var targetElement = evt.target as VisualElement; if (targetElement == item) { item.value = evt.newValue; } if (targetElement.parent == item || targetElement == item || targetElement.contentContainer == item) { item.value = evt.newValue; // if (evt.newValue) item.contentContainer.style.display = DisplayStyle.Flex; // if (!evt.newValue) // @formatter:off // { // item.schedule.Execute(() => // { // item.contentContainer.style.display = DisplayStyle.None; // }).StartingIn(500); // item.schedule.Execute(() => // { // contentItem.style.display = DisplayStyle.None; // }).StartingIn(600); // @formatter:on // } } else { item.expander.TriggerExpanderResize(true); } }); // @formatter:on } else { var item = (Foldout)x; toggleItem = item.Q <Toggle>(); toggleItem.ToggleInClassList("categoryFoldoutClosed"); item.Q(null, "unity-toggle__checkmark").AddToClassList("toggleCheckmark"); } }); serializedObject.ApplyModifiedProperties(); if (afterDefaultElements == null) { afterDefaultElements = new VisualElement(); } afterDefaultElements.name = "afterDefaultElements"; afterDefaultElements.AddToClassList("afterDefaultElements"); boxContainer.Add(afterDefaultElements); defaultRoot.Add(boxContainer); defaultRoot.RegisterCallback <GeometryChangedEvent>(ExecutePostBuildTask); defaultRoot.schedule.Execute(ExecuteLocalDeferredTask).StartingIn(0); return(defaultRoot); }
VisualElement GetSettings(GraphData graphData, Action onChange) { var element = new VisualElement() { name = "graphSettings" }; if (graphData.isSubGraph) { return(element); } void RegisterActionToUndo(string actionName) { graphData.owner.RegisterCompleteObjectUndo(actionName); } // Add Label var targetSettingsLabel = new Label("Target Settings"); targetSettingsLabel.style.unityFontStyleAndWeight = FontStyle.Bold; element.Add(new PropertyRow(targetSettingsLabel)); var targetList = new ReorderableListView <JsonData <Target> >( graphData.m_ActiveTargets, "Active Targets", false, // disallow reordering (active list is sorted) target => target.value.displayName); targetList.GetAddMenuOptions = () => graphData.GetPotentialTargetDisplayNames(); targetList.OnAddMenuItemCallback += (list, addMenuOptionIndex, addMenuOption) => { RegisterActionToUndo("Add Target"); graphData.SetTargetActive(addMenuOptionIndex); m_postChangeTargetSettingsCallback(); }; targetList.RemoveItemCallback += (list, itemIndex) => { RegisterActionToUndo("Remove Target"); graphData.SetTargetInactive(list[itemIndex].value); m_postChangeTargetSettingsCallback(); }; element.Add(targetList); // Iterate active TargetImplementations foreach (var target in graphData.activeTargets) { // Ensure enabled state is being tracked and get value bool foldoutActive; if (!m_TargetFoldouts.TryGetValue(target, out foldoutActive)) { foldoutActive = true; m_TargetFoldouts.Add(target, foldoutActive); } // Create foldout var foldout = new Foldout() { text = target.displayName, value = foldoutActive, name = "foldout" }; element.Add(foldout); foldout.AddToClassList("MainFoldout"); foldout.RegisterValueChangedCallback(evt => { // Update foldout value and rebuild m_TargetFoldouts[target] = evt.newValue; foldout.value = evt.newValue; onChange(); }); if (foldout.value) { // Get settings for Target var context = new TargetPropertyGUIContext(); // Indent the content of the foldout context.globalIndentLevel++; target.GetPropertiesGUI(ref context, onChange, RegisterActionToUndo); context.globalIndentLevel--; element.Add(context); } } #if VFX_GRAPH_10_0_0_OR_NEWER // Inform the user that VFXTarget is deprecated, if they are using one. var activeTargetSRP = graphData.m_ActiveTargets.Where(t => !(t.value is VFXTarget)); if (graphData.m_ActiveTargets.Any(t => t.value is VFXTarget) && //Use Old VFXTarget activeTargetSRP.Any() && activeTargetSRP.All(o => o.value.CanSupportVFX())) { var vfxWarning = new HelpBoxRow(MessageType.Info); var vfxWarningLabel = new Label("The Visual Effect target is deprecated.\n" + "Use the SRP target(s) instead, and enable 'Support VFX Graph' in the Graph Inspector.\n" + "Then, you can remove the Visual Effect Target."); vfxWarningLabel.style.color = new StyleColor(Color.white); vfxWarningLabel.style.whiteSpace = WhiteSpace.Normal; vfxWarning.Add(vfxWarningLabel); element.Add(vfxWarning); } #endif return(element); }