public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { if (!_initialized) { Initialize(property); } _listHeight = _reorderableList?.GetHeight() ?? _listHeight; return(base.GetPropertyHeight(property, label) + _listHeight + _spaceAboveControl); }
public void OnGUI() { // Use for debugging // EditorGUILayout.LabelField(m_Property.stringValue); var listRect = GUILayoutUtility.GetRect(200, m_ListView.GetHeight()); listRect = EditorGUI.IndentedRect(listRect); m_ListView.DoList(listRect); if (m_ListView.index >= 0) { for (var i = 0; i < m_SelectedParameterList.Length; i++) { var parameterValue = m_SelectedParameterList[i]; EditorGUI.BeginChangeCheck(); ////TODO: need to detect when value is at default string result = null; if (parameterValue.type == InputControlLayout.ParameterType.Integer) { var intValue = int.Parse(parameterValue.GetValueAsString()); result = EditorGUILayout.IntField(ObjectNames.NicifyVariableName(parameterValue.name), intValue).ToString(); } else if (parameterValue.type == InputControlLayout.ParameterType.Float) { var floatValue = float.Parse(parameterValue.GetValueAsString()); result = EditorGUILayout.FloatField(ObjectNames.NicifyVariableName(parameterValue.name), floatValue).ToString(); } else if (parameterValue.type == InputControlLayout.ParameterType.Boolean) { var boolValue = bool.Parse(parameterValue.GetValueAsString()); result = EditorGUILayout.Toggle(ObjectNames.NicifyVariableName(parameterValue.name), boolValue).ToString(); } if (EditorGUI.EndChangeCheck()) { m_SelectedParameterList[i].SetValue(result); m_Apply(); } } } }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { float h; if (EditorHelper.AssertMultiObjectEditingNotSupportedHeight(property, label, out h)) { return(h); } if (property.isArray) { this.StartOnGUI(property, label); if (_disallowFoldout || property.isExpanded) { h = _lst.GetHeight(); if (_drawElementAtBottom && _lst.index >= 0 && _lst.index < property.arraySize) { var pchild = property.GetArrayElementAtIndex(_lst.index); if (_internalDrawer != null) { h += _internalDrawer.GetPropertyHeight(pchild, label) + BOTTOM_PAD + TOP_PAD; } else if (pchild.hasChildren && pchild.objectReferenceValue is MonoBehaviour) { //we don't draw this way if it's a built-in type from Unity h += SPEditorGUI.GetDefaultPropertyHeight(pchild, label, true) + BOTTOM_PAD + TOP_PAD - EditorGUIUtility.singleLineHeight; } else { h += SPEditorGUI.GetDefaultPropertyHeight(pchild, label, true) + BOTTOM_PAD + TOP_PAD; } } } else { h = EditorGUIUtility.singleLineHeight; } } else { h = EditorGUIUtility.singleLineHeight; } return(h); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(position, label, property); property.serializedObject.Update(); myClassObject = fieldInfo.GetValue(property.serializedObject.targetObject) as MyClass1; myInt = property.FindPropertyRelative("myInt"); myClass2List = property.FindPropertyRelative("MyClass2List"); height = 0; yPos = position.y; position.height = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing; height += position.height + EditorGUIUtility.standardVerticalSpacing;; yPos += position.height + EditorGUIUtility.standardVerticalSpacing;; property.isExpanded = EditorGUI.Foldout(position, property.isExpanded, new GUIContent("Element")); if (property.isExpanded) { subPropsRect = new Rect(position); subPropsRect.x += indent; subPropsRect.width -= indent; intRect = new Rect(subPropsRect); intRect.y = yPos; intRect.height = EditorGUI.GetPropertyHeight(myInt); height += intRect.height + EditorGUIUtility.standardVerticalSpacing * 2; yPos += intRect.height + EditorGUIUtility.standardVerticalSpacing * 2; EditorGUI.PropertyField(intRect, myInt); list = GetNestedReorderableList(myClass2List); listRect = new Rect(subPropsRect); listRect.y = yPos; listRect.height = list.GetHeight(); height += listRect.height + EditorGUIUtility.standardVerticalSpacing; list.DoList(listRect); } property.FindPropertyRelative("elementHeight").floatValue = height + EditorGUIUtility.standardVerticalSpacing; property.serializedObject.ApplyModifiedProperties(); EditorGUI.EndProperty(); }
////TODO: close with escape public override void OnGUI(Rect rect) { m_ScrollPosition = GUI.BeginScrollView(rect, m_ScrollPosition, rect); // Modifiers section. var modifierListRect = rect; modifierListRect.x += kPaddingLeftRight; modifierListRect.y += kPaddingTop; modifierListRect.width -= kPaddingLeftRight * 2; modifierListRect.height = m_ModifierListView.GetHeight(); m_ModifierListView.DoList(modifierListRect); ////TODO: draw box around following section // Chaining toggle. var chainingToggleRect = modifierListRect; chainingToggleRect.y += modifierListRect.height + 5; chainingToggleRect.height = kCombineToggleHeight; ////TODO: disable toggle if property is first in list (bit tricky to find out from the SerializedProperty) var currentCombineSetting = (m_Flags & InputBinding.Flags.ThisAndPreviousCombine) == InputBinding.Flags.ThisAndPreviousCombine; var newCombineSetting = EditorGUI.ToggleLeft(chainingToggleRect, Contents.chain, currentCombineSetting); if (currentCombineSetting != newCombineSetting) { if (newCombineSetting) { m_Flags |= InputBinding.Flags.ThisAndPreviousCombine; } else { m_Flags &= ~InputBinding.Flags.ThisAndPreviousCombine; } m_FlagsProperty.intValue = (int)m_Flags; m_FlagsProperty.serializedObject.ApplyModifiedProperties(); } GUI.EndScrollView(); }
public override void OnGUILayout(SerializedProperty property, GUIContent label) { if (property.isExpanded) { LayoutContainer(() => reorderableList.DoList(position), reorderableList.GetHeight()); if (IsGUI) { var newDataSP = property.FindPropertyRelative("newData"); var newKeySP = newDataSP.FindPropertyRelative("key"); var newValueSP = newDataSP.FindPropertyRelative("value"); var rect = position; rect.width = rect.width - 70F; rect.yMin = rect.yMax - 18F; const float arrowWidth = 20; const float prefixWidth = 65F; var keyWidth = (rect.width - arrowWidth - prefixWidth) * 0.3F; var valueWidth = rect.width - keyWidth - arrowWidth - prefixWidth; EditorGUI.LabelField( new Rect(rect.xMin, rect.yMin, prefixWidth, rect.height), new GUIContent("New Data") ); rect.xMin += prefixWidth; EditorGUI.PropertyField( new Rect(rect.xMin, rect.yMin, keyWidth, rect.height), newKeySP, GUIContent.none ); rect.xMin += keyWidth; EditorGUI.PrefixLabel( new Rect(rect.xMin, rect.yMin, arrowWidth, rect.height), new GUIContent(ArrowText) ); rect.xMin += arrowWidth; EditorGUI.PropertyField( new Rect(rect.xMin, rect.yMin, valueWidth, rect.height), newValueSP, GUIContent.none ); } } else { BetterGUILayout.PropertyField(property, displayLabel); } }
public override void OnGUILayout(SerializedProperty property, GUIContent label) { if (property.isExpanded) { LayoutContainer(() => reorderableList.DoList(position), reorderableList.GetHeight()); if (IsGUI) { var newDataSP = property.FindPropertyRelative("newData"); var rect = position; rect.width -= 70F; rect.yMin = rect.yMax - 18F; EditorGUI.PropertyField(rect, newDataSP); } } else { BetterGUILayout.PropertyField(property, displayLabel); } }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { RestoreState(property); float height = 0f; if (m_ReorderableList != null) { if (!m_ReorderableList.serializedProperty.isExpanded) { return(EditorGUIUtility.singleLineHeight + VerticalSpacing + VerticalSpacing); } height = m_ReorderableList.GetHeight(); height += EditorGUIUtility.singleLineHeight; } return(height + VerticalSpacing); }
/// <inheritdoc /> public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { float eventLineHeight = 0f; if (_displayValueChangedEvent && _isConstant) { int persistentArgumentsCount = 0; SerializedProperty persistentCalls = property.FindPropertyRelative("OnConstantValueChanged._PersistentCalls"); for (int i = 0, condition = persistentCalls.arraySize; i < condition; i++) { SerializedProperty persistentCall = persistentCalls.GetArrayElementAtIndex(i); SerializedProperty persistentArguments = persistentCall.FindPropertyRelative("_PersistentArguments"); persistentArgumentsCount += persistentArguments.arraySize; } ReorderableList eventDrawer = new ReorderableList(property.serializedObject, persistentCalls) { elementHeight = EditorGUIUtility.singleLineHeight * 1.45f, headerHeight = 0f }; SerializedProperty events = property.FindPropertyRelative("OnConstantValueChanged"); eventLineHeight = eventDrawer.GetHeight() - (events.isExpanded ? 0f : EditorGUIUtility.singleLineHeight * Mathf.Max(1, eventDrawer.count) * 1.45f ) + (events.isExpanded ? EditorGUIUtility.singleLineHeight * 1.125f * persistentArgumentsCount : 0f); } return(base.GetPropertyHeight(property, label) + _lineHeight + eventLineHeight); }
public override void OnInspectorGUI() { GUILayout.Space(3); if (repeatNames.Count > 0) { var oldFontStyle = EditorStyles.helpBox.fontStyle; EditorStyles.helpBox.fontStyle = FontStyle.Bold; EditorGUILayout.HelpBox(StringUtil.Contact("There are duplicate field names :\n", string.Join("\n", repeatNames)), MessageType.Error); EditorStyles.helpBox.fontStyle = oldFontStyle; } serializedObject.Update(); var height = Mathf.Min(800, reorderableList.GetHeight()); scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition, GUILayout.Height(height)); reorderableList.DoLayoutList(); EditorGUILayout.EndScrollView(); serializedObject.ApplyModifiedProperties(); if (GUI.changed) { fieldNames.Clear(); repeatNames.Clear(); for (int i = 0; i < luaComponentsProperty.arraySize; i++) { var element = reorderableList.serializedProperty.GetArrayElementAtIndex(i); var nameProperty = element.FindPropertyRelative("name"); if (!string.IsNullOrEmpty(nameProperty.stringValue)) { if (fieldNames.Contains(nameProperty.stringValue)) { if (!repeatNames.Contains(nameProperty.stringValue)) { repeatNames.Add(nameProperty.stringValue); } } else { fieldNames.Add(nameProperty.stringValue); } } } } }
protected override float GetHeight(GUIContent label) { if (Event.current.type == EventType.Layout) { ClearCache(); } float height = 0f; if (_ConditionsList != null) { var oldIndentLevel = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; height = _ConditionsList.GetHeight(); EditorGUI.indentLevel = oldIndentLevel; } return(height); }
/// <summary> /// Draws the properties for the inventory subclass. /// </summary> protected override void DrawInventoryProperties() { if (Foldout("Default Loadout")) { EditorGUI.indentLevel++; if (m_DefaultLoadoutReordableList == null) { var itemListProperty = PropertyFromName("m_DefaultLoadout"); m_DefaultLoadoutReordableList = new ReorderableList(serializedObject, itemListProperty, true, true, true, true); m_DefaultLoadoutReordableList.drawHeaderCallback = OnDefaultLoadoutHeaderDraw; m_DefaultLoadoutReordableList.drawElementCallback = OnDefaultLoadoutElementDraw; } var listRect = GUILayoutUtility.GetRect(0, m_DefaultLoadoutReordableList.GetHeight()); listRect.x += EditorGUI.indentLevel * Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth; listRect.xMax -= EditorGUI.indentLevel * Shared.Editor.Inspectors.Utility.InspectorUtility.IndentWidth; m_DefaultLoadoutReordableList.DoList(listRect); EditorGUI.indentLevel--; } }
public override void Draw() { inPoint.Draw(); outPoint.Draw(); GUI.Box(rect, "", style); EditorGUI.LabelField(new Rect(rect.position + new Vector2(25, 15), new Vector2(size - 50, 20)), "Line Node"); title = GUI.TextField(new Rect(rect.position + new Vector2(25, 35), new Vector2(size - 50, 20)), title); GUI.Label(new Rect(rect.position + new Vector2(25, 65), new Vector2(size - 50, 20)), "ID: " + ID); //NumOfLines = EditorGUI.DelayedIntField(new Rect(rect.position + new Vector2(25, 85), new Vector2(150, 20)), NumOfLines); CallNextNodeImmediately = EditorGUI.ToggleLeft(new Rect(rect.position + new Vector2(25, 85), new Vector2(size - 50, 20)), "Call Next Node Immediately", CallNextNodeImmediately); DenyPlayerInput = EditorGUI.ToggleLeft(new Rect(rect.position + new Vector2(25, 110), new Vector2(size - 50, 20)), "Deny Player Input", DenyPlayerInput); //EditorGUI.PropertyField(new Rect(rect.position + new Vector2(25, 115), new Vector2(150, 20)), (SerializedProperty)Lines, true); size = EditorGUI.Slider(new Rect(rect.position + new Vector2(25, 125), new Vector2(300, 20)), size, 350, 1000); List.DoList(new Rect(rect.position + new Vector2(25, 150), new Vector2(size - 50, 20))); NumOfLines = Lines.Count; rect.size = new Vector2(size, 165 + List.GetHeight()); }
/************************************************************************************************************************/ public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { if (!property.isExpanded) { return(EditorGUIUtility.singleLineHeight); } else { if (!DrawerState.Current.TryBeginEvent(property)) { return(EditorGUIUtility.singleLineHeight); } CachePersistentCallList(property); DrawerState.Current.EndEvent(); return(_CurrentCallList.GetHeight() - 1); } }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { float h; if (EditorHelper.AssertMultiObjectEditingNotSupportedHeight(property, label, out h)) { return(h); } if (property.isArray) { this.StartOnGUI(property, label); if (_disallowFoldout || property.isExpanded) { h = _lst.GetHeight(); if (_drawElementAtBottom && _lst.index >= 0 && _lst.index < property.arraySize) { var pchild = property.GetArrayElementAtIndex(_lst.index); bool cache = pchild.isExpanded; pchild.isExpanded = true; if (_internalDrawer != null) { h += _internalDrawer.GetPropertyHeight(pchild, label) + BOTTOM_PAD; } else { h += SPEditorGUI.GetDefaultPropertyHeight(pchild, label, true) + BOTTOM_PAD; } pchild.isExpanded = cache; } } else { h = EditorGUIUtility.singleLineHeight; } } else { h = EditorGUIUtility.singleLineHeight; } return(h); }
/// <summary> /// Draws the inspector for the ItemIdentifier list. /// </summary> protected override void DrawItemIdentifierInspector() { if (Foldout("Item Definition Amounts")) { EditorGUI.indentLevel++; if (m_ReordableItemAmount == null) { var itemListProperty = PropertyFromName("m_ItemDefinitionAmounts"); m_ReordableItemAmount = new ReorderableList(serializedObject, itemListProperty, true, true, true, true); m_ReordableItemAmount.drawHeaderCallback = OnItemIdentifierAmountHeaderDraw; m_ReordableItemAmount.drawElementCallback = OnItemIdentifierAmountElementDraw; m_ReordableItemAmount.elementHeight = c_SlotRowHeight; } var listRect = GUILayoutUtility.GetRect(0, m_ReordableItemAmount.GetHeight()); listRect.x += EditorGUI.indentLevel * InspectorUtility.IndentWidth; listRect.xMax -= EditorGUI.indentLevel * InspectorUtility.IndentWidth; m_ReordableItemAmount.DoList(listRect); EditorGUI.indentLevel--; } }
public static void DrawList(ReorderableList list, EditorUtils editorUtils) { Rect maskRect; //if (listExpanded) //{ maskRect = EditorGUILayout.GetControlRect(true, list.GetHeight()); list.DoList(maskRect); //} //else //{ // int oldIndent = EditorGUI.indentLevel; // EditorGUI.indentLevel = 1; // listExpanded = EditorGUILayout.Foldout(listExpanded, PropertyCount("SpawnerAdded", (List<SpawnerPresetListEntry>)list.list, editorUtils), true); // maskRect = GUILayoutUtility.GetLastRect(); // EditorGUI.indentLevel = oldIndent; //} //editorUtils.Panel("MaskBaking", DrawMaskBaking, false); }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { float h; if (EditorHelper.AssertMultiObjectEditingNotSupportedHeight(property, label, out h)) { return(h); } if (property.isExpanded) { this.BeginProperty(property, label); h = _lst.GetHeight(); this.EndProperty(); return(h); } else { return(EditorGUIUtility.singleLineHeight); } }
public override void OnInspectorGUI() { serializedObject.Update(); EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(skillNameProp); if (EditorGUI.EndChangeCheck()) { serializedObject.ApplyModifiedProperties(); _skillInfoAsset.name = _skillInfoAsset.skillName.StringValue; var path = AssetDatabase.GetAssetPath(_skillInfoAsset); AssetDatabase.RenameAsset(path, _skillInfoAsset.skillName.StringValue); AssetDatabase.Refresh(); } if (GUILayout.Button("清空触发器列表")) { triggerListProp.arraySize = 0; } var minHeight = Mathf.Min(triggerList.GetHeight(), 400); this.scrolPos = GUILayout.BeginScrollView(this.scrolPos, false, false, GUILayout.ExpandHeight(true), GUILayout.MaxHeight(minHeight)); triggerList.DoLayoutList(); GUILayout.EndScrollView(); if (selectIndex != -1 && selectIndex < triggerList.serializedProperty.arraySize) { var prop = triggerListProp.GetArrayElementAtIndex(selectIndex); var height = EditorGUI.GetPropertyHeight(prop); this.detailPos = GUILayout.BeginScrollView(this.detailPos, false, false, GUILayout.ExpandHeight(true), GUILayout.MaxHeight(height)); var rect = GUILayoutUtility.GetRect(100, height, GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true)); _skillInfoAsset.triggers[selectIndex].OnDrawMoreInfo(prop, rect); GUILayout.EndScrollView(); } serializedObject.ApplyModifiedProperties(); }
protected virtual Rect DrawCollection(Rect position, SerializedProperty property, SerializedProperty collection, GUIContent label) { EditorGUI.BeginProperty(position, new GUIContent(collection.displayName), collection); { Rect foldoutPos = position; foldoutPos.height = EditorGUIUtility.singleLineHeight; collection.isExpanded = EditorGUI.Foldout(foldoutPos, collection.isExpanded, label, true); position.y += EditorGUIUtility.singleLineHeight; DisplayState listState = ReorderableCollection.ListStates[GetFullPath(collection)]; listState.Collection = collection; ReorderableList valuePairList = listState.List.List; valuePairList.serializedProperty = collection; if (collection.isExpanded && collection.isArray) { valuePairList.DoList(position); position.y += valuePairList.GetHeight(); } } EditorGUI.EndProperty(); return(position); }
void DrawDeviceList() { EditorGUILayout.BeginHorizontal(EditorStyles.label); var requirementsLabelSize = EditorStyles.label.CalcSize(m_RequirementGUI); var deviceListRect = GUILayoutUtility.GetRect(GetWindowSize().x - requirementsLabelSize.x - 20, m_DevicesReorderableList.GetHeight()); m_DevicesReorderableList.DoList(deviceListRect); var requirementsHeight = DrawRequirementsCheckboxes(); var listHeight = m_DevicesReorderableList.GetHeight() + EditorGUIUtility.singleLineHeight * 3; if (Event.current.type == EventType.Repaint) { if (listHeight < requirementsHeight) { m_ButtonsAndLabelsHeights += requirementsHeight; } else { m_ButtonsAndLabelsHeights += listHeight; } } EditorGUILayout.EndHorizontal(); }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { SerializedProperty onUPSerialized = property.FindPropertyRelative("onUP"); SerializedProperty onDOWNSerialized = property.FindPropertyRelative("onDOWN"); SerializedProperty onHOLDSerialized = property.FindPropertyRelative("onHOLD"); SerializedProperty elements; ReorderableList list; elements = onUPSerialized.FindPropertyRelative("m_PersistentCalls.m_Calls"); list = new ReorderableList(onUPSerialized.serializedObject, elements, false, true, true, true); list.elementHeight = 43f; //MAGIC NUMBER (see UnityEventDrawer onGUI and GetState) onUPSerializedPropertyHeight = list.GetHeight(); elements = onDOWNSerialized.FindPropertyRelative("m_PersistentCalls.m_Calls"); list = new ReorderableList(onDOWNSerialized.serializedObject, elements, false, true, true, true); list.elementHeight = 43f; onDOWNSerializedPropertyHeight = list.GetHeight(); elements = onHOLDSerialized.FindPropertyRelative("m_PersistentCalls.m_Calls"); list = new ReorderableList(onHOLDSerialized.serializedObject, elements, false, true, true, true); list.elementHeight = 43f; onHOLDSerializedPropertyHeight = list.GetHeight(); return(onUPSerializedPropertyHeight + onDOWNSerializedPropertyHeight + onHOLDSerializedPropertyHeight + 5 * 2f + 16f); //offset + EnumPopup }
/// <inheritdoc/> public override void OnGUI(Rect area, SerializedProperty property, GUIContent label) { _RootProperty = null; base.OnGUI(area, property, label); if (_RootProperty == null || !_RootProperty.isExpanded) { return; } using (DrawerContext.Get(_RootProperty)) { if (Context.Transition == null) { return; } _CurrentChildList = GatherDetails(_RootProperty); var indentLevel = EditorGUI.indentLevel; area.yMin = area.yMax - _CurrentChildList.GetHeight(); EditorGUI.indentLevel++; area = EditorGUI.IndentedRect(area); EditorGUI.indentLevel = 0; _CurrentChildList.DoList(area); EditorGUI.indentLevel = indentLevel; TryCollapseArrays(); } }
void DrawCustomPassReorderableList() { // Sanitize list: for (int i = 0; i < m_SerializedPassVolume.customPasses.arraySize; i++) { if (m_SerializedPassVolume.customPasses.GetArrayElementAtIndex(i) == null) { m_SerializedPassVolume.customPasses.DeleteArrayElementAtIndex(i); serializedObject.ApplyModifiedProperties(); i++; } } float customPassListHeight = m_CustomPassList.GetHeight(); var customPassRect = EditorGUILayout.GetControlRect(false, customPassListHeight); EditorGUI.BeginProperty(customPassRect, GUIContent.none, m_SerializedPassVolume.customPasses); { EditorGUILayout.BeginVertical(); m_CustomPassList.DoList(customPassRect); EditorGUILayout.EndVertical(); } EditorGUI.EndProperty(); }
// ReSharper disable Unity.PerformanceAnalysis internal bool Display(ref Rect position) { var rect = position; var listHeight = reorderableList.GetHeight(); var singleLineHeight = EditorGUIUtility.singleLineHeight; // Reserve space { rect.height = singleLineHeight + 10 + listHeight; GetRect(rect.width, rect.height); position.y += rect.height + 5; } // Background { rect.x += 5; rect.width -= 10; rect.height -= listHeight; DrawRect(rect, DarkGray); } // Transition Header { rect.x += 3; LabelField(rect, "To"); rect.x += 20; LabelField(rect, SerializedTransition.ToState?.objectReferenceValue.name, boldLabel); } // Buttons { bool Button(Rect pos, string icon) { return(GUI.Button(pos, IconContent(icon))); } var buttonRect = new Rect(rect.width - 25, rect.y + 5, 30, 18); //int i, l; { /*var transitions = editor.GetTransitions(SerializedTransition.FromState.objectReferenceValue); * l = transitions.Count - 1; * i = transitions.FindIndex(t => t.Index == SerializedTransition.Index);*/ } // Remove transition if (Button(buttonRect, "Toolbar Minus")) { //editor.RemoveTransition(SerializedTransition); return(true); } buttonRect.x -= 35; // Move transition down /*if (i < l) * { * if (Button(buttonRect, "scrolldown")) * { * editor.ReorderTransition(SerializedTransition, false); * return true; * } * * buttonRect.x -= 35; * }*/ // Move transition up /*if (i > 0) * { * if (Button(buttonRect, "scrollup")) * { * editor.ReorderTransition(SerializedTransition, true); * return true; * } * * buttonRect.x -= 35; * } * * // State editor * if (Button(buttonRect, "SceneViewTools")) * { * editor.DisplayStateEditor(SerializedTransition.ToState.objectReferenceValue); * return true; * }*/ } rect.x = position.x + 5; rect.y += rect.height; rect.width = position.width - 10; rect.height = listHeight; // Display conditions reorderableList.DoList(rect); return(false); }
public override void OnGUI(string searchContext) { if (m_SettingsManager == null) { Initialize(); } // This has to be called to sync all the changes between m_SettingsManager and m_SettingsManagerObject. if (m_SettingsManagerObject.targetObject != null) { m_SettingsManagerObject.Update(); } var noHeightRect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.label, GUILayout.ExpandWidth(true), GUILayout.Height(0)); var width = noHeightRect.width; var totalRect = new Rect(k_Padding, 0f, width - k_Padding, Screen.height); // Draw the toolbar for Android/iOS. var toolBarRect = new Rect(totalRect.x, totalRect.y, totalRect.width, k_ToolbarHeight); var toolbarIndex = GUI.Toolbar(toolBarRect, m_SettingsManager.ToolbarIndex, k_ToolbarStrings); if (toolbarIndex != m_SettingsManager.ToolbarIndex) { m_SettingsManager.ToolbarIndex = toolbarIndex; m_SettingsManager.SaveSettings(); } var notificationSettingsRect = new Rect(totalRect.x, k_ToolbarHeight + 2, totalRect.width, totalRect.height - k_ToolbarHeight - k_Padding); // Draw the notification settings. int drawnSettingsCount = DrawNotificationSettings(notificationSettingsRect, m_SettingsManager.ToolbarIndex); if (drawnSettingsCount <= 0) { return; } float heightPlaceHolder = k_SlotSize; // Draw drawable resources list for Android. if (m_SettingsManager.ToolbarIndex == 0) { var iconListlabelRect = new Rect(notificationSettingsRect.x, notificationSettingsRect.y + 85, 180, k_LabelLineHeight); GUI.Label(iconListlabelRect, "Notification Icons", EditorStyles.label); // Draw the help message for setting the icons. float labelHeight; if (notificationSettingsRect.width > 510) { labelHeight = k_LabelLineHeight * 4; } else if (notificationSettingsRect.width > 500) { labelHeight = k_LabelLineHeight * 5; } else { labelHeight = k_LabelLineHeight * 6; } var iconListMsgRect = new Rect(iconListlabelRect.x, iconListlabelRect.y + iconListlabelRect.height + k_VerticalSeparator, notificationSettingsRect.width, labelHeight); EditorGUI.SelectableLabel(iconListMsgRect, k_InfoStringAndroid, NotificationStyles.k_IconHelpMessageStyle); // Draw the reorderable list for the icon list. var iconListRect = new Rect(iconListMsgRect.x, iconListMsgRect.y + iconListMsgRect.height + k_VerticalSeparator, iconListMsgRect.width, notificationSettingsRect.height - 55f); m_ReorderableList.DoList(iconListRect); heightPlaceHolder += iconListMsgRect.height + m_ReorderableList.GetHeight(); } // We have to do this to occupy the space that ScrollView can set the scrollbars correctly. EditorGUILayout.GetControlRect(true, heightPlaceHolder, GUILayout.MinWidth(width)); }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { ReorderableList list = GetList(property, attribute as ReorderableAttribute, ARRAY_PROPERTY_NAME); return(list != null?list.GetHeight() : EditorGUIUtility.singleLineHeight); }
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { Init(property); return(m_ReorderableList.GetHeight()); }
public void OnSceneGUI() { serializedObject.Update(); Handles.BeginGUI(); // clamp index to valid value m_selectedIndexProp.intValue = Mathf.Clamp(m_selectedIndexProp.intValue, -1, m_target.Tilemaps.Count - 1); m_sceneViewTilemapRList.index = m_selectedIndexProp.intValue; GUI.color = new Color(.75f, .75f, 0.8f, 0.85f); float hOff = m_displayTilemapRList.boolValue? 40f : 20f; m_sceneViewTilemapRList.DoList(new Rect(Screen.width - 300f - 10f, Screen.height - m_sceneViewTilemapRList.GetHeight() - hOff, 300f, 1f)); GUI.color = Color.white; Handles.EndGUI(); TilemapEditor tilemapEditor = GetTilemapEditor(); if (tilemapEditor) { (tilemapEditor as TilemapEditor).OnSceneGUI(); } DoKeyboardChecks(); serializedObject.ApplyModifiedProperties(); }
/// <summary> /// Overrides the rendered height of the property drawer /// </summary> /// <param name="property">Reference to SerializedProperty in question</param> /// <param name="label">Reference to GUIContent</param> /// <returns>Rendered height of the property drawer</returns> public override float GetPropertyHeight(SerializedProperty property, GUIContent label) { return(m_ReorderableList == null?base.GetPropertyHeight(property, label) : m_ReorderableList.GetHeight()); }