/// <summary> /// Create and show a context menu for adding new Timeline Tracks. /// </summary> protected override void addTrackContext() { TrackGroup trackGroup = TrackGroup.Behaviour as TrackGroup; if(trackGroup != null) { // Get the possible tracks that this group can contain. List<Type> trackTypes = trackGroup.GetAllowedTrackTypes(); GenericMenu createMenu = new GenericMenu(); // Get the attributes of each track. foreach (Type t in trackTypes) { MemberInfo info = t; string label = string.Empty; foreach (TimelineTrackAttribute attribute in info.GetCustomAttributes(typeof(TimelineTrackAttribute), true)) { label = attribute.Label; break; } createMenu.AddItem(new GUIContent(string.Format("Add {0}", label)), false, addTrack, new TrackContextData(label, t, trackGroup)); } createMenu.ShowAsContext(); } }
private void OnAddDropDown(Rect buttonRect, ReorderableList list) { var menu = new GenericMenu(); if (kModule._inputData.Length >= 2) return; if (kModule._inputData.Length == 0) { menu.AddItem(new GUIContent("Right Hand"), false, OnClickHandler, new DataParams() { jointType = KinectUIHandType.Right }); menu.AddItem(new GUIContent("Left Hand"), false, OnClickHandler, new DataParams() { jointType = KinectUIHandType.Left }); } else if (kModule._inputData.Length == 1) { DataParams param; string name; if (kModule._inputData[0].trackingHandType == KinectUIHandType.Left){ param = new DataParams() { jointType = KinectUIHandType.Right }; name = "Right Hand"; } else { param = new DataParams() { jointType = KinectUIHandType.Left }; name = "Left Hand"; } menu.AddItem(new GUIContent(name),false, OnClickHandler, param); } menu.ShowAsContext(); }
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label) { //SerializedProperty me = prop.FindPropertyRelative("this"); //SerializedProperty scale = prop.FindPropertyRelative("scale"); //SerializedProperty curve = prop.FindPropertyRelative("curve"); //EditorGUI.LabelField(pos, "hi" + resources); var rowRect = new Rect(pos.x, pos.y, pos.width, base.GetPropertyHeight(prop, label)); isFoldedOut = EditorGUI.Foldout(new Rect(rowRect.x, rowRect.y, rowRect.width - 20, rowRect.height), isFoldedOut, "Resources"); if (isFoldedOut) { var resources = prop.FindPropertyRelative("Resources"); if (GUI.Button(new Rect(rowRect.x + rowRect.width - 22, rowRect.y + 1, 22, rowRect.height - 2), "+")) { resources.InsertArrayElementAtIndex(resources.arraySize); } rowRect.y += rowRect.height; for (int i = 0; i < resources.arraySize; ++i) { var item = resources.GetArrayElementAtIndex(i); var minusClick = GUI.Button(new Rect(rowRect.x, rowRect.y, 22, rowRect.height), "-"); EditorGUI.PropertyField(new Rect(rowRect.x + 20, rowRect.y, rowRect.width - 21, rowRect.height), item); if (minusClick) { if (Event.current.button == 1) { // Now create the menu, add items and show it var menu = new GenericMenu(); if (i > 0) menu.AddItem(new GUIContent("Move Up"), false, (itm) => { resources.MoveArrayElement((int)itm, (int)itm - 1); }, i); if (i < resources.arraySize - 1) menu.AddItem(new GUIContent("Move Down"), false, (itm) => { resources.MoveArrayElement((int)itm, (int)itm + 1); }, i); menu.ShowAsContext(); } else { resources.DeleteArrayElementAtIndex(i--); } } rowRect.y += rowRect.height; } } }
protected override void showHeaderContextMenu() { GenericMenu createMenu = new GenericMenu(); createMenu.AddItem(new GUIContent("Select"), false, focusActor); createMenu.AddItem(new GUIContent("Delete"), false, delete); createMenu.ShowAsContext(); }
private int controlID; // The control ID for this track control. /// <summary> /// Header Control 3 is typically the "Add" control. /// </summary> /// <param name="position">The position that this control is drawn at.</param> protected override void updateHeaderControl3(UnityEngine.Rect position) { TimelineTrack track = TargetTrack.Behaviour as TimelineTrack; if (track == null) return; Color temp = GUI.color; GUI.color = (track.GetTimelineItems().Length > 0) ? Color.green : Color.red; controlID = GUIUtility.GetControlID(track.GetInstanceID(), FocusType.Passive, position); if (GUI.Button(position, string.Empty, TrackGroupControl.styles.addIcon)) { // Get the possible items that this track can contain. List<Type> trackTypes = track.GetAllowedCutsceneItems(); if (trackTypes.Count == 1) { // Only one option, so just create it. ContextData data = getContextData(trackTypes[0]); if (data.PairedType == null) { addCutsceneItem(data); } else { showObjectPicker(data); } } else if (trackTypes.Count > 1) { // Present context menu for selection. GenericMenu createMenu = new GenericMenu(); foreach (Type t in trackTypes) { ContextData data = getContextData(t); createMenu.AddItem(new GUIContent(string.Format("{0}/{1}", data.Category, data.Label)), false, addCutsceneItem, data); } createMenu.ShowAsContext(); } } // Handle the case where the object picker has a value selected. if (Event.current.type == EventType.ExecuteCommand && Event.current.commandName == "ObjectSelectorClosed") { if (EditorGUIUtility.GetObjectPickerControlID() == controlID) { UnityEngine.Object pickedObject = EditorGUIUtility.GetObjectPickerObject(); if(pickedObject != null) addCutsceneItem(savedData, pickedObject); Event.current.Use(); } } GUI.color = temp; }
void OpenContextMenu() { GenericMenu menu = new GenericMenu(); menu.AddItem (new GUIContent("Open As Floating Window", ""), false, Menu_OpenAsFloatingWindow); menu.AddItem (new GUIContent("Open As Dockable Window", ""), false, Menu_OpenAsDockableWindow); menu.ShowAsContext (); }
public void ClearConnectionMenu() { GenericMenu menu = new GenericMenu (); menu.AddSeparator ("ARE YOU SURE YOU WANT TO CLEAR?"); menu.AddSeparator (""); menu.AddItem(new GUIContent ("Clear"), false, ClearConnections, ""); menu.AddItem(new GUIContent ("Don't Clear"), false, DontClearConnections, ""); menu.ShowAsContext (); }
public static void DrawAddTabGUI(List<AlloyTabAdd> tabsToAdd) { if (tabsToAdd.Count <= 0) { return; } GUI.color = new Color(0.8f, 0.8f, 0.8f, 0.8f); GUILayout.Label(""); var rect = GUILayoutUtility.GetLastRect(); rect.x -= 35.0f; rect.width += 10.0f; GUI.color = Color.clear; bool add = GUI.Button(rect, new GUIContent(""), "Box"); GUI.color = new Color(0.8f, 0.8f, 0.8f, 0.8f); Rect subRect = rect; foreach (var tab in tabsToAdd) { GUI.color = tab.Color; GUI.Box(subRect, "", "ShurikenModuleTitle"); subRect.x += rect.width / tabsToAdd.Count; subRect.width -= rect.width / tabsToAdd.Count; } GUI.color = new Color(0.8f, 0.8f, 0.8f, 0.8f); var delRect = rect; delRect.xMin = rect.xMax; delRect.xMax += 40.0f; if (GUI.Button(delRect, "", "ShurikenModuleTitle") || add) { var menu = new GenericMenu(); foreach (var tab in tabsToAdd) { menu.AddItem(new GUIContent(tab.Name), false, tab.Enable); } menu.ShowAsContext(); } delRect.x += 10.0f; GUI.Label(delRect, "+"); rect.x += EditorGUIUtility.currentViewWidth / 2.0f - 30.0f; // Ensures tab text is always white, even when using light skin in pro. GUI.color = EditorGUIUtility.isProSkin ? new Color(0.7f, 0.7f, 0.7f) : new Color(0.9f, 0.9f, 0.9f); GUI.Label(rect, "Add tab", EditorStyles.whiteLabel); GUI.color = Color.white; }
private void OnEnable() { list = new ReorderableList(serializedObject, serializedObject.FindProperty("Waves"), true, true, true, true); list.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) => { var element = list.serializedProperty.GetArrayElementAtIndex(index); rect.y += 2; EditorGUI.PropertyField(new Rect(rect.x, rect.y, 60, EditorGUIUtility.singleLineHeight), element.FindPropertyRelative("Type"), GUIContent.none); EditorGUI.PropertyField(new Rect(rect.x + 60, rect.y, rect.width - 60 - 30, EditorGUIUtility.singleLineHeight), element.FindPropertyRelative("Prefab"), GUIContent.none); EditorGUI.PropertyField(new Rect(rect.x + rect.width - 30, rect.y, 30, EditorGUIUtility.singleLineHeight), element.FindPropertyRelative("Count"), GUIContent.none); }; list.drawHeaderCallback = (Rect rect) => { EditorGUI.LabelField(rect, "Monster Waves"); }; list.onSelectCallback = (ReorderableList l) => { var prefab = l.serializedProperty.GetArrayElementAtIndex(l.index).FindPropertyRelative("Prefab").objectReferenceValue as GameObject; if (prefab) EditorGUIUtility.PingObject(prefab.gameObject); }; list.onCanRemoveCallback = (ReorderableList l) => { return l.count > 1; }; list.onRemoveCallback = (ReorderableList l) => { if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to delete the wave?", "Yes", "No")) { ReorderableList.defaultBehaviours.DoRemoveButton(l); } }; list.onAddCallback = (ReorderableList l) => { var index = l.serializedProperty.arraySize; l.serializedProperty.arraySize++; l.index = index; var element = l.serializedProperty.GetArrayElementAtIndex(index); element.FindPropertyRelative("Type").enumValueIndex = 0; element.FindPropertyRelative("Count").intValue = 20; element.FindPropertyRelative("Prefab").objectReferenceValue = AssetDatabase.LoadAssetAtPath("Assets/Prefabs/Mobs/Cube.prefab", typeof(GameObject)) as GameObject; }; list.onAddDropdownCallback = (Rect buttonRect, ReorderableList l) => { var menu = new GenericMenu(); var guids = AssetDatabase.FindAssets("", new[]{"Assets/Prefabs/Mobs"}); foreach (var guid in guids) { var path = AssetDatabase.GUIDToAssetPath(guid); menu.AddItem(new GUIContent("Mobs/" + Path.GetFileNameWithoutExtension(path)), false, clickHandler, new WaveCreationParams() {Type = MobWave.WaveType.Mobs, Path = path}); } guids = AssetDatabase.FindAssets("", new[]{"Assets/Prefabs/Bosses"}); foreach (var guid in guids) { var path = AssetDatabase.GUIDToAssetPath(guid); menu.AddItem(new GUIContent("Bosses/" + Path.GetFileNameWithoutExtension(path)), false, clickHandler, new WaveCreationParams() {Type = MobWave.WaveType.Boss, Path = path}); } menu.ShowAsContext(); }; }
void OnGUI() { windowRect = new Rect(0, 0, Screen.width, Screen.height); if(Event.current.type == EventType.ContextClick) { Vector2 mousePos = Event.current.mousePosition; if(windowRect.Contains(mousePos)) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("CreateCube"), false, createMenu, "createCube"); menu.ShowAsContext(); } } }
public static void CreateNodeMenu(Vector2 position, GenericMenu.MenuFunction2 MenuCallback) { GenericMenu menu = new GenericMenu(); var assembly = Assembly.Load(new AssemblyName("Assembly-CSharp")); var paramTypes = (from t in assembly.GetTypes() where t.IsSubclassOfRawGeneric(typeof(AParameterNode<>)) && !t.IsAbstract select t).ToArray(); var flowTypes = (from t in assembly.GetTypes() where t.IsSubclassOfRawGeneric(typeof(AFlowNode)) && !t.IsAbstract select t).ToArray(); foreach(System.Type t in paramTypes) { menu.AddItem(new GUIContent(string.Format("Parameter Nodes/{0}", t.Name)), false, MenuCallback, new NodeCallbackData(position, t)); } foreach(System.Type t in flowTypes) { menu.AddItem(new GUIContent(string.Format("Flow Nodes/{0}", t.Name)), false, MenuCallback, new NodeCallbackData(position, t)); } menu.AddItem(new GUIContent("TaskNode"), false, MenuCallback, new NodeCallbackData(position, typeof(TaskNode))); menu.AddItem(new GUIContent("TreeNode"), false, MenuCallback, new NodeCallbackData(position, typeof(TreeNode))); menu.ShowAsContext(); }
protected override void showBodyContextMenu(Event evt) { MultiCurveTrack itemTrack = TargetTrack.Behaviour as MultiCurveTrack; if (itemTrack == null) return; Behaviour b = DirectorCopyPaste.Peek(); PasteContext pasteContext = new PasteContext(evt.mousePosition, itemTrack); GenericMenu createMenu = new GenericMenu(); if (b != null && DirectorHelper.IsTrackItemValidForTrack(b, itemTrack)) { createMenu.AddItem(new GUIContent("Paste"), false, pasteItem, pasteContext); } else { createMenu.AddDisabledItem(new GUIContent("Paste")); } createMenu.ShowAsContext(); }
protected override void showContextMenu(Behaviour behaviour) { CinemaActorClipCurve clipCurve = behaviour as CinemaActorClipCurve; if (clipCurve == null) return; List<KeyValuePair<string, string>> currentCurves = new List<KeyValuePair<string, string>>(); foreach (MemberClipCurveData data in clipCurve.CurveData) { KeyValuePair<string, string> curveStrings = new KeyValuePair<string, string>(data.Type, data.PropertyName); currentCurves.Add(curveStrings); } GenericMenu createMenu = new GenericMenu(); if (clipCurve.Actor != null) { Component[] components = DirectorHelper.getValidComponents(clipCurve.Actor.gameObject); for (int i = 0; i < components.Length; i++) { Component component = components[i]; MemberInfo[] members = DirectorHelper.getValidMembers(component); for (int j = 0; j < members.Length; j++) { AddCurveContext context = new AddCurveContext(); context.clipCurve = clipCurve; context.component = component; context.memberInfo = members[j]; if (!currentCurves.Contains(new KeyValuePair<string, string>(component.GetType().Name, members[j].Name))) { createMenu.AddItem(new GUIContent(string.Format("Add Curve/{0}/{1}", component.GetType().Name, DirectorHelper.GetUserFriendlyName(component, members[j]))), false, addCurve, context); } } } createMenu.AddSeparator(string.Empty); } createMenu.AddItem(new GUIContent("Copy"), false, copyItem, behaviour); createMenu.AddSeparator(string.Empty); createMenu.AddItem(new GUIContent("Clear"), false, deleteItem, clipCurve); createMenu.ShowAsContext(); }
protected override void showContextMenu(Behaviour behaviour) { CinemaShot shot = behaviour as CinemaShot; if (shot == null) return; Camera[] cameras = GameObject.FindObjectsOfType<Camera>(); GenericMenu createMenu = new GenericMenu(); createMenu.AddItem(new GUIContent("Focus"), false, focusShot, shot); foreach (Camera c in cameras) { ContextSetCamera arg = new ContextSetCamera(); arg.shot = shot; arg.camera = c; createMenu.AddItem(new GUIContent(string.Format(MODIFY_CAMERA, c.gameObject.name)), false, setCamera, arg); } createMenu.AddSeparator(string.Empty); createMenu.AddItem(new GUIContent("Copy"), false, copyItem, behaviour); createMenu.AddSeparator(string.Empty); createMenu.AddItem(new GUIContent("Clear"), false, deleteItem, shot); createMenu.ShowAsContext(); }
void Selector(SerializedProperty property) { GenericMenu menu = new GenericMenu(); AtlasAsset atlasAsset = (AtlasAsset)atlasProp.objectReferenceValue; Atlas atlas = atlasAsset.GetAtlas(); FieldInfo field = typeof(Atlas).GetField("regions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.NonPublic); List<AtlasRegion> regions = (List<AtlasRegion>)field.GetValue(atlas); for (int i = 0; i < regions.Count; i++) { string name = regions[i].name; menu.AddItem(new GUIContent(name), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); } menu.ShowAsContext(); }
void OnCurveGUI(Rect rect, SerializedProperty curve, CurveState state) { // Discard invisible curves if (!state.visible) { return; } var animCurve = curve.animationCurveValue; var keys = animCurve.keys; var length = keys.Length; // Curve drawing // Slightly dim non-editable curves var color = state.color; if (!state.editable) { color.a *= 0.5f; } Handles.color = color; var bounds = settings.bounds; if (length == 0) { var p1 = CurveToCanvas(new Vector3(bounds.xMin, state.zeroKeyConstantValue)); var p2 = CurveToCanvas(new Vector3(bounds.xMax, state.zeroKeyConstantValue)); Handles.DrawAAPolyLine(state.width, p1, p2); } else if (length == 1) { var p1 = CurveToCanvas(new Vector3(bounds.xMin, keys[0].value)); var p2 = CurveToCanvas(new Vector3(bounds.xMax, keys[0].value)); Handles.DrawAAPolyLine(state.width, p1, p2); } else { var prevKey = keys[0]; for (int k = 1; k < length; k++) { var key = keys[k]; var pts = BezierSegment(prevKey, key); if (float.IsInfinity(prevKey.outTangent) || float.IsInfinity(key.inTangent)) { var s = HardSegment(prevKey, key); Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]); } else { Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width); } prevKey = key; } // Curve extents & loops if (keys[0].time > bounds.xMin) { if (state.loopInBounds) { var p1 = keys[length - 1]; p1.time -= settings.bounds.width; var p2 = keys[0]; var pts = BezierSegment(p1, p2); if (float.IsInfinity(p1.outTangent) || float.IsInfinity(p2.inTangent)) { var s = HardSegment(p1, p2); Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]); } else { Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width); } } else { var p1 = CurveToCanvas(new Vector3(bounds.xMin, keys[0].value)); var p2 = CurveToCanvas(keys[0]); Handles.DrawAAPolyLine(state.width, p1, p2); } } if (keys[length - 1].time < bounds.xMax) { if (state.loopInBounds) { var p1 = keys[length - 1]; var p2 = keys[0]; p2.time += settings.bounds.width; var pts = BezierSegment(p1, p2); if (float.IsInfinity(p1.outTangent) || float.IsInfinity(p2.inTangent)) { var s = HardSegment(p1, p2); Handles.DrawAAPolyLine(state.width, s[0], s[1], s[2]); } else { Handles.DrawBezier(pts[0], pts[3], pts[1], pts[2], color, null, state.width); } } else { var p1 = CurveToCanvas(keys[length - 1]); var p2 = CurveToCanvas(new Vector3(bounds.xMax, keys[length - 1].value)); Handles.DrawAAPolyLine(state.width, p1, p2); } } } // Make sure selection is correct (undo can break it) bool isCurrentlySelectedCurve = curve == m_SelectedCurve; if (isCurrentlySelectedCurve && m_SelectedKeyframeIndex >= length) { m_SelectedKeyframeIndex = -1; } // Handles & keys for (int k = 0; k < length; k++) { bool isCurrentlySelectedKeyframe = k == m_SelectedKeyframeIndex; var e = Event.current; var pos = CurveToCanvas(keys[k]); var hitRect = new Rect(pos.x - 8f, pos.y - 8f, 16f, 16f); var offset = isCurrentlySelectedCurve ? new RectOffset(5, 5, 5, 5) : new RectOffset(6, 6, 6, 6); var outTangent = pos + CurveTangentToCanvas(keys[k].outTangent).normalized * 40f; var inTangent = pos - CurveTangentToCanvas(keys[k].inTangent).normalized * 40f; var inTangentHitRect = new Rect(inTangent.x - 7f, inTangent.y - 7f, 14f, 14f); var outTangentHitrect = new Rect(outTangent.x - 7f, outTangent.y - 7f, 14f, 14f); // Draw if (state.showNonEditableHandles) { if (e.type == EventType.repaint) { var selectedColor = (isCurrentlySelectedCurve && isCurrentlySelectedKeyframe) ? settings.selectionColor : state.color; // Keyframe EditorGUI.DrawRect(offset.Remove(hitRect), selectedColor); // Tangents if (isCurrentlySelectedCurve && (!state.onlyShowHandlesOnSelection || (state.onlyShowHandlesOnSelection && isCurrentlySelectedKeyframe))) { Handles.color = selectedColor; if (k > 0 || state.loopInBounds) { Handles.DrawAAPolyLine(state.handleWidth, pos, inTangent); EditorGUI.DrawRect(offset.Remove(inTangentHitRect), selectedColor); } if (k < length - 1 || state.loopInBounds) { Handles.DrawAAPolyLine(state.handleWidth, pos, outTangent); EditorGUI.DrawRect(offset.Remove(outTangentHitrect), selectedColor); } } } } // Events if (state.editable) { // Keyframe move if (m_EditMode == EditMode.Moving && e.type == EventType.MouseDrag && isCurrentlySelectedCurve && isCurrentlySelectedKeyframe) { EditMoveKeyframe(animCurve, keys, k); } // Tangent editing if (m_EditMode == EditMode.TangentEdit && e.type == EventType.MouseDrag && isCurrentlySelectedCurve && isCurrentlySelectedKeyframe) { bool alreadyBroken = !(Mathf.Approximately(keys[k].inTangent, keys[k].outTangent) || (float.IsInfinity(keys[k].inTangent) && float.IsInfinity(keys[k].outTangent))); EditMoveTangent(animCurve, keys, k, m_TangentEditMode, e.shift || !(alreadyBroken || e.control)); } // Keyframe selection & context menu if (e.type == EventType.mouseDown && rect.Contains(e.mousePosition)) { if (hitRect.Contains(e.mousePosition)) { if (e.button == 0) { SelectKeyframe(curve, k); m_EditMode = EditMode.Moving; e.Use(); } else if (e.button == 1) { // Keyframe context menu var menu = new GenericMenu(); menu.AddItem(new GUIContent("Delete Key"), false, (x) => { var action = (MenuAction)x; var curveValue = action.curve.animationCurveValue; action.curve.serializedObject.Update(); RemoveKeyframe(curveValue, action.index); m_SelectedKeyframeIndex = -1; SaveCurve(action.curve, curveValue); action.curve.serializedObject.ApplyModifiedProperties(); }, new MenuAction(curve, k)); menu.ShowAsContext(); e.Use(); } } } // Tangent selection & edit mode if (e.type == EventType.mouseDown && rect.Contains(e.mousePosition)) { if (inTangentHitRect.Contains(e.mousePosition) && (k > 0 || state.loopInBounds)) { SelectKeyframe(curve, k); m_EditMode = EditMode.TangentEdit; m_TangentEditMode = Tangent.In; e.Use(); } else if (outTangentHitrect.Contains(e.mousePosition) && (k < length - 1 || state.loopInBounds)) { SelectKeyframe(curve, k); m_EditMode = EditMode.TangentEdit; m_TangentEditMode = Tangent.Out; e.Use(); } } // Mouse up - clean up states if (e.rawType == EventType.MouseUp && m_EditMode != EditMode.None) { m_EditMode = EditMode.None; } // Set cursors { EditorGUIUtility.AddCursorRect(hitRect, MouseCursor.MoveArrow); if (k > 0 || state.loopInBounds) { EditorGUIUtility.AddCursorRect(inTangentHitRect, MouseCursor.RotateArrow); } if (k < length - 1 || state.loopInBounds) { EditorGUIUtility.AddCursorRect(outTangentHitrect, MouseCursor.RotateArrow); } } } } Handles.color = Color.white; SaveCurve(curve, animCurve); }
// Handles mouse operations void InputEvents(Event e) { // Events mousePos = e.mousePosition; // Mouse Events Node clickedNode = null; if (e.type == EventType.MouseDown) { if (coreSystem != null && !EditorApplication.isPlaying) { clickedNode = NodeAtPosition(mousePos); if (clickedNode == null) { clickedConnector = ConAtPosition(mousePos); } } if (clickedNode != null && !EditorApplication.isPlaying) { // Click on a Node if (e.button == 0) { // Left Click -> Window Drag. Handled by Unity } else if (e.button == 1) { if (clickedNode is StartAINode) { } else { // Right click -> Node delete customMenu.Call(ContextCallback, "Delete Node", "Duplicate Node"); e.Use(); } } } else if (clickedConnector.active && !EditorApplication.isPlaying) { // Click on Connector // Store really clicked connector. Because clickedConnector might change below reallyClickedConnector = clickedConnector.connector; // Break old Connection(s) if there are some if (clickedConnector.connector.connections.Count > 0) { Undo.RegisterCompleteObjectUndo(clickedConnector.connector, "Disconnect Nodes"); Connector otherConnector = clickedConnector.connector.Break(); if (otherConnector != null) { // The Curve Handle should now be detatched from Connector, // And still be connected with the Connector on the other Node clickedConnector = ConAtPosition(otherConnector.GetRect().center); } } } else { // Click on empty Canvas (no Node, not sideWindow) if (e.button == 2 || e.button == 0) { Rect rect = new Rect(sideWindow.opened ? position.width - 220 : position.width - 20, 0f, 220, position.height); if (!rect.Contains(mousePos)) { // Left/Middle Click -> Start scrolling scrollWindow = true; e.delta = new Vector2(0, 0); } } else if (e.button == 1) { if (SelectedObject != null && coreSystem == null) { CreateEasyAISystem(); EditorGUIUtility.ExitGUI(); } // new menu system // Now create the menu, add items and show it NEED TO CHANGE TO CUSTOM GENERIC MENU GenericMenu menu = new GenericMenu(); // no gameobject selected in scene if (coreSystem == null) { menu.AddItem(new GUIContent("Create GameObject"), false, ContextCallback, "Create GameObject"); } else { coreSystem.zoomFactor = 1f; foreach (var item in nodes.Keys) { menu.AddItem(new GUIContent(item.ToString()), false, ContextCallback, item.ToString()); } } menu.ShowAsContext(); e.Use(); // Right click -> Editor Context Click //customMenu.Call(ContextCallback, nodes.Keys.ToArray()); //e.Use (); } } } else if (e.type == EventType.MouseUp) { // Left/Middle click up if (e.button == 2 || e.button == 0) { // Connect 2 Nodes, if possible if (clickedConnector.active) { ConHandle secondHandle = ConAtPosition(mousePos); if (secondHandle.active) { if (clickedConnector.node != secondHandle.node) { // If Mouse Click and Release on the same Connector, connect them but don't record UNDO if (secondHandle.connector != reallyClickedConnector) { Undo.RegisterCompleteObjectUndo(clickedConnector.connector, "Connect Nodes"); Undo.RegisterCompleteObjectUndo(secondHandle.connector, "Connect Nodes"); } if (clickedConnector.connector.color == secondHandle.connector.color) { // Connect both Connectors to each other. clickedConnector.connector.ConnectTo(secondHandle.connector); } // // RECALCULE NODES //clickedConnector.node.CalculateNode(); //secondHandle.node.CalculateNode(); } } // // RECALCULE NODES //if (clickedConnector.node != null) clickedConnector.node.CalculateNode(); //if (secondHandle.node != null) secondHandle.node.CalculateNode(); // recalcule all nodes ONLY FOR TEST foreach (var item in coreSystem.nodes) { item.CalculateNode(); } } // Stop scrolling clickedConnector.active = false; scrollWindow = false; } } else if (e.type == EventType.ScrollWheel) { if (e.delta.y > 1 && coreSystem.zoomFactor < 1f) { coreSystem.zoomFactor = coreSystem.zoomFactor + 0.1f; } else if (e.delta.y < 0 && coreSystem.zoomFactor > 0.4f) { coreSystem.zoomFactor = coreSystem.zoomFactor - 0.1f; } } // Scroll Mainwindow if (scrollWindow) { // Change Window and Nodes by Mouse delta (difference to last rendered position) scrollOffset += e.delta / 2; if (coreSystem != null) { foreach (Node n in coreSystem.nodes) { n.rect.position += e.delta / 2; } } //Repaint(); } }
private void HandleKeyHandlerGUI(GUIContent name, Utils.KeyHandler keyHandler, GUISkin skin) { const int keyButtonWidth = 90; GUILayout.BeginHorizontal(); { keyHandler.Enable = GUI.Toggle(name, keyHandler.Enable, skin.button, GUI.Align(skin.label, TextAnchor.MiddleLeft), new GUILayoutOption[] { GUILayout.Width(ToggleButtonSize), GUILayout.Height(ToggleButtonSize) }, new GUILayoutOption[] { GUILayout.Height(ToggleButtonSize) }); GUILayout.FlexibleSpace(); UnityEngine.GUI.enabled = keyHandler.Enable; for (int iKey = 0; iKey < keyHandler.NumKeyCodes; ++iKey) { GUIContent buttonLabel = keyHandler.IsDetectingKey(iKey) ? GUI.MakeLabel("Detecting...") : GUI.MakeLabel(keyHandler.Keys[iKey].ToString()); bool toggleDetecting = GUILayout.Button(buttonLabel, skin.button, GUILayout.Width(keyButtonWidth), GUILayout.Height(ToggleButtonSize)); if (toggleDetecting) { keyHandler.DetectKey(this, !keyHandler.IsDetectingKey(iKey), iKey); } } Rect dropDownButtonRect = new Rect(); GUILayout.BeginVertical(GUILayout.Height(ToggleButtonSize)); { GUIStyle tmp = new GUIStyle(skin.button); tmp.fontSize = 6; m_showDropDown = GUILayout.Button(GUI.MakeLabel("v", true), tmp, GUILayout.Width(16), GUILayout.Height(14)) ? !m_showDropDown : m_showDropDown; dropDownButtonRect = GUILayoutUtility.GetLastRect(); GUILayout.FlexibleSpace(); } GUILayout.EndVertical(); UnityEngine.GUI.enabled = true; if (m_showDropDown && dropDownButtonRect.Contains(Event.current.mousePosition)) { GenericMenu menu = new GenericMenu(); menu.AddItem(GUI.MakeLabel("Reset to default"), false, () => { if (EditorUtility.DisplayDialog("Reset to default", "Reset key(s) to default?", "OK", "Cancel")) { keyHandler.ResetToDefault(); } }); menu.AddItem(GUI.MakeLabel("Add key"), false, () => { keyHandler.Add(KeyCode.None); }); if (keyHandler.NumKeyCodes > 1) { menu.AddItem(GUI.MakeLabel("Remove key"), false, () => { if (EditorUtility.DisplayDialog("Remove key", "Remove key: " + keyHandler[keyHandler.NumKeyCodes - 1].ToString() + "?", "OK", "Cancel")) { keyHandler.Remove(keyHandler.NumKeyCodes - 1); } }); } menu.ShowAsContext(); } } GUILayout.EndHorizontal(); if (UnityEngine.GUI.changed) { EditorUtility.SetDirty(this); } }
void OnGUI() { if (EditorApplication.isPlaying) { return; } if (!layerObject) { return; } layerObject.getRoot();//trigger lazy creation of the root object drawState.layerObject = layerObject; switch (Event.current.type) { case EventType.KeyDown: { if (Event.current.keyCode == KeyCode.Delete) { if ((null != SelectedNode) && !(SelectedNode is RootNode)) { Undo.RecordObject(layerObject, "Delete Node"); { layerObject.nodes.Remove(SelectedNode); foreach (var node in layerObject.nodes) { for (int i = 0; i < node.inputs.Count; i++) { var nodeInput = node.inputs[i]; if (nodeInput.inputNode == SelectedNode) { node.inputs.RemoveAt(i); i--; } } } } Undo.FlushUndoRecordObjects(); SelectedNode = null; Event.current.Use(); } } break; } case EventType.MouseDown: { if (Event.current.button == 2) //Middle mouse button { drawState.scrollStart = Event.current.mousePosition; drawState.scrolling = true; drawState.scrollOffset = Vector2.zero; Event.current.Use(); } break; } case EventType.MouseUp: { if (Event.current.button == 2) //Middle mouse button { drawState.scrolling = false; drawState.guiOffset += drawState.scrollOffset; drawState.scrollOffset = Vector2.zero; Event.current.Use(); } break; } case EventType.MouseDrag: { if (drawState.scrolling) { drawState.scrollOffset = Event.current.mousePosition - drawState.scrollStart; } break; } case EventType.ContextClick: { drawState.menuPos = Event.current.mousePosition; GenericMenu menu = new GenericMenu(); foreach (Type type in Assembly.GetAssembly(typeof(RecipeLayerBase)).GetTypes() .Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(BaseNode)))) { if (type != typeof(RootNode)) { menu.AddItem(new GUIContent(Utilities.MakeNiceName(type.Name)), false, NodeCreateCallback, type); } } menu.ShowAsContext(); Event.current.Use(); break; } } if (null != SelectedNode) { if (!(SelectedNode is RootNode)) { SerializedObject nodeObject = new SerializedObject(SelectedNode); var nameProp = nodeObject.FindProperty("nodeName"); nameProp.stringValue = DefaultNodeRenderer.DrawLabelEdit(SelectedNode, drawState, nameProp.stringValue); nodeObject.ApplyModifiedProperties(); } } { BeginWindows(); if (Event.current.type == EventType.Layout) { drawState.windowData.Clear(); } int id = 0; Event currentEvent = Event.current; drawState.menuPos = currentEvent.mousePosition; foreach (var node in layerObject.nodes) { BaseNodeRenderer.NodeDrawState.WindowData d = new BaseNodeRenderer.NodeDrawState.WindowData(); if (Event.current.type == EventType.Layout) { d.pos = node.nodePosition + drawState.guiOffset + drawState.scrollOffset; drawState.windowData.Add(d); } else { d = drawState.windowData[id]; } //update the window positions iff we are currently scrolling the view if (drawState.scrolling && Event.current.type == EventType.MouseDrag) { d.pos = node.nodePosition + drawState.guiOffset + drawState.scrollOffset; drawState.windowData[id] = d; } BaseNodeRenderer nodeRenderer = RendererFactory.getRenderer(node); Rect windowRect = new Rect(d.pos, nodeRenderer.getNodeSize(node).size); SerializedObject nodeObject = new SerializedObject(node); var posProp = nodeObject.FindProperty("nodePosition"); windowRect = GUI.Window(id, windowRect, DrawNodeWindow, "", GUIStyle.none); posProp.vector2Value = windowRect.position - drawState.guiOffset - drawState.scrollOffset; nodeObject.ApplyModifiedProperties(); id++; } EndWindows();//triggers the actual drawing of the windows, anything drawn after this will be drawn above all the windows } if (drawState.connectivityChange) { refreshShader = true; drawState.connectivityChange = false; } switch (Event.current.type) { case EventType.MouseUp: { drawState.drawCurve = false; break; } case EventType.Repaint: { foreach (var node in layerObject.nodes) { BaseNodeRenderer nodeRenderer = RendererFactory.getRenderer(node); var nodeSize = nodeRenderer.getNodeSize(node); int i = 0; foreach (var input in node.inputs) { if (null != input.inputNode) { var inputPos = node.nodePosition + new Vector2(0, (i * 16) + 35) + drawState.guiOffset + drawState.scrollOffset; var endPos = input.inputNode.nodePosition + new Vector2(nodeSize.width, 35 + (20 * input.outputIndex)) + drawState.guiOffset + drawState.scrollOffset; DrawNodeCurve(inputPos, endPos, Color.cyan); } i++; } } if (drawState.drawCurve) { DrawNodeCurve(drawState.curveStart, Event.current.mousePosition, Color.red); } break; } } }
void OnIdleContextClick( Event e ) { if( currentNode == null ) { GenericMenu menu = new GenericMenu(); menu.AddItem( new GUIContent("New Menu"), false, Callback, "newScreen" ); menu.ShowAsContext(); e.Use(); } }
public void OnGUI () { if (EditorApplication.isCompiling || EditorApplication.isUpdating) { EditorGUILayout.LabelField("Please wait...", EditorStyles.centeredGreyMiniLabel); _cachedComponents = null; _selectedDisplay = null; _componentDisplays = null; _initialized = false; return; } if (!_initialized) { Initialize(); } Transform transform = Selection.activeTransform; if (Selection.GetFiltered(typeof(Transform), SelectionMode.Unfiltered).Length > 0) { transform = (Transform)Selection.GetFiltered(typeof(Transform), SelectionMode.Unfiltered)[0]; } if (transform == null) { EditorGUILayout.LabelField("Select a GameObject.", EditorStyles.centeredGreyMiniLabel); _cachedComponents = null; _selectedDisplay = null; _componentDisplays = null; } else { bool dirty = false; Component[] components = transform.GetComponents<Component>(); if (_cachedComponents == null || _cachedComponents.Count != components.Length) { dirty = true; } else { for (int i = 0; i < components.Length; i++) { if (components[i] != _cachedComponents[i]) { dirty = true; break; } } } if (dirty) { Dictionary<Component, ComponentDisplay> displays = new Dictionary<Component, ComponentDisplay>(); _cachedComponents = new List<Component>(components); if (_componentDisplays == null) { _componentDisplays = new Dictionary<Component, ComponentDisplay>(); } for (int i = 0; i < _cachedComponents.Count; i++) { Component component = _cachedComponents[i]; if (component == null) { continue; } ComponentDisplay display = null; if (!_componentDisplays.TryGetValue(component, out display)) { display = new ComponentDisplay(); display.component = component; } displays[component] = display; } _componentDisplays = displays; } } if (_componentDisplays == null) { return; } _scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition); Editor editor = Editor.CreateEditor(transform.gameObject); editor.DrawHeader(); if (transform != null) { for (int i = 0; i < _cachedComponents.Count; i++) { Component component = _cachedComponents[i]; _componentDisplays[component].Draw(_componentDisplays[component] == _selectedDisplay); } ComponentDisplay hovered_display = null; for (int i = 0; i < _cachedComponents.Count; i++) { Component component = _cachedComponents[i]; if (_componentDisplays[component].GetRect().Contains(Event.current.mousePosition)) { hovered_display = _componentDisplays[component]; break; } } if (hovered_display != null) { if (Event.current.type == EventType.ContextClick) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Move Up"), false, MoveUp, hovered_display.component); menu.AddItem(new GUIContent("Move Down"), false, MoveDown, hovered_display.component); menu.AddItem(new GUIContent("Move to Top"), false, MoveToTop, hovered_display.component); menu.AddItem(new GUIContent("Move to Bottom"), false, MoveToBottom, hovered_display.component); menu.ShowAsContext(); Event.current.Use(); } if (_selectedDisplay == null && Event.current.type == EventType.MouseDown && Event.current.button == 0) { _dragged = false; _selectedDisplay = hovered_display; Event.current.Use(); } } if (_selectedDisplay != null) // Something was selected. { // If we're hovering over an option that's not the one we started on, treat this as a drag. if (hovered_display != null && _selectedDisplay != hovered_display) { _dragged = true; } // Draw where the component will be dropped. if (hovered_display != null) { Rect rect = new Rect(hovered_display.GetRect()); rect.height = 1; GUI.Box(rect, "", destination); } else if (Event.current.mousePosition.y > _componentDisplays[_cachedComponents[_cachedComponents.Count - 1]].GetRect().y) { Rect rect = new Rect(_componentDisplays[_cachedComponents[_cachedComponents.Count - 1]].GetRect()); rect.y += rect.height; rect.height = 1; GUI.Box(rect, "", destination); } else { Rect rect = new Rect(_componentDisplays[_cachedComponents[0]].GetRect()); rect.height = 1; GUI.Box(rect, "", destination); } } if (Event.current.type == EventType.MouseUp && Event.current.button == 0) { if (_selectedDisplay != null && _selectedDisplay == hovered_display) { // If we didn't attempt to drag the component, and we're not over content, fold it out. if (!_dragged && !_selectedDisplay.GetContentRect().Contains(Event.current.mousePosition)) { _selectedDisplay.Toggle(); } _selectedDisplay = null; Event.current.Use(); } else if (_selectedDisplay != null) { if (hovered_display != null) { int source_index = _cachedComponents.IndexOf(_selectedDisplay.component); int destination_index = _cachedComponents.IndexOf(hovered_display.component); int offset = destination_index - source_index; if (destination_index > source_index) { offset -= 1; } while (offset > 0) { UnityEditorInternal.ComponentUtility.MoveComponentDown(_selectedDisplay.component); offset --; } while (offset < 0) { UnityEditorInternal.ComponentUtility.MoveComponentUp(_selectedDisplay.component); offset ++; } } else if (Event.current.mousePosition.y > _componentDisplays[_cachedComponents[_cachedComponents.Count - 1]].GetRect().y) { MoveToBottom(_selectedDisplay.component); } else { MoveToTop(_selectedDisplay.component); } _selectedDisplay = null; } Event.current.Use(); } } EditorGUILayout.EndScrollView(); }
private void CreateList(SerializedProperty listProperty) { var list = new ReorderableList(listProperty.serializedObject, listProperty , true, true, true, true); list.headerHeight = HeaderHeight; list.footerHeight = FooterHeight; list.drawHeaderCallback = delegate(Rect rect) { EditorGUI.LabelField(rect, m_Settings.ListHeaderLabel); }; list.elementHeight = m_Settings.ListElementHeight; list.drawElementCallback = delegate(Rect position, int index, bool isActive, bool isFocused) { var element = list.serializedProperty.GetArrayElementAtIndex(index); var typProp = element.FindPropertyRelative(m_Settings.ItemTypePropName); var dataProp = element.FindPropertyRelative(m_Settings.ItemDataPropName); GUIContent label; GUIStyle style = EditorStyles.label; if (typProp.enumValueIndex == -1) { label = new GUIContent("Invalid Type", "Enum type value changed or removed?"); style = EditorGUIUtil.RedLabel; } else { string vmessage = null; var vcheck = m_Settings.Validate == null ? PropertyValidationResult.Success : m_Settings.Validate(dataProp, out vmessage); label = new GUIContent(typProp.enumDisplayNames[typProp.enumValueIndex]); if (!string.IsNullOrEmpty(vmessage)) { label.tooltip = vmessage; } switch (vcheck) { case PropertyValidationResult.Warning: style = EditorGUIUtil.YellowLabel; break; case PropertyValidationResult.Error: style = EditorGUIUtil.RedLabel; break; } } var rect = new Rect( position.x, position.y + EditorGUIUtility.standardVerticalSpacing, position.width, position.height); m_Settings.DrawElement(rect, dataProp, label, style); }; GenericMenu.MenuFunction2 addItem = delegate(object typValue) { list.index = AddItem(list.serializedProperty, (int)typValue); }; GenericMenu.MenuFunction addAllItems = delegate() { var stdNames = OutfitterEditorUtil.OutfitMaterialTypeNames; var stdValues = OutfitterEditorUtil.OutfitMaterialTypeTypeValues; var idx = list.serializedProperty.arraySize; for (int i = 0; i < stdNames.Length; i++) { if (!IsInList(list.serializedProperty, stdValues[i])) { AddItem(list.serializedProperty, stdValues[i]); } } list.index = idx; // Assumes function is never called if list is full. }; list.onAddDropdownCallback = delegate(Rect rect, ReorderableList roList) { var menu = new GenericMenu(); var stdNames = OutfitterEditorUtil.OutfitMaterialTypeNames; var stdValues = OutfitterEditorUtil.OutfitMaterialTypeTypeValues; for (int i = 0; i < stdNames.Length; i++) { if (m_Settings.AllowMultipleTargets || !IsInList(list.serializedProperty, stdValues[i])) { menu.AddItem(new GUIContent(stdNames[i]), false, addItem, stdValues[i]); } } if (menu.GetItemCount() == 0) { menu.AddDisabledItem(new GUIContent("<None Available>")); } else { menu.AddItem(new GUIContent("All"), false, addAllItems); } menu.ShowAsContext(); }; m_List = list; }
protected override void OnInspectorDefaultGUI() { base.OnInspectorDefaultGUI(); GUILayout.BeginHorizontal(); EditorGUILayout.HelpBox("Entity Manager, Control all EntityLogic!", MessageType.Info); GUILayout.EndHorizontal(); GUILayout.BeginVertical("Box"); GUILayout.BeginHorizontal(); GUILayout.Label("Define Entity", "BoldLabel"); GUILayout.EndHorizontal(); for (int i = 0; i < Target.DefineEntityNames.Count; i++) { GUILayout.BeginVertical("HelpBox"); GUILayout.BeginHorizontal(); GUILayout.Label("Type", GUILayout.Width(40)); if (GUILayout.Button(Target.DefineEntityNames[i], "MiniPopup")) { GenericMenu gm = new GenericMenu(); List <Type> types = GlobalTools.GetTypesInRunTimeAssemblies(); for (int m = 0; m < types.Count; m++) { if (types[m].IsSubclassOf(typeof(EntityLogicBase))) { int j = i; int n = m; if (Target.DefineEntityNames.Contains(types[n].FullName)) { gm.AddDisabledItem(new GUIContent(types[n].FullName)); } else { gm.AddItem(new GUIContent(types[n].FullName), Target.DefineEntityNames[j] == types[n].FullName, () => { Undo.RecordObject(target, "Set Define Entity Name"); Target.DefineEntityNames[j] = types[n].FullName; HasChanged(); }); } } } gm.ShowAsContext(); } if (GUILayout.Button("Delete", "Minibutton", GUILayout.Width(50))) { Undo.RecordObject(target, "Delete Define Entity"); Target.DefineEntityNames.RemoveAt(i); Target.DefineEntityTargets.RemoveAt(i); HasChanged(); continue; } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); GUILayout.Label("Entity", GUILayout.Width(40)); GameObject entity = Target.DefineEntityTargets[i]; ObjectField(Target.DefineEntityTargets[i], out entity, false, ""); if (entity != Target.DefineEntityTargets[i]) { Target.DefineEntityTargets[i] = entity; } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button("New", "Minibutton")) { Undo.RecordObject(target, "New Define Entity"); Target.DefineEntityNames.Add("<None>"); Target.DefineEntityTargets.Add(null); HasChanged(); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); }
/// <summary> Show a context menu for the graph. Shown when the developer right clicks over the grid area </summary> private void ShowGraphContextMenu() { var menu = new GenericMenu(); //create a generic menu var nodeMenus = new List <NodeMenuItem>(); foreach (Type type in NodeTypes) { NodeMenu nodeMenu; string path = GetNodeMenuName(type, out nodeMenu); //Get node context menu path if (string.IsNullOrEmpty(path)) { continue; //empty entry means that the node will be hidden from the menu } nodeMenus.Add(new NodeMenuItem(nodeMenu, type)); } nodeMenus = nodeMenus.OrderBy(n => n.Menu.Order).ThenBy(o => o.Menu.MenuName).ToList(); string nodeRootPath = UILabels.CreateNode + "/"; foreach (NodeMenuItem nodeMenuItem in nodeMenus) { NodeMenuItem menuItem = nodeMenuItem; if (menuItem.Menu.AddSeparatorBefore) { menu.AddSeparator(nodeRootPath); } menu.AddItem(new GUIContent(nodeRootPath + menuItem.Menu.MenuName), false, () => ExecuteGraphAction(GraphAction.CreateNode, menuItem.NodeType.AssemblyQualifiedName)); //Create Node if (menuItem.Menu.AddSeparatorAfter) { menu.AddSeparator(nodeRootPath); } } // foreach (Type type in NodeTypes) // { // NodeMenu nodeMenu; // string path = GetNodeMenuName(type, out nodeMenu); //Get node context menu path // if (string.IsNullOrEmpty(path)) continue; //empty entry means that the node will be hidden from the menu // Type nodeType = type; // menu.AddItem(new GUIContent(UILabels.Create + "/" + path), false, () => ExecuteGraphAction(GraphAction.CreateNode, nodeType.AssemblyQualifiedName)); //Create Node // } menu.AddSeparator(""); var pasteNode = new GUIContent(UILabels.Paste); if (WindowSettings.CanPasteNodes) { menu.AddItem(pasteNode, false, () => { ExecuteGraphAction(GraphAction.Paste); }); //Paste Node } else { menu.AddDisabledItem(pasteNode); //Paste Node label } menu.AddSeparator(""); if (WindowSettings.SelectedNodes.Count > 0) { menu.AddItem(new GUIContent(UILabels.CenterSelectedNodes), false, () => { CenterSelectedNodesInWindow(); }); //Center Selected Nodes menu.AddSeparator(""); } menu.AddItem(new GUIContent(UILabels.Overview), false, () => { CenterAllNodesInWindow(); }); //Overview menu.AddItem(new GUIContent(UILabels.GoToStartNode), false, GoToStartOrEnterNode); //Go to Start Node menu.AddSeparator(""); AddCustomContextMenuItems(menu, CurrentGraph); //Add custom menu options from graph menu.AddItem(new GUIContent(UILabels.Settings), false, () => { DoozyWindow.Open(DoozyWindow.View.Nody); }); //Settings menu.ShowAsContext(); //show menu at mouse position }
protected void DrawLanguages() { _languagesHelpRect = EditorHelper.ShowHideableHelpBox("GameFramework.LocalisationEditorWindow.Languages", "Here you can specify the languages for which you will provide localised values.\n\nYou should enter the language name and also an optional ISO-639-1 code for use with google translate if you want to perform automatic translations. For convenience Unity supported languages are available from the dropdown button at the bottom right.", _languagesHelpRect); EditorGUILayout.BeginVertical("Box"); EditorGUILayout.BeginHorizontal(); EditorGUILayout.LabelField("Name", GUILayout.ExpandWidth(true)); EditorGUILayout.LabelField("Code", GUILayout.Width(60 + GuiStyles.RemoveButtonWidth + 6)); //EditorGUILayout.LabelField("", GUILayout.Width(GuiStyles.RemoveButtonWidth)); EditorGUILayout.EndHorizontal(); serializedObject.Update(); string languageForDeleting = null; for (var i = 0; i < _languagesProperty.arraySize; i++) { EditorGUILayout.BeginHorizontal(); var languageProperty = _languagesProperty.GetArrayElementAtIndex(i); var nameProperty = languageProperty.FindPropertyRelative("Name"); EditorGUILayout.PropertyField(nameProperty, GUIContent.none, GUILayout.ExpandWidth(true)); var codeProperty = languageProperty.FindPropertyRelative("Code"); EditorGUILayout.PropertyField(codeProperty, GUIContent.none, GUILayout.Width(60)); if (GUILayout.Button("-", EditorStyles.miniButton, GUILayout.Width(GuiStyles.RemoveButtonWidth))) { languageForDeleting = nameProperty.stringValue; break; } EditorGUILayout.EndHorizontal(); } EditorGUILayout.EndVertical(); serializedObject.ApplyModifiedProperties(); // add functionality EditorGUILayout.BeginHorizontal(); _newLanguage = EditorGUILayout.TextField("", _newLanguage, GUILayout.ExpandWidth(true)); if (string.IsNullOrEmpty(_newLanguage) || _targetLocalisationData.ContainsLanguage(_newLanguage)) { GUI.enabled = false; } if (GUILayout.Button(new GUIContent("Add", "Add the specified language to the list"), EditorStyles.miniButton, GUILayout.Width(100))) { Undo.RecordObject(_targetLocalisationData, "Add Language"); _targetLocalisationData.AddLanguage(_newLanguage); _targetChanged = true; _newLanguage = ""; } GUI.enabled = true; //if (GUILayout.Button(EditorGUIUtility.IconContent("Toolbar Plus More", "Add to list"), GUILayout.Width(25))) if (GUILayout.Button(new GUIContent("+", "Add a new language to the list"), EditorStyles.miniButton, GUILayout.Width(20))) { var menu = new GenericMenu(); foreach (var languageDefinition in Languages.LanguageDefinitions) { if (!_targetLocalisationData.ContainsLanguage(languageDefinition.Name)) { menu.AddItem(new GUIContent(languageDefinition.Name + " (" + languageDefinition.Code + ")"), false, AddLanguage, languageDefinition.Name); } } menu.ShowAsContext(); } EditorGUILayout.EndHorizontal(); // delay deleting to avoid editor issues. if (languageForDeleting != null && EditorUtility.DisplayDialog("Delete Language?", string.Format("Are you sure you want to delete the language '{0}'?\n\nDeleting this language will also delete all translations for this language from the list of entries.", languageForDeleting), "Yes", "No")) { Undo.RecordObject(_targetLocalisationData, "Delete Language"); _targetLocalisationData.RemoveLanguage(languageForDeleting); _targetChanged = true; } }
void OnGUI() { Event e = Event.current; //trunk/branches //GUI.color = Color.white; //Dictionary<string, ProxyBool> fs = YangMenuHelper.helperIns.switchFloders; m_ScrollPosition = EditorGUILayout.BeginScrollView(m_ScrollPosition); //if (NGUIEditorTools.DrawHeader("切换主分支", "切换主分支key")) //{ // NGUIEditorTools.BeginContents(); // int index = 0; // foreach (var item in fs)//用复选框实现单选按钮 // { // if (item.Value.m_bool != EditorGUILayout.ToggleLeft(item.Key, item.Value.m_bool)) // { // if (!item.Value.m_bool) // { // UnityEngine.Debug.Log("item:" + item.Key + " item.Value.m_bool:" + item.Value.m_bool); // item.Value.m_bool = true; // YangMenuHelper.helperIns.projMiniPath = item.Key;//选中. // YangMenuHelper.helperIns.WriteConfigLine(0, "switchFloder.txt", "path=" + YangMenuHelper.helperIns.projMiniPath); // } // } // else // { // //UnityEngine.Debug.Log(" false !!!item:" + item.Key + " item.Value.m_bool:" + item.Value.m_bool); // if (!item.Key.Equals(YangMenuHelper.helperIns.projMiniPath)) // { // item.Value.m_bool = false; // } // } // index++; // } // NGUIEditorTools.EndContents(); //} //server list GUI.color = Color.white; Dictionary <ServerInfo, ProxyBool> serverf = YangMenuHelper.helperIns.serverFloders; if (NGUIEditorTools.DrawHeader("切换服务器", "切换服务器key")) { NGUIEditorTools.BeginContents(); GUILayout.BeginHorizontal(); bool selectSelf = YangMenuHelper.helperIns.currentServerIP.Equals(selfIP); if (selectSelf != EditorGUILayout.ToggleLeft(selfIP, selectSelf)) { if (!string.IsNullOrEmpty(selfIP)) { YangMenuHelper.helperIns.currentServerIP = selfIP; WriteIP(); } } newSelfIp = GUILayout.TextField(newSelfIp, 25); if (GUILayout.Button("保存")) { if (!string.IsNullOrEmpty(newSelfIp) && !selfIP.Equals(newSelfIp) && YangMenuHelper.helperIns.IsIP(newSelfIp)) { selfIP = newSelfIp; YangMenuHelper.helperIns.WriteConfigLine(0, "temp/selfIp.txt", selfIP); } } GUILayout.EndHorizontal(); int index = 0; foreach (var item in serverf)//用复选框实现单选按钮 { if (item.Key.connectioned) { GUI.color = Color.green; } else { GUI.color = Color.red; } if (item.Value.m_bool != EditorGUILayout.ToggleLeft(item.Key.content + ":" + (item.Key.connectioned ? "已开" : "未开"), item.Value.m_bool)) { if (!item.Value.m_bool) { UnityEngine.Debug.Log("item:" + item.Key + " item.Value.m_bool:" + item.Value.m_bool); item.Value.m_bool = true; YangMenuHelper.helperIns.currentServerIP = item.Key.ip;//选中. WriteIP(); } } else { if (!item.Key.ip.Equals(YangMenuHelper.helperIns.currentServerIP)) { item.Value.m_bool = false; } } index++; } NGUIEditorTools.EndContents(); } //log level GUI.color = Color.white; Dictionary <int, LineConfigInfo> clientConfig = YangMenuHelper.helperIns.ywindow_clientConfigBean.configDic; if (NGUIEditorTools.DrawHeader("修改ClientConfig", "修改ClientConfigkey")) { NGUIEditorTools.BeginContents(); foreach (var item in clientConfig)//用复选框实现单选按钮 { if (item.Value.myType == CONFIG_TYPE.STRING || item.Value.myType == CONFIG_TYPE.BOOL) { if (GUILayout.Button(item.Value.lineValue)) { if (item.Value.myType == CONFIG_TYPE.STRING) { GenericMenu menu = new GenericMenu(); for (int i = 0; i < item.Value.lineValues.Count; i++) { menu.AddItem(new GUIContent(item.Value.lineValues[i]), false, StringChangeCallBack, new object[] { item.Value, item.Value.lineValues[i] }); } menu.ShowAsContext(); } else { item.Value.OnBoolChange(); } } } else if (item.Value.myType == CONFIG_TYPE.INT || item.Value.myType == CONFIG_TYPE.INPUT) { GUILayout.BeginHorizontal(); GUILayout.Label(item.Value.lineValue); item.Value.xmlValue = GUILayout.TextField(item.Value.xmlValue, 25); if (GUILayout.Button("更改")) { item.Value.OnInputChange(); } GUILayout.EndHorizontal(); } } //ButtonCtrl layoutBtn = new ButtonCtrl(); //layoutBtn.Caption = "操作区布局"; //layoutBtn.Name = "LayoutButton"; //layoutBtn.Size = btnRect; //layoutBtn.onClick = OnLayoutBtnClick; NGUIEditorTools.EndContents(); } EditorGUILayout.EndScrollView(); }
/// <summary> /// Update and Draw the inspector /// </summary> public override void OnInspectorGUI() { eventTrack.Update(); ActorItemTrack track = base.serializedObject.targetObject as ActorItemTrack; CinemaActorAction[] actions = track.ActorActions; CinemaActorEvent[] actorEvents = track.ActorEvents; if (actions.Length > 0 || actorEvents.Length > 0) { actionFoldout = EditorGUILayout.Foldout(actionFoldout, actionContent); if (actionFoldout) { EditorGUI.indentLevel++; for (int i = 0; i < actions.Length; i++) { EditorGUILayout.ObjectField(actions[i].name, actions[i], typeof(CinemaActorAction), true); } for (int i = 0; i < actorEvents.Length; i++) { EditorGUILayout.ObjectField(actorEvents[i].name, actorEvents[i], typeof(CinemaActorEvent), true); } EditorGUI.indentLevel--; } } if (GUILayout.Button(addActionContent)) { GenericMenu createMenu = new GenericMenu(); Type actorActionType = typeof(CinemaActorAction); Type[] actionSubTypes = DirectorHelper.GetAllSubTypes(actorActionType); for (int i = 0; i < actionSubTypes.Length; i++) { string text = string.Empty; string category = string.Empty; string label = string.Empty; foreach (CutsceneItemAttribute attribute in actionSubTypes[i].GetCustomAttributes(typeof(CutsceneItemAttribute), true)) { if (attribute != null) { category = attribute.Category; label = attribute.Label; text = string.Format("{0}/{1}", category, label); break; } } ContextData userData = new ContextData { type = actionSubTypes[i], label = label, category = category }; createMenu.AddItem(new GUIContent(text), false, new GenericMenu.MenuFunction2(AddEvent), userData); } Type actorEventType = typeof(CinemaActorEvent); Type[] eventSubTypes = DirectorHelper.GetAllSubTypes(actorEventType); for (int i = 0; i < eventSubTypes.Length; i++) { string text = string.Empty; string category = string.Empty; string label = string.Empty; foreach (CutsceneItemAttribute attribute in eventSubTypes[i].GetCustomAttributes(typeof(CutsceneItemAttribute), true)) { if (attribute != null) { category = attribute.Category; label = attribute.Label; text = string.Format("{0}/{1}", attribute.Category, attribute.Label); break; } } ContextData userData = new ContextData { type = eventSubTypes[i], label = label, category = category }; createMenu.AddItem(new GUIContent(text), false, new GenericMenu.MenuFunction2(AddEvent), userData); } createMenu.ShowAsContext(); } eventTrack.ApplyModifiedProperties(); }
/// <summary> /// Processes input events /// </summary> public static void InputEvents() { Event e = Event.current; mousePos = e.mousePosition; bool leftClick = e.button == 0, rightClick = e.button == 1, mouseDown = e.type == EventType.MouseDown, mousUp = e.type == EventType.MouseUp; if (ignoreInput(mousePos)) { return; } #region Change Node selection and focus // Choose focused and selected Node, accounting for focus changes curEditorState.focusedNode = null; if (mouseDown || mousUp) { curEditorState.focusedNode = NodeEditor.NodeAtPosition(mousePos); if (curEditorState.focusedNode != curEditorState.selectedNode) { unfocusControls = true; } if (mouseDown && leftClick) { curEditorState.selectedNode = curEditorState.focusedNode; RepaintClients(); } } // Perform above mentioned focus changes in Repaint, which is the only suitable time to do this if (unfocusControls && Event.current.type == EventType.Repaint) { GUIUtility.hotControl = 0; GUIUtility.keyboardControl = 0; unfocusControls = false; } #if UNITY_EDITOR if (curEditorState.focusedNode != null) { UnityEditor.Selection.activeObject = curEditorState.focusedNode; } #endif #endregion switch (e.type) { case EventType.MouseDown: curEditorState.dragNode = false; curEditorState.panWindow = false; if (curEditorState.focusedNode != null) { // Clicked a Node if (rightClick) { // Node Context Click GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Delete Node"), false, ContextCallback, new NodeEditorMenuCallback("deleteNode", curNodeCanvas, curEditorState)); menu.AddItem(new GUIContent("Duplicate Node"), false, ContextCallback, new NodeEditorMenuCallback("duplicateNode", curNodeCanvas, curEditorState)); if (curEditorState.focusedNode.AcceptsTranstitions) { menu.AddSeparator("Seperator"); menu.AddItem(new GUIContent("Make Transition"), false, ContextCallback, new NodeEditorMenuCallback("startTransition", curNodeCanvas, curEditorState)); } menu.ShowAsContext(); e.Use(); } else if (leftClick) { // Detect click on a connection knob if (!CanvasGUIToScreenRect(curEditorState.focusedNode.rect).Contains(mousePos)) { // Clicked NodeEdge, check Node Inputs and Outputs NodeOutput nodeOutput = curEditorState.focusedNode.GetOutputAtPos(e.mousePosition); if (nodeOutput != null) { // Output clicked -> New Connection drawn from this curEditorState.connectOutput = nodeOutput; e.Use(); return; } NodeInput nodeInput = curEditorState.focusedNode.GetInputAtPos(e.mousePosition); if (nodeInput != null && nodeInput.connection != null) { // Input clicked -> Loose and edit Connection // TODO: Draw input from NodeInput curEditorState.connectOutput = nodeInput.connection; nodeInput.RemoveConnection(); e.Use(); } } } } else { // Clicked on canvas // NOTE: Panning is not done here but in LateEvents, so buttons on the canvas won't be blocked when clicking if (rightClick) { // Editor Context Click GenericMenu menu = new GenericMenu(); if (curEditorState.connectOutput != null) { // A connection is drawn, so provide a context menu with apropriate nodes to auto-connect foreach (Node node in NodeTypes.nodes.Keys) { // Iterate through all nodes and check for compability foreach (NodeInput input in node.Inputs) { if (input.type == curEditorState.connectOutput.type) { menu.AddItem(new GUIContent("Add " + NodeTypes.nodes[node].adress), false, ContextCallback, new NodeEditorMenuCallback(node.GetID, curNodeCanvas, curEditorState)); break; } } } } else if (curEditorState.makeTransition != null && curEditorState.makeTransition.AcceptsTranstitions) { // A transition is drawn, so provide a context menu with nodes to auto-connect foreach (Node node in NodeTypes.nodes.Keys) { // Iterate through all nodes and check for compability if (node.AcceptsTranstitions) { menu.AddItem(new GUIContent("Add " + NodeTypes.nodes[node].adress), false, ContextCallback, new NodeEditorMenuCallback(node.GetID, curNodeCanvas, curEditorState)); } } } else { // Ordinary context click, add all nodes to add foreach (Node node in NodeTypes.nodes.Keys) { menu.AddItem(new GUIContent("Add " + NodeTypes.nodes [node].adress), false, ContextCallback, new NodeEditorMenuCallback(node.GetID, curNodeCanvas, curEditorState)); } } menu.ShowAsContext(); e.Use(); } } break; case EventType.MouseUp: if (curEditorState.focusedNode != null && curEditorState.connectOutput != null) { // Apply Drawn connections on node if theres a clicked input if (!curEditorState.focusedNode.Outputs.Contains(curEditorState.connectOutput)) { // An input was clicked, it'll will now be connected NodeInput clickedInput = curEditorState.focusedNode.GetInputAtPos(e.mousePosition); if (clickedInput.CanApplyConnection(curEditorState.connectOutput)) { // It can connect (type is equals, it does not cause recursion, ...) clickedInput.ApplyConnection(curEditorState.connectOutput); } } e.Use(); } curEditorState.makeTransition = null; curEditorState.connectOutput = null; curEditorState.dragNode = false; curEditorState.panWindow = false; break; case EventType.ScrollWheel: // Apply Zoom curEditorState.zoom = (float)Math.Round(Math.Min(2.0f, Math.Max(0.6f, curEditorState.zoom + e.delta.y / 15)), 2); RepaintClients(); break; case EventType.KeyDown: // TODO: Node Editor: Shortcuts if (e.keyCode == KeyCode.N) // Start Navigating (curve to origin / active Node) { curEditorState.navigate = true; } if (e.keyCode == KeyCode.LeftControl && curEditorState.selectedNode != null) { // Snap selected Node's position to multiples of 10 Vector2 pos = curEditorState.selectedNode.rect.position; pos = (pos - curEditorState.panOffset) / 10; pos = new Vector2(Mathf.RoundToInt(pos.x), Mathf.RoundToInt(pos.y)); curEditorState.selectedNode.rect.position = pos * 10 + curEditorState.panOffset; } RepaintClients(); break; case EventType.KeyUp: if (e.keyCode == KeyCode.N) // Stop Navigating { curEditorState.navigate = false; } RepaintClients(); break; case EventType.MouseDrag: if (curEditorState.panWindow) { // Scroll everything with the current mouse delta curEditorState.panOffset += e.delta * curEditorState.zoom; foreach (Node node in curNodeCanvas.nodes) { node.rect.position += e.delta * curEditorState.zoom; } e.delta = Vector2.zero; RepaintClients(); } if (curEditorState.dragNode && curEditorState.selectedNode != null && GUIUtility.hotControl == 0) { // Drag the active node with the current mouse delta curEditorState.selectedNode.rect.position += e.delta * curEditorState.zoom; NodeEditorCallbacks.IssueOnMoveNode(curEditorState.selectedNode); e.delta = Vector2.zero; RepaintClients(); } else { curEditorState.dragNode = false; } break; } }
void Selector(SerializedProperty property) { SkeletonData data = skeletonDataAsset.GetSkeletonData(true); if (data == null) return; SpineAttachment attrib = (SpineAttachment)attribute; List<Skin> validSkins = new List<Skin>(); if (skeletonRenderer != null && attrib.currentSkinOnly) { if (skeletonRenderer.skeleton.Skin != null) { validSkins.Add(skeletonRenderer.skeleton.Skin); } else { validSkins.Add(data.Skins.Items[0]); } } else { foreach (Skin skin in data.Skins) { if (skin != null) validSkins.Add(skin); } } GenericMenu menu = new GenericMenu(); List<string> attachmentNames = new List<string>(); List<string> placeholderNames = new List<string>(); string prefix = ""; if (skeletonRenderer != null && attrib.currentSkinOnly) menu.AddDisabledItem(new GUIContent(skeletonRenderer.gameObject.name + " (SkeletonRenderer)")); else menu.AddDisabledItem(new GUIContent(skeletonDataAsset.name)); menu.AddSeparator(""); menu.AddItem(new GUIContent("Null"), property.stringValue == "", HandleSelect, new SpineDrawerValuePair("", property)); menu.AddSeparator(""); Skin defaultSkin = data.Skins.Items[0]; SerializedProperty slotProperty = property.serializedObject.FindProperty(attrib.slotField); string slotMatch = ""; if (slotProperty != null) { if (slotProperty.propertyType == SerializedPropertyType.String) { slotMatch = slotProperty.stringValue.ToLower(); } } foreach (Skin skin in validSkins) { string skinPrefix = skin.Name + "/"; if (validSkins.Count > 1) prefix = skinPrefix; for (int i = 0; i < data.Slots.Count; i++) { if (slotMatch.Length > 0 && data.Slots.Items[i].Name.ToLower().Contains(slotMatch) == false) continue; attachmentNames.Clear(); placeholderNames.Clear(); skin.FindNamesForSlot(i, attachmentNames); if (skin != defaultSkin) { defaultSkin.FindNamesForSlot(i, attachmentNames); skin.FindNamesForSlot(i, placeholderNames); } for (int a = 0; a < attachmentNames.Count; a++) { string attachmentPath = attachmentNames[a]; string menuPath = prefix + data.Slots.Items[i].Name + "/" + attachmentPath; string name = attachmentNames[a]; if (attrib.returnAttachmentPath) name = skin.Name + "/" + data.Slots.Items[i].Name + "/" + attachmentPath; if (attrib.placeholdersOnly && placeholderNames.Contains(attachmentPath) == false) { menu.AddDisabledItem(new GUIContent(menuPath)); } else { menu.AddItem(new GUIContent(menuPath), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); } } } } menu.ShowAsContext(); }
private void InitReorderedList() { if (prefEntryHolder == null) { var tmp = Resources.FindObjectsOfTypeAll <PreferenceEntryHolder>(); if (tmp.Length > 0) { prefEntryHolder = tmp[0]; } else { prefEntryHolder = ScriptableObject.CreateInstance <PreferenceEntryHolder>(); } } if (serializedObject == null) { serializedObject = new SerializedObject(prefEntryHolder); } userDefList = new ReorderableList(serializedObject, serializedObject.FindProperty("userDefList"), false, true, true, true); unityDefList = new ReorderableList(serializedObject, serializedObject.FindProperty("unityDefList"), false, true, false, false); relSpliterPos = EditorPrefs.GetFloat("BGTools.PlayerPrefsEditor.RelativeSpliterPosition", 100 / position.width); userDefList.drawHeaderCallback = (Rect rect) => { EditorGUI.LabelField(rect, "User defined"); }; userDefList.drawElementBackgroundCallback = OnDrawElementBackgroundCallback; userDefList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) => { SerializedProperty element = GetUserDefListElementAtIndex(index, userDefList.serializedProperty); SerializedProperty key = element.FindPropertyRelative("m_key"); SerializedProperty type = element.FindPropertyRelative("m_typeSelection"); SerializedProperty value; // Load only necessary type switch ((PreferenceEntry.PrefTypes)type.enumValueIndex) { case PreferenceEntry.PrefTypes.Float: value = element.FindPropertyRelative("m_floatValue"); break; case PreferenceEntry.PrefTypes.Int: value = element.FindPropertyRelative("m_intValue"); break; case PreferenceEntry.PrefTypes.String: value = element.FindPropertyRelative("m_strValue"); break; default: value = element.FindPropertyRelative("This should never happen"); break; } float spliterPos = relSpliterPos * rect.width; rect.y += 2; EditorGUI.BeginChangeCheck(); string prefKeyName = key.stringValue; EditorGUI.LabelField(new Rect(rect.x, rect.y, spliterPos - 1, EditorGUIUtility.singleLineHeight), new GUIContent(prefKeyName, prefKeyName)); GUI.enabled = false; EditorGUI.EnumPopup(new Rect(rect.x + spliterPos + 1, rect.y, 60, EditorGUIUtility.singleLineHeight), (PreferenceEntry.PrefTypes)type.enumValueIndex); GUI.enabled = !showLoadingIndicatorOverlay; switch ((PreferenceEntry.PrefTypes)type.enumValueIndex) { case PreferenceEntry.PrefTypes.Float: EditorGUI.DelayedFloatField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; case PreferenceEntry.PrefTypes.Int: EditorGUI.DelayedIntField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; case PreferenceEntry.PrefTypes.String: EditorGUI.DelayedTextField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; } if (EditorGUI.EndChangeCheck()) { entryAccessor.IgnoreNextChange(); switch ((PreferenceEntry.PrefTypes)type.enumValueIndex) { case PreferenceEntry.PrefTypes.Float: PlayerPrefs.SetFloat(key.stringValue, value.floatValue); break; case PreferenceEntry.PrefTypes.Int: PlayerPrefs.SetInt(key.stringValue, value.intValue); break; case PreferenceEntry.PrefTypes.String: PlayerPrefs.SetString(key.stringValue, value.stringValue); break; } PlayerPrefs.Save(); } }; userDefList.onRemoveCallback = (ReorderableList l) => { userDefList.ReleaseKeyboardFocus(); unityDefList.ReleaseKeyboardFocus(); string prefKey = l.serializedProperty.GetArrayElementAtIndex(l.index).FindPropertyRelative("m_key").stringValue; if (EditorUtility.DisplayDialog("Warning!", $"Are you sure you want to delete this entry from PlayerPrefs?\n\nEntry: {prefKey}", "Yes", "No")) { entryAccessor.IgnoreNextChange(); PlayerPrefs.DeleteKey(prefKey); PlayerPrefs.Save(); ReorderableList.defaultBehaviours.DoRemoveButton(l); PrepareData(); GUIUtility.ExitGUI(); } }; userDefList.onAddDropdownCallback = (Rect buttonRect, ReorderableList l) => { var menu = new GenericMenu(); foreach (PreferenceEntry.PrefTypes type in Enum.GetValues(typeof(PreferenceEntry.PrefTypes))) { menu.AddItem(new GUIContent(type.ToString()), false, () => { TextFieldDialog.OpenDialog("Create new property", "Key for the new property:", prefKeyValidatorList, (key) => { entryAccessor.IgnoreNextChange(); switch (type) { case PreferenceEntry.PrefTypes.Float: PlayerPrefs.SetFloat(key, 0.0f); break; case PreferenceEntry.PrefTypes.Int: PlayerPrefs.SetInt(key, 0); break; case PreferenceEntry.PrefTypes.String: PlayerPrefs.SetString(key, string.Empty); break; } PlayerPrefs.Save(); PrepareData(); Focus(); }, this); }); } menu.ShowAsContext(); }; unityDefList.drawElementBackgroundCallback = OnDrawElementBackgroundCallback; unityDefList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) => { var element = unityDefList.serializedProperty.GetArrayElementAtIndex(index); SerializedProperty key = element.FindPropertyRelative("m_key"); SerializedProperty type = element.FindPropertyRelative("m_typeSelection"); SerializedProperty value; // Load only necessary type switch ((PreferenceEntry.PrefTypes)type.enumValueIndex) { case PreferenceEntry.PrefTypes.Float: value = element.FindPropertyRelative("m_floatValue"); break; case PreferenceEntry.PrefTypes.Int: value = element.FindPropertyRelative("m_intValue"); break; case PreferenceEntry.PrefTypes.String: value = element.FindPropertyRelative("m_strValue"); break; default: value = element.FindPropertyRelative("This should never happen"); break; } float spliterPos = relSpliterPos * rect.width; rect.y += 2; GUI.enabled = false; string prefKeyName = key.stringValue; EditorGUI.LabelField(new Rect(rect.x, rect.y, spliterPos - 1, EditorGUIUtility.singleLineHeight), new GUIContent(prefKeyName, prefKeyName)); EditorGUI.EnumPopup(new Rect(rect.x + spliterPos + 1, rect.y, 60, EditorGUIUtility.singleLineHeight), (PreferenceEntry.PrefTypes)type.enumValueIndex); switch ((PreferenceEntry.PrefTypes)type.enumValueIndex) { case PreferenceEntry.PrefTypes.Float: EditorGUI.DelayedFloatField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; case PreferenceEntry.PrefTypes.Int: EditorGUI.DelayedIntField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; case PreferenceEntry.PrefTypes.String: EditorGUI.DelayedTextField(new Rect(rect.x + spliterPos + 62, rect.y, rect.width - spliterPos - 60, EditorGUIUtility.singleLineHeight), value, GUIContent.none); break; } GUI.enabled = !showLoadingIndicatorOverlay; }; unityDefList.drawHeaderCallback = (Rect rect) => { EditorGUI.LabelField(rect, "Unity defined"); }; }
void Selector(SerializedProperty property) { SpineSlot attrib = (SpineSlot)attribute; SkeletonData data = skeletonDataAsset.GetSkeletonData(true); if (data == null) return; GenericMenu menu = new GenericMenu(); menu.AddDisabledItem(new GUIContent(skeletonDataAsset.name)); menu.AddSeparator(""); for (int i = 0; i < data.Slots.Count; i++) { string name = data.Slots.Items[i].Name; if (name.StartsWith(attrib.startsWith)) { if (attrib.containsBoundingBoxes) { int slotIndex = i; List<Attachment> attachments = new List<Attachment>(); foreach (var skin in data.Skins) { skin.FindAttachmentsForSlot(slotIndex, attachments); } bool hasBoundingBox = false; foreach (var attachment in attachments) { if (attachment is BoundingBoxAttachment) { menu.AddItem(new GUIContent(name), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); hasBoundingBox = true; break; } } if (!hasBoundingBox) menu.AddDisabledItem(new GUIContent(name)); } else { menu.AddItem(new GUIContent(name), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); } } } menu.ShowAsContext(); }
/** * retrieve mouse events for this node in this GraphEditor window. */ private void HandleNodeMouseEvent() { switch (Event.current.type) { /* * handling release of mouse drag from this node to another node. * this node doesn't know about where the other node is. the master only knows. * only emit event. */ case EventType.Ignore: { NodeGUIUtility.NodeEventHandler(new NodeEvent(NodeEvent.EventType.EVENT_CONNECTING_END, this, Event.current.mousePosition, null)); break; } /* * check if the mouse-down point is over one of the connectionPoint in this node. * then emit event. */ case EventType.MouseDown: { Model.ConnectionPointData result = IsOverConnectionPoint(Event.current.mousePosition); if (result != null) { NodeGUIUtility.NodeEventHandler(new NodeEvent(NodeEvent.EventType.EVENT_CONNECTING_BEGIN, this, Event.current.mousePosition, result)); break; } else { NodeGUIUtility.NodeEventHandler(new NodeEvent(NodeEvent.EventType.EVENT_NODE_CLICKED, this, Event.current.mousePosition, null)); } break; } } /* * retrieve mouse events for this node in|out of this GraphTool window. */ switch (Event.current.rawType) { case EventType.MouseUp: { bool eventSent = false; // send EVENT_CONNECTION_ESTABLISHED event if MouseUp performed on ConnectionPoint Action <Model.ConnectionPointData> raiseEventIfHit = (Model.ConnectionPointData point) => { // Only one connectionPoint can send NodeEvent. if (eventSent) { return; } // If InputConnectionPoint is not valid at this moment, ignore if (!IsValidInputConnectionPoint(point)) { return; } if (point.Region.Contains(Event.current.mousePosition)) { NodeGUIUtility.NodeEventHandler( new NodeEvent(NodeEvent.EventType.EVENT_CONNECTION_ESTABLISHED, this, Event.current.mousePosition, point)); eventSent = true; return; } }; m_data.InputPoints.ForEach(raiseEventIfHit); m_data.OutputPoints.ForEach(raiseEventIfHit); break; } } /* * right click to open Context menu */ if (Event.current.type == EventType.ContextClick || (Event.current.type == EventType.MouseUp && Event.current.button == 1)) { var menu = new GenericMenu(); Data.Operation.Object.OnContextMenuGUI(menu); menu.AddItem( new GUIContent("Delete"), false, () => { NodeGUIUtility.NodeEventHandler(new NodeEvent(NodeEvent.EventType.EVENT_NODE_DELETE, this, Vector2.zero, null)); } ); menu.ShowAsContext(); Event.current.Use(); } }
void SpawnHierarchyContextMenu () { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Follow"), false, SpawnFollowHierarchy); menu.AddItem(new GUIContent("Follow (Root Only)"), false, SpawnFollowHierarchyRootOnly); menu.AddSeparator(""); menu.AddItem(new GUIContent("Override"), false, SpawnOverrideHierarchy); menu.AddItem(new GUIContent("Override (Root Only)"), false, SpawnOverrideHierarchyRootOnly); menu.ShowAsContext(); }
public bool DoProperty(Rect position, SerializedProperty property) { if (!reorderableListDict.ContainsKey(property.propertyPath)) { return(false); } headerPosition = new Rect(position); headerPosition.height = EditorGUIUtility.singleLineHeight; // Draw the background if (DrawBackgroundCallback != null) { Rect backgroundPosition = new Rect(headerPosition); backgroundPosition.xMin += EasyGUI.Indent; if (property.isExpanded) { backgroundPosition.yMax += 15; } EditorGUI.DrawRect(backgroundPosition, DrawBackgroundCallback(false, false)); } // Draw header if (HeaderCallback != null) { HeaderCallback(headerPosition); } else { string headerName = string.Format(HeaderStr, property.displayName, property.arraySize); EditorGUI.PropertyField(headerPosition, property, new GUIContent(headerName), false); } // Draw the reorderable list for the property if (property.isExpanded) { EditorGUI.BeginDisabledGroup(!Editable); if (!property.editable) { EditorGUI.indentLevel++; } EditorGUI.BeginChangeCheck(); var sizePosition = new Rect(headerPosition); sizePosition.yMin = headerPosition.yMax; sizePosition.height = EditorGUIUtility.singleLineHeight; var newArraySize = Mathf.Clamp(EditorGUI.IntField(sizePosition, SizeStr, property.arraySize), 0, int.MaxValue); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(property.serializedObject.targetObject, SetArraySizeStr); property.arraySize = newArraySize; EditorUtility.SetDirty(property.serializedObject.targetObject); } var listPosition = new Rect(sizePosition); listPosition.xMin += EasyGUI.Indent; listPosition.yMin = sizePosition.yMax; var indentLevel = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; reorderableListDict[property.propertyPath].DoList(listPosition); EditorGUI.indentLevel = indentLevel; if (!property.editable) { EditorGUI.indentLevel--; } EditorGUI.EndDisabledGroup(); } // Do dropdown menu for the header if (property.isArray && Event.current.type == EventType.MouseDown && headerPosition.Contains(Event.current.mousePosition)) { GenericMenu popupMenu = new GenericMenu(); if (HeaderMenuCallback != null && HeaderMenuCallback(popupMenu)) { Event.current.Use(); if (popupMenu.GetItemCount() != 0) { popupMenu.ShowAsContext(); } } } // Handle drag and drop into the header Event evt = Event.current; if (evt == null) { return(true); } if (evt.type == EventType.DragUpdated || evt.type == EventType.DragPerform) { if (!headerPosition.Contains(evt.mousePosition)) { return(true); } DragAndDrop.visualMode = DragAndDropVisualMode.Copy; if (evt.type == EventType.DragPerform) { DragAndDrop.AcceptDrag(); System.Action <SerializedProperty, Object[]> handler = null; if (propDropHandlers.TryGetValue(property.propertyPath, out handler)) { if (handler != null) { handler(property, DragAndDrop.objectReferences); } } else { foreach (Object draggedObject in DragAndDrop.objectReferences) { if (draggedObject.GetType() != property.GetType()) { continue; } int newIndex = property.arraySize; property.arraySize++; SerializedProperty target = property.GetArrayElementAtIndex(newIndex); target.objectReferenceInstanceIDValue = draggedObject.GetInstanceID(); } } evt.Use(); } } return(true); }
private void DrawToolbarGUI() { GUILayout.BeginHorizontal(EditorStyles.toolbar); if (OnlineMapsUpdater.hasNewVersion && updateAvailableContent != null) { Color defBackgroundColor = GUI.backgroundColor; GUI.backgroundColor = new Color(1, 0.5f, 0.5f); if (GUILayout.Button(updateAvailableContent, EditorStyles.toolbarButton)) { OnlineMapsUpdater.OpenWindow(); } GUI.backgroundColor = defBackgroundColor; } else GUILayout.Label(""); if (GUILayout.Button("Help", EditorStyles.toolbarButton, GUILayout.ExpandWidth(false))) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Documentation"), false, OnViewDocs); menu.AddItem(new GUIContent("API Reference"), false, OnViewAPI); menu.AddItem(new GUIContent("Atlas of Examples"), false, OnViewAtlas); menu.AddSeparator(""); menu.AddItem(new GUIContent("Product Page"), false, OnProductPage); menu.AddItem(new GUIContent("Forum"), false, OnViewForum); menu.AddItem(new GUIContent("Check Updates"), false, OnCheckUpdates); menu.AddItem(new GUIContent("Support"), false, OnSendMail); menu.AddSeparator(""); menu.AddItem(new GUIContent("About"), false, OnAbout); menu.ShowAsContext(); } GUILayout.EndHorizontal(); }
public void DrawConnection(List <Node> nodes, Dictionary <string, List <string> > throughputListDict) { var startNodes = nodes.Where(node => node.nodeId == startNodeId).ToList(); if (!startNodes.Any()) { return; } var start = startNodes[0].GlobalConnectionPointPosition(outputPoint); start = Node.ScaleEffect(start); var startV3 = new Vector3(start.x, start.y, 0f); var endNodes = nodes.Where(node => node.nodeId == endNodeId).ToList(); if (!endNodes.Any()) { return; } var end = endNodes[0].GlobalConnectionPointPosition(inputPoint); end = Node.ScaleEffect(end); var endV3 = new Vector3(end.x, end.y + 1f, 0f); var centerPoint = start + ((end - start) / 2); var centerPointV3 = new Vector3(centerPoint.x, centerPoint.y, 0f); var pointDistance = (end.x - start.x) / 3f; if (pointDistance < AssetGraphGUISettings.CONNECTION_CURVE_LENGTH) { pointDistance = AssetGraphGUISettings.CONNECTION_CURVE_LENGTH; } var startTan = new Vector3(start.x + pointDistance, start.y, 0f); var endTan = new Vector3(end.x - pointDistance, end.y, 0f); Handles.DrawBezier(startV3, endV3, startTan, endTan, Color.gray, null, 4f); // draw connection label if connection's label is not normal. if (Node.scaleFactor == Node.SCALE_MAX) { switch (label) { case AssetGraphSettings.DEFAULT_OUTPUTPOINT_LABEL: { // show nothing break; } case AssetGraphSettings.BUNDLIZER_BUNDLE_OUTPUTPOINT_LABEL: { var labelPointV3 = new Vector3(centerPointV3.x - ((AssetGraphSettings.BUNDLIZER_BUNDLE_OUTPUTPOINT_LABEL.Length * 6f) / 2), centerPointV3.y - 24f, 0f); Handles.Label(labelPointV3, AssetGraphSettings.BUNDLIZER_BUNDLE_OUTPUTPOINT_LABEL); break; } case AssetGraphSettings.BUNDLIZER_RESOURCES_OUTPUTPOINT_LABEL: { var labelPointV3 = new Vector3(centerPointV3.x - ((AssetGraphSettings.BUNDLIZER_RESOURCES_OUTPUTPOINT_LABEL.Length * 6f) / 2), centerPointV3.y - 24f, 0f); Handles.Label(labelPointV3, AssetGraphSettings.BUNDLIZER_RESOURCES_OUTPUTPOINT_LABEL); break; } default: { var labelPointV3 = new Vector3(centerPointV3.x - ((label.Length * 7f) / 2), centerPointV3.y - 24f, 0f); Handles.Label(labelPointV3, label); break; } } } // draw connection arrow. if (Node.scaleFactor == Node.SCALE_MAX) { GUI.DrawTexture( new Rect( endV3.x - AssetGraphGUISettings.CONNECTION_ARROW_WIDTH + 4f, endV3.y - (AssetGraphGUISettings.CONNECTION_ARROW_HEIGHT / 2f) - 1f, AssetGraphGUISettings.CONNECTION_ARROW_WIDTH, AssetGraphGUISettings.CONNECTION_ARROW_HEIGHT ), connectionArrowTex ); } /* * draw throughtput badge. */ var throughputCount = 0; foreach (var list in throughputListDict.Values) { throughputCount += list.Count; } var offsetSize = throughputCount.ToString().Length * 20f; buttonRect = new Rect(centerPointV3.x - offsetSize / 2f, centerPointV3.y - 7f, offsetSize, 20f); if ( Event.current.type == EventType.ContextClick || (Event.current.type == EventType.MouseUp && Event.current.button == 1) ) { var rightClickPos = Event.current.mousePosition; if (buttonRect.Contains(rightClickPos)) { var menu = new GenericMenu(); menu.AddItem( new GUIContent("Delete"), false, () => { Delete(); } ); menu.ShowAsContext(); Event.current.Use(); } } if (GUI.Button(buttonRect, throughputCount.ToString(), connectionButtonStyle)) { conInsp.UpdateCon(this, throughputListDict); Emit(new OnConnectionEvent(OnConnectionEvent.EventType.EVENT_CONNECTION_TAPPED, this)); } }
private void OnEnable() { Color backColor = GUI.backgroundColor; Color contentColor = GUI.contentColor; float line = EditorGUIUtility.singleLineHeight; SerializedProperty property = serializedObject.FindProperty("services"); _services = new ReorderableList(serializedObject, property); _services.showDefaultBackground = true; _services.elementHeight = line + 6; _services.drawHeaderCallback = (rect) => { EditorGUI.LabelField(rect, "Core Framework Services"); }; _services.drawElementCallback = (Rect rect, int index, bool active, bool focused) => { float width = rect.width - 22; SerializedProperty element = _services.serializedProperty.GetArrayElementAtIndex(index); if (GUI.Button(new Rect(rect.x + rect.width - 20, rect.y + 4, 18, line), EditorGUIUtility.IconContent("_Popup").image, GUIStyle.none)) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Edit"), false, delegate() { Selection.activeObject = element.objectReferenceValue; }); menu.AddItem(new GUIContent("Remove"), false, delegate() { if (!_gameConfiguration.services[index]) { _gameConfiguration.services.RemoveAt(index); EditorUtility.SetDirty(_gameConfiguration); } else if (EditorUtility.DisplayDialog("Remove " + ObjectNames.NicifyVariableName(_gameConfiguration.services[index].name) + "?", "Are you sure you want to remove this service? This will delete the ScriptableObject and can't be undone.", "Yes", "No")) { AssetDatabase.DeleteAsset(AssetDatabase.GetAssetOrScenePath(element.objectReferenceValue)); _gameConfiguration.services.RemoveAt(index); EditorUtility.SetDirty(_gameConfiguration); } }); menu.ShowAsContext(); } EditorGUI.PropertyField(new Rect(rect.x, rect.y + 2, width, line), element, GUIContent.none); }; _services.onAddCallback = (list) => { Type[] allServiceTypes = GetAllServiceTypes(); GenericMenu servicesMenu = new GenericMenu(); foreach (var serviceType in allServiceTypes) { servicesMenu.AddItem(new GUIContent(ObjectNames.NicifyVariableName(serviceType.Name)), false, delegate(object service) { Type styp = service as Type; foreach (var assy in AppDomain.CurrentDomain.GetAssemblies()) { foreach (var typ in assy.GetTypes()) { if (typ.Name == styp.Name + "Config" || typ.Name == styp.Name + "Configuration") { serializedObject.ApplyModifiedProperties(); object so = ScriptableObject.CreateInstance(typ); if (so == null || (so as ServiceConfiguration) == null) { return; } serializedObject.ApplyModifiedProperties(); string path = AssetDatabase.GetAssetOrScenePath(serializedObject.targetObject); path = Path.GetDirectoryName(path) + Path.DirectorySeparatorChar + styp.Name + ".asset"; AssetDatabase.CreateAsset(so as ServiceConfiguration, path); if (so != null) { _gameConfiguration.services.Add(so as ServiceConfiguration); EditorUtility.SetDirty(_gameConfiguration); } return; } } } }, serviceType); } servicesMenu.ShowAsContext(); }; }
void DrawContextMenu() { GenericMenu menu = new GenericMenu(); foreach(StateMenuItem it in menuItems) { menu.AddItem(new GUIContent("Add State/" + it.name), false, AddStateToMachine, it); } menu.AddItem(new GUIContent("Add State/Sub Machine"), false, AddSubMachine); menu.AddItem(new GUIContent("Add Trigger"), false, AddTrigger); menu.ShowAsContext (); }
void OnGeneralUI(Rect rect) { var e = Event.current; // Selection if (e.type == EventType.mouseDown) { GUI.FocusControl(null); m_SelectedCurve = null; m_SelectedKeyframeIndex = -1; bool used = false; var hit = CanvasToCurve(e.mousePosition); float curvePickValue = CurveToCanvas(hit).y; // Try and select a curve foreach (var curve in m_Curves) { if (!curve.Value.editable || !curve.Value.visible) { continue; } var prop = curve.Key; var state = curve.Value; var animCurve = prop.animationCurveValue; float hitY = animCurve.length == 0 ? state.zeroKeyConstantValue : animCurve.Evaluate(hit.x); var curvePos = CurveToCanvas(new Vector3(hit.x, hitY)); if (Mathf.Abs(curvePos.y - curvePickValue) < settings.curvePickingDistance) { m_SelectedCurve = prop; if (e.clickCount == 2 && e.button == 0) { // Create a keyframe on double-click on this curve EditCreateKeyframe(animCurve, hit, true, state.zeroKeyConstantValue); SaveCurve(prop, animCurve); } else if (e.button == 1) { // Curve context menu var menu = new GenericMenu(); menu.AddItem(new GUIContent("Add Key"), false, (x) => { var action = (MenuAction)x; var curveValue = action.curve.animationCurveValue; action.curve.serializedObject.Update(); EditCreateKeyframe(curveValue, hit, true, 0f); SaveCurve(action.curve, curveValue); action.curve.serializedObject.ApplyModifiedProperties(); }, new MenuAction(prop, hit)); menu.ShowAsContext(); e.Use(); used = true; } } } if (e.clickCount == 2 && e.button == 0 && m_SelectedCurve == null) { // Create a keyframe on every curve on double-click foreach (var curve in m_Curves) { if (!curve.Value.editable || !curve.Value.visible) { continue; } var prop = curve.Key; var state = curve.Value; var animCurve = prop.animationCurveValue; EditCreateKeyframe(animCurve, hit, e.alt, state.zeroKeyConstantValue); SaveCurve(prop, animCurve); } } else if (!used && e.button == 1) { // Global context menu var menu = new GenericMenu(); menu.AddItem(new GUIContent("Add Key At Position"), false, () => ContextMenuAddKey(hit, false)); menu.AddItem(new GUIContent("Add Key On Curves"), false, () => ContextMenuAddKey(hit, true)); menu.ShowAsContext(); } e.Use(); } // Delete selected key(s) if (e.type == EventType.keyDown && (e.keyCode == KeyCode.Delete || e.keyCode == KeyCode.Backspace)) { if (m_SelectedKeyframeIndex != -1 && m_SelectedCurve != null) { var animCurve = m_SelectedCurve.animationCurveValue; var length = animCurve.length; if (m_Curves[m_SelectedCurve].minPointCount < length && length >= 0) { EditDeleteKeyframe(animCurve, m_SelectedKeyframeIndex); m_SelectedKeyframeIndex = -1; SaveCurve(m_SelectedCurve, animCurve); } e.Use(); } } }
void DrawTriggerInspector(int windowID) { TriggerManager[] tempKeys = new TriggerManager[triggerInspectorPositions.Count]; triggerInspectorPositions.Keys.CopyTo(tempKeys, 0); TriggerManager curTrigger = tempKeys[windowID - stateInspectorPositions.Count]; if(Event.current.type == EventType.MouseDown && Event.current.button == 1) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Delete"), false, DeleteTrigger, curTrigger); menu.ShowAsContext (); Event.current.Use(); } GUILayout.Label("From --> Obs --> To"); GUILayout.BeginHorizontal(); curTrigger.owner = LineStateSelector(curTrigger.owner, Color.cyan, windowID, curTrigger.inspectorCorner, null, Direction.Backwards); GUILayout.FlexibleSpace(); curTrigger.watched = LineStateSelector((State)curTrigger.watched, Color.green, windowID, curTrigger.inspectorCorner, null, Direction.None); GUILayout.FlexibleSpace(); curTrigger.target = LineStateSelector(curTrigger.target, Color.blue, windowID, curTrigger.inspectorCorner, null, Direction.Forwards); GUILayout.EndHorizontal(); if(curTrigger.watched != null && curTrigger.watched.GetExposedVariables().Length > 0) { curTrigger.observedIndex = curTrigger.watched.DrawObservableSelector(curTrigger.observedIndex); GUI.contentColor = Color.black; EditorGUIUtility.LookLikeControls(); curTrigger.mode = (TriggerMode)EditorGUILayout.EnumPopup(curTrigger.mode); switch(curTrigger.obsType) { case ObservedType.integer: curTrigger.intTarget = EditorGUILayout.IntField(curTrigger.intTarget, GUILayout.MaxWidth(triggerInspectorPositions[curTrigger].width)); break; case ObservedType.floatingPoint: curTrigger.floatTarget = EditorGUILayout.FloatField(curTrigger.floatTarget, GUILayout.MaxWidth(triggerInspectorPositions[curTrigger].width)); break; case ObservedType.boolean: curTrigger.boolTarget = EditorGUILayout.Toggle(curTrigger.boolTarget, GUILayout.MaxWidth(triggerInspectorPositions[curTrigger].width)); break; } GUI.contentColor = Color.white; EditorGUIUtility.LookLikeInspector(); } if(curTrigger.watched == null) { GUILayout.Label("Observing Memory"); EditorGUIUtility.LookLikeControls(); curTrigger.memoryKey = EditorGUILayout.TextField(curTrigger.memoryKey); curTrigger.mode = (TriggerMode)EditorGUILayout.EnumPopup(curTrigger.mode); curTrigger.floatTarget = EditorGUILayout.FloatField(curTrigger.floatTarget, GUILayout.MaxWidth(triggerInspectorPositions[curTrigger].width)); EditorGUIUtility.LookLikeInspector(); } GUI.DragWindow(); curTrigger.inspectorCorner = new Vector2(triggerInspectorPositions[curTrigger].x, triggerInspectorPositions[curTrigger].y); }
protected override void OnInspectorDefaultGUI() { base.OnInspectorDefaultGUI(); GUILayout.BeginHorizontal(); GUI.enabled = !EditorApplication.isPlaying && Target.DefaultProcedure != ""; GUILayout.Label("Default: " + Target.DefaultProcedure); GUI.enabled = !EditorApplication.isPlaying; GUILayout.FlexibleSpace(); GUI.enabled = !EditorApplication.isPlaying && Target.ActivatedProcedures.Count > 0; if (GUILayout.Button("Set Default", EditorGlobalTools.Styles.MiniPopup)) { GenericMenu gm = new GenericMenu(); for (int i = 0; i < Target.ActivatedProcedures.Count; i++) { int j = i; gm.AddItem(new GUIContent(Target.ActivatedProcedures[j]), Target.DefaultProcedure == Target.ActivatedProcedures[j], () => { Undo.RecordObject(target, "Set Default Procedure"); Target.DefaultProcedure = Target.ActivatedProcedures[j]; HasChanged(); }); } gm.ShowAsContext(); } GUI.enabled = !EditorApplication.isPlaying; GUILayout.EndHorizontal(); GUILayout.BeginVertical(EditorGlobalTools.Styles.Box); GUILayout.BeginHorizontal(); GUILayout.Label("Enabled Procedures:"); GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); for (int i = 0; i < Target.ActivatedProcedures.Count; i++) { GUILayout.BeginHorizontal(); GUILayout.Label((i + 1) + "." + Target.ActivatedProcedures[i]); GUILayout.FlexibleSpace(); if (GUILayout.Button("▲", EditorStyles.miniButtonLeft)) { if (i > 0) { Undo.RecordObject(target, "Set Procedure Order"); string procedure = Target.ActivatedProcedures[i]; Target.ActivatedProcedures.RemoveAt(i); Target.ActivatedProcedures.Insert(i - 1, procedure); HasChanged(); continue; } } if (GUILayout.Button("▼", EditorStyles.miniButtonMid)) { if (i < Target.ActivatedProcedures.Count - 1) { Undo.RecordObject(target, "Set Procedure Order"); string procedure = Target.ActivatedProcedures[i]; Target.ActivatedProcedures.RemoveAt(i); Target.ActivatedProcedures.Insert(i + 1, procedure); HasChanged(); continue; } } if (GUILayout.Button("Edit", EditorStyles.miniButtonMid)) { MonoScriptToolkit.OpenMonoScript(Target.ActivatedProcedures[i]); } if (GUILayout.Button("Delete", EditorStyles.miniButtonRight)) { Undo.RecordObject(target, "Delete Procedure"); if (Target.DefaultProcedure == Target.ActivatedProcedures[i]) { Target.DefaultProcedure = ""; } Target.ActivatedProcedures.RemoveAt(i); if (Target.DefaultProcedure == "" && Target.ActivatedProcedures.Count > 0) { Target.DefaultProcedure = Target.ActivatedProcedures[0]; } HasChanged(); } GUILayout.EndHorizontal(); } GUILayout.BeginHorizontal(); if (GUILayout.Button("Add Procedure", EditorGlobalTools.Styles.MiniPopup)) { GenericMenu gm = new GenericMenu(); List <Type> types = ReflectionToolkit.GetTypesInRunTimeAssemblies(type => { return(type.IsSubclassOf(typeof(ProcedureBase)) && !type.IsAbstract); }); for (int i = 0; i < types.Count; i++) { int j = i; if (Target.ActivatedProcedures.Contains(types[j].FullName)) { gm.AddDisabledItem(new GUIContent(types[j].FullName)); } else { gm.AddItem(new GUIContent(types[j].FullName), false, () => { Undo.RecordObject(target, "Add Procedure"); Target.ActivatedProcedures.Add(types[j].FullName); if (Target.DefaultProcedure == "") { Target.DefaultProcedure = Target.ActivatedProcedures[0]; } HasChanged(); }); } } gm.ShowAsContext(); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); GUI.enabled = true; }
private void OnEnable() { Action <ReorderableList, SerializedProperty> fnAssetDropDown = delegate(ReorderableList list, SerializedProperty property) { var existingAttribute = new List <string>(); for (int i = 0; i < property.arraySize; ++i) { existingAttribute.Add(property.GetArrayElementAtIndex(i).FindPropertyRelative("attribute.m_Name").stringValue); } var menu = new GenericMenu(); foreach (var attributeName in VFXAttribute.AllIncludingVariadicReadWritable.Except(existingAttribute).OrderBy(o => o)) { var attribute = VFXAttribute.Find(attributeName); menu.AddItem(new GUIContent(attribute.name), false, () => { serializedObject.Update(); property.arraySize++; var newElement = property.GetArrayElementAtIndex(property.arraySize - 1); newElement.FindPropertyRelative("attribute.m_Name").stringValue = attribute.name; newElement.FindPropertyRelative("type").intValue = (int)attribute.type; var size = VFXExpression.TypeToSize(attribute.type); var values = newElement.FindPropertyRelative("values"); values.arraySize = size; var initialValues = new float[size]; if (attribute.type == VFXValueType.Float) { initialValues[0] = attribute.value.Get <float>(); } else if (attribute.type == VFXValueType.Float2) { var v = attribute.value.Get <Vector2>(); initialValues[0] = v.x; initialValues[1] = v.y; } else if (attribute.type == VFXValueType.Float3) { var v = attribute.value.Get <Vector3>(); initialValues[0] = v.x; initialValues[1] = v.y; initialValues[2] = v.z; } else if (attribute.type == VFXValueType.Float4) { var v = attribute.value.Get <Vector4>(); initialValues[0] = v.x; initialValues[1] = v.y; initialValues[2] = v.z; initialValues[3] = v.w; } else if (attribute.type == VFXValueType.Int32) { initialValues[0] = attribute.value.Get <int>(); } else if (attribute.type == VFXValueType.Uint32) { initialValues[0] = attribute.value.Get <uint>(); } else if (attribute.type == VFXValueType.Boolean) { initialValues[0] = attribute.value.Get <bool>() ? 1.0f : 0.0f; } for (int i = 0; i < size; ++i) { values.GetArrayElementAtIndex(i).floatValue = initialValues[i]; } serializedObject.ApplyModifiedProperties(); }); } menu.ShowAsContext(); }; Action <Rect, SerializedProperty, int> fnDrawElement = delegate(Rect r, SerializedProperty property, int index) { var element = property.GetArrayElementAtIndex(index); var label = element.FindPropertyRelative("attribute.m_Name").stringValue; var labelWidth = 110;//GUI.skin.label.CalcSize(new GUIContent(label)); //Should be maximized among all existing property, for now, angularVelocity is considered as maximum EditorGUI.LabelField(new Rect(r.x, r.y, labelWidth, EditorGUIUtility.singleLineHeight), label); var valueType = (VFXValueType)element.FindPropertyRelative("type").intValue; var valueSize = VFXExpression.TypeToSize(valueType); var fieldWidth = (r.width - labelWidth) / valueSize; var emptyGUIContent = new GUIContent(string.Empty); var valuesProperty = element.FindPropertyRelative("values"); if (valueType == VFXValueType.Float || valueType == VFXValueType.Float2 || valueType == VFXValueType.Float3 || valueType == VFXValueType.Float4) { if (label.Contains("color") && valueType == VFXValueType.Float3) { var oldColor = new Color(valuesProperty.GetArrayElementAtIndex(0).floatValue, valuesProperty.GetArrayElementAtIndex(1).floatValue, valuesProperty.GetArrayElementAtIndex(2).floatValue); EditorGUI.BeginChangeCheck(); var newColor = EditorGUI.ColorField(new Rect(r.x + labelWidth, r.y, fieldWidth * 3, EditorGUIUtility.singleLineHeight), oldColor); if (EditorGUI.EndChangeCheck()) { valuesProperty.GetArrayElementAtIndex(0).floatValue = newColor.r; valuesProperty.GetArrayElementAtIndex(1).floatValue = newColor.g; valuesProperty.GetArrayElementAtIndex(2).floatValue = newColor.b; } } else { for (int i = 0; i < valueSize; ++i) { EditorGUI.PropertyField(new Rect(r.x + labelWidth + fieldWidth * i, r.y, fieldWidth, EditorGUIUtility.singleLineHeight), valuesProperty.GetArrayElementAtIndex(i), emptyGUIContent); } } } else if (valueType == VFXValueType.Int32 || valueType == VFXValueType.Uint32 || valueType == VFXValueType.Boolean) { var oldValue = valuesProperty.GetArrayElementAtIndex(0).floatValue; float newValue; var currentRect = new Rect(r.x + labelWidth, r.y, fieldWidth, EditorGUIUtility.singleLineHeight); EditorGUI.BeginChangeCheck(); if (valueType == VFXValueType.Boolean) { newValue = EditorGUI.Toggle(currentRect, emptyGUIContent, oldValue != 0.0f) ? 1.0f : 0.0f; } else { newValue = (float)EditorGUI.LongField(currentRect, emptyGUIContent, (long)oldValue); newValue = newValue < 0.0f ? 0.0f : newValue; } if (EditorGUI.EndChangeCheck()) { valuesProperty.GetArrayElementAtIndex(0).floatValue = newValue; serializedObject.ApplyModifiedProperties(); } } }; onClipEnterProperty = serializedObject.FindProperty("activationBehavior.onClipEnter.m_Name"); onClipExitProperty = serializedObject.FindProperty("activationBehavior.onClipExit.m_Name"); var clipEnterAttributesProperty = serializedObject.FindProperty("activationBehavior.clipEnterEventAttributes"); var clipExitAttributesProperty = serializedObject.FindProperty("activationBehavior.clipExitEventAttributes"); clipEnterAttributesPropertyList = new ReorderableList(serializedObject, clipEnterAttributesProperty, true, true, true, true); clipExitAttributesPropertyList = new ReorderableList(serializedObject, clipExitAttributesProperty, true, true, true, true); clipEnterAttributesPropertyList.drawHeaderCallback = (Rect r) => { EditorGUI.LabelField(r, "Enter Event Attributes"); }; clipExitAttributesPropertyList.drawHeaderCallback = (Rect r) => { EditorGUI.LabelField(r, "Exit Event Attributes"); }; clipEnterAttributesPropertyList.onAddDropdownCallback += (Rect buttonRect, ReorderableList list) => fnAssetDropDown(list, clipEnterAttributesProperty); clipExitAttributesPropertyList.onAddDropdownCallback += (Rect buttonRect, ReorderableList list) => fnAssetDropDown(list, clipExitAttributesProperty); clipEnterAttributesPropertyList.drawElementCallback = (Rect r, int index, bool active, bool focused) => fnDrawElement(r, clipEnterAttributesProperty, index); clipExitAttributesPropertyList.drawElementCallback = (Rect r, int index, bool active, bool focused) => fnDrawElement(r, clipExitAttributesProperty, index); }
void DrawStateInspector(int windowID) { State[] tempKeys = new State[stateInspectorPositions.Count]; stateInspectorPositions.Keys.CopyTo(tempKeys, 0); State curState = tempKeys[windowID]; if(Event.current.type == EventType.MouseDown && Event.current.button == 1) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Delete"), false, DeleteState, curState); menu.ShowAsContext (); Event.current.Use(); } foreach(LinkedStateReference stRef in curState.GetStateTransitions()) { GUILayout.BeginHorizontal(); GUILayout.Label(stRef.GetLabel()); stRef.SetState(LineStateSelector (stRef.GetState(), Color.blue, windowID, curState.inspectorCorner, curState, Direction.Forwards)); GUILayout.EndHorizontal(); } if(curState.GetType() == typeof(Machine)) { if(GUILayout.Button("Push")) { Selection.activeGameObject = curState.gameObject; stMachine = (Machine)curState; stateInspectorPositions = new Dictionary<State, Rect>(); triggerInspectorPositions = new Dictionary<TriggerManager, Rect>(); return; } } curState.DrawInspector(); GUI.DragWindow(); curState.inspectorCorner = new Vector2(stateInspectorPositions[curState].x, stateInspectorPositions[curState].y); }
private void ShowUI() { GUI.enabled = true; #region Classify EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button("Model", "ButtonLeft", GUILayout.Width(80))) { _currentClassify = "Model"; } if (GUILayout.Button("Rig", "ButtonMid", GUILayout.Width(80))) { _currentClassify = "Rig"; } if (GUILayout.Button("Animations", "ButtonRight", GUILayout.Width(80))) { _currentClassify = "Animations"; } GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); #endregion if (_currentClassify == "Model") { #region STL Meshes EditorGUILayout.BeginHorizontal(); GUILayout.Label("STL Meshes", "BoldLabel"); GUILayout.Label("(File Type:Binary)", "BoldLabel"); EditorGUILayout.EndHorizontal(); GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Scale Factor", GUILayout.Width(120)); GUILayout.TextField("1"); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("File Scale", GUILayout.Width(120)); GUILayout.TextField("1"); EditorGUILayout.EndHorizontal(); if (_fileName == "" && _trianglescount == "") { GetFileNameAndTrianglesCount(); } EditorGUILayout.BeginHorizontal(); GUILayout.Label("File Name", GUILayout.Width(120)); _fileName = GUILayout.TextField(_fileName); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Triangles Count", GUILayout.Width(120)); _trianglescount = GUILayout.TextField(_trianglescount); EditorGUILayout.EndHorizontal(); GUI.enabled = true; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Mesh Compression", GUILayout.Width(120)); if (GUILayout.Button(_meshCompression, "MiniPopup")) { GenericMenu gm = new GenericMenu(); gm.AddItem(new GUIContent("Off"), "Off" == _meshCompression, delegate() { _meshCompression = "Off"; }); gm.AddItem(new GUIContent("On"), "On" == _meshCompression, delegate() { _meshCompression = "On"; }); gm.ShowAsContext(); } EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Single Triangles Number", GUILayout.Width(120)); _singleTrianglesNumber = EditorGUILayout.IntField(_singleTrianglesNumber); EditorGUILayout.EndHorizontal(); GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Read/Write Enabled", GUILayout.Width(120)); GUILayout.Toggle(true, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Optimize Mesh", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Import BlendShapes", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Generate Colliders", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Keep Quads", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Swap UVs", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Generate Lightmap UVs", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); GUI.enabled = true; #endregion #region Normals & Tangents EditorGUILayout.BeginHorizontal(); GUILayout.Label("Normals & Tangents", "BoldLabel"); EditorGUILayout.EndHorizontal(); GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Normals", GUILayout.Width(120)); GUILayout.Button("None", "MiniPopup"); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Smoothing Angle", GUILayout.Width(120)); GUILayout.HorizontalSlider(0.3f, 0, 1); GUILayout.TextField("60"); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Tangents", GUILayout.Width(120)); GUILayout.Button("None - (Normals required)", "MiniPopup"); EditorGUILayout.EndHorizontal(); GUI.enabled = true; #endregion #region Materials EditorGUILayout.BeginHorizontal(); GUILayout.Label("Materials", "BoldLabel"); EditorGUILayout.EndHorizontal(); GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Import Materials", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); GUI.enabled = true; #endregion } else if (_currentClassify == "Rig") { #region Rig GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Animation Type", GUILayout.Width(120)); GUILayout.Button("Legacy", "MiniPopup"); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.Label("Generation", GUILayout.Width(120)); GUILayout.Button("Don't Import", "MiniPopup"); EditorGUILayout.EndHorizontal(); GUI.enabled = true; #endregion } else if (_currentClassify == "Animations") { #region Animations GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.Label("Import Animation", GUILayout.Width(120)); GUILayout.Toggle(false, ""); EditorGUILayout.EndHorizontal(); GUI.enabled = true; EditorGUILayout.BeginHorizontal(); EditorGUILayout.HelpBox("No animation data available in this STL model.", MessageType.Info); EditorGUILayout.EndHorizontal(); #endregion } #region Apply EditorGUILayout.BeginHorizontal(); GUILayout.Label(""); EditorGUILayout.EndHorizontal(); GUI.enabled = false; EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); GUILayout.Button("Revert"); GUILayout.Button("Apply"); EditorGUILayout.EndHorizontal(); GUI.enabled = true; #endregion #region CreateInstance EditorGUILayout.BeginHorizontal(); GUILayout.Label(""); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button("CreateInstance", GUILayout.Width(160))) { CreateInstance(); } _isSaveMesh = GUILayout.Toggle(_isSaveMesh, "Save Mesh"); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); #endregion }
void DoContextMenu() { var menu = new GenericMenu(); menu.AddItem(new GUIContent("Reset All"), false, () => { if (!UnityEditor.EditorUtility.DisplayDialog("Reset All Settings", "Reset all settings? This is not undo-able.", "Reset", "Cancel")) { return; } // Do not reset SettingVisibility.Unregistered foreach (var pref in UserSettings.FindUserSettings(m_Assemblies, SettingVisibility.Visible | SettingVisibility.Hidden | SettingVisibility.Unlisted)) { pref.Reset(); } m_SettingsInstance.Save(); }); if (EditorPrefs.GetBool("DeveloperMode", false)) { menu.AddSeparator(""); menu.AddItem(new GUIContent("Developer/List Settings By Key"), listByKey, () => { listByKey.SetValue(!listByKey, true); SearchForUserSettingAttributes(); }); menu.AddSeparator("Developer/"); menu.AddItem(new GUIContent("Developer/Show User Settings"), showUserSettings, () => { showUserSettings.SetValue(!showUserSettings, true); SearchForUserSettingAttributes(); }); menu.AddItem(new GUIContent("Developer/Show Project Settings"), showProjectSettings, () => { showProjectSettings.SetValue(!showProjectSettings, true); SearchForUserSettingAttributes(); }); menu.AddSeparator("Developer/"); menu.AddItem(new GUIContent("Developer/Show Unlisted Settings"), showHiddenSettings, () => { showHiddenSettings.SetValue(!showHiddenSettings, true); SearchForUserSettingAttributes(); }); menu.AddItem(new GUIContent("Developer/Show Unregistered Settings"), showUnregisteredSettings, () => { showUnregisteredSettings.SetValue(!showUnregisteredSettings, true); SearchForUserSettingAttributes(); }); menu.AddSeparator("Developer/"); menu.AddItem(new GUIContent("Developer/Open Project Settings File"), false, () => { var project = m_SettingsInstance.GetRepository(SettingsScope.Project); if (project != null) { var path = Path.GetFullPath(project.path); System.Diagnostics.Process.Start(path); } }); menu.AddItem(new GUIContent("Developer/Print All Settings"), false, () => { Debug.Log(UserSettings.GetSettingsString(m_Assemblies)); }); #if UNITY_2019_1_OR_NEWER menu.AddSeparator("Developer/"); menu.AddItem(new GUIContent("Developer/Recompile Scripts"), false, UnityEditorInternal.InternalEditorUtility.RequestScriptReload); #endif } menu.ShowAsContext(); }
private bool HistoryEntry(GitLogEntry entry, LogEntryState state, bool selected) { var entryRect = GUILayoutUtility.GetRect(Styles.HistoryEntryHeight, Styles.HistoryEntryHeight); var timelineBarRect = new Rect(entryRect.x + Styles.BaseSpacing, 0, 2, Styles.HistoryDetailsHeight); if (Event.current.type == EventType.Repaint) { var keyboardFocus = GUIUtility.keyboardControl == listID; var summaryRect = new Rect(entryRect.x, entryRect.y + (Styles.BaseSpacing / 2), entryRect.width, Styles.HistorySummaryHeight + Styles.BaseSpacing); var timestampRect = new Rect(entryRect.x, entryRect.yMax - Styles.HistoryDetailsHeight - (Styles.BaseSpacing / 2), entryRect.width, Styles.HistoryDetailsHeight); var authorRect = new Rect(timestampRect.xMax, timestampRect.y, timestampRect.width, timestampRect.height); var contentOffset = new Vector2(Styles.BaseSpacing * 2, 0); Styles.Label.Draw(entryRect, "", false, false, selected, keyboardFocus); Styles.Label.contentOffset = contentOffset; Styles.HistoryEntryDetailsStyle.contentOffset = contentOffset; Styles.Label.Draw(summaryRect, entry.Summary, false, false, selected, keyboardFocus); Styles.HistoryEntryDetailsStyle.Draw(timestampRect, entry.PrettyTimeString + " " + entry.AuthorName, false, false, selected, keyboardFocus); if (!string.IsNullOrEmpty(entry.MergeA)) { const float MergeIndicatorWidth = 10.28f; const float MergeIndicatorHeight = 12f; var mergeIndicatorRect = new Rect(entryRect.x + 7, summaryRect.y, MergeIndicatorWidth, MergeIndicatorHeight); GUI.DrawTexture(mergeIndicatorRect, Styles.MergeIcon); DrawTimelineRectAroundIconRect(entryRect, mergeIndicatorRect); summaryRect.Set(mergeIndicatorRect.xMax, summaryRect.y, summaryRect.width - MergeIndicatorWidth, summaryRect.height); } if (state == LogEntryState.Local && string.IsNullOrEmpty(entry.MergeA)) { const float LocalIndicatorSize = 6f; var localIndicatorRect = new Rect(entryRect.x + (Styles.BaseSpacing - 2), summaryRect.y + 5, LocalIndicatorSize, LocalIndicatorSize); DrawTimelineRectAroundIconRect(entryRect, localIndicatorRect); GUI.DrawTexture(localIndicatorRect, Styles.LocalCommitIcon); summaryRect.Set(localIndicatorRect.xMax, summaryRect.y, summaryRect.width - LocalIndicatorSize, summaryRect.height); } if (state == LogEntryState.Normal && string.IsNullOrEmpty(entry.MergeA)) { const float NormalIndicatorWidth = 6f; const float NormalIndicatorHeight = 6f; Rect normalIndicatorRect = new Rect(entryRect.x + (Styles.BaseSpacing - 2), summaryRect.y + 5, NormalIndicatorWidth, NormalIndicatorHeight); DrawTimelineRectAroundIconRect(entryRect, normalIndicatorRect); GUI.DrawTexture(normalIndicatorRect, Styles.DotIcon); } } else if (Event.current.type == EventType.ContextClick && entryRect.Contains(Event.current.mousePosition)) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Revert"), false, RevertCommit); menu.ShowAsContext(); Event.current.Use(); } else if (Event.current.type == EventType.MouseDown && entryRect.Contains(Event.current.mousePosition)) { Event.current.Use(); return(true); } return(false); }
void Selector(SerializedProperty property) { SpineAnimation attrib = (SpineAnimation)attribute; GenericMenu menu = new GenericMenu(); var animations = skeletonDataAsset.GetAnimationStateData().SkeletonData.Animations; for (int i = 0; i < animations.Count; i++) { string name = animations.Items[i].Name; if (name.StartsWith(attrib.startsWith)) menu.AddItem(new GUIContent(name), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); } menu.ShowAsContext(); }
// This function is called every editor gui update. In here we are diong our magic to show all to the user in a nice way. public override void OnInspectorGUI() { //Setting styles if (_descBoxStyle == null) { _descBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box")); _descBoxStyle.alignment = TextAnchor.UpperLeft; _descBoxStyle.normal.textColor = Color.white; _descBoxStyle.stretchWidth = true; _bigBoxStyle = new GUIStyle(GUI.skin.FindStyle("Box")); _bigBoxStyle.alignment = TextAnchor.UpperLeft; _bigBoxStyle.normal.textColor = Color.white; _bigBoxStyle.stretchHeight = true; _bigBoxStyle.normal.background = (Texture2D)Resources.Load("SourceBack"); _popupStyle = new GUIStyle(GUI.skin.FindStyle("Popup")); _popupStyle.fontStyle = (FontStyle.Normal); _popupStyle.stretchHeight = true; } EditorGUIUtility.LookLikeInspector(); serializedObject.Update(); // update the serialized object since the last time this method was called. BaseAction myTarget = (BaseAction)target; myTarget.UpdateInspector(); SerializedProperty script = serializedObject.FindProperty("m_Script"); EditorGUILayout.PropertyField(script, new GUIContent("Script", myTarget.GetActionDescription())); //Show first public visible fields with the Attribute "ShowAtfirst" SerializedProperty prop = serializedObject.GetIterator(); prop.NextVisible(true); do { if (ShouldShowFirst(prop)) { EditorGUILayout.PropertyField(prop, true); } } while (prop.NextVisible(false)); //then show Triggers Rect rect = EditorGUILayout.BeginVertical(); GUI.Box(rect, "", _bigBoxStyle); if (myTarget.IsSupportCustomTriggers()) { GUILayout.Space(5); // Add Trigger row - Combo-box + Add Button Rect addTriggerRect = EditorGUILayout.BeginHorizontal(); { if (_triggerToAdd != null) { // If user pressed on "Add" button - add the selected trigger to the action's supported triggers _supportedTriggers.InsertArrayElementAtIndex(0); _supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_triggerToAdd); ((Trigger)_supportedTriggers.GetArrayElementAtIndex(0).objectReferenceValue).CleanRules(); _triggerToAdd = null; } GUILayout.Box("Add Triger", _popupStyle); var evt = Event.current; if (evt.type == EventType.MouseDown) { //Getting all Triggers List <System.Type> possibleTriggers = myTarget.GetSupprtedTriggers(); var mousePos = evt.mousePosition; if (addTriggerRect.Contains(mousePos)) { // Now create the menu, add items and show it var menu = new GenericMenu(); for (int i = 0; i < possibleTriggers.Count; i++) { string triggerFriendlyName = ""; if (!_friendlyNames.ContainsKey(possibleTriggers[i].FullName)) { GameObject g = new GameObject("temp"); Trigger triggerTemp = (Trigger)g.AddComponent(possibleTriggers[i]); _friendlyNames.Add(possibleTriggers[i].FullName, triggerTemp.FriendlyName); DestroyImmediate(g); } triggerFriendlyName = _friendlyNames[possibleTriggers[i].FullName]; menu.AddItem(new GUIContent(triggerFriendlyName), false, AddTrigger, possibleTriggers[i]); } menu.ShowAsContext(); evt.Use(); } } } EditorGUILayout.EndHorizontal(); } // go over all the Action's supported triggers and add them to the inspector. for (int i = 0; i < _supportedTriggers.arraySize; i++) { //Get Trigger and update rules Trigger trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue; if (trigger == null) { ((BaseAction)target).InitializeSupportedTriggers(); EditorGUILayout.EndVertical(); return; } // Trigger Row - Foldout + Reset trigger button + Delete trigger Rect triggerRect = EditorGUILayout.BeginHorizontal(); { trigger.FoldoutOpen = GUIUtils.Foldout(trigger.FoldoutOpen, trigger.FriendlyName); if (trigger.FoldoutOpen) { List <System.Type> supprtedRules1 = trigger.GetSupportedRules(); Rect rectRuleAddButton = EditorGUILayout.BeginHorizontal(); GUILayout.Box("Add", _popupStyle, GUILayout.Width(50)); EditorGUILayout.EndHorizontal(); GUILayout.FlexibleSpace(); var evt = Event.current; if (evt.type == EventType.MouseDown) { var mousePos = evt.mousePosition; if (rectRuleAddButton.Contains(mousePos)) { // Now create the menu, add items and show it var menu1 = new GenericMenu(); for (int ri = 0; ri < supprtedRules1.Count(); ri++) { string ruleFriendlyName = ""; if (!_friendlyNames.ContainsKey(supprtedRules1[ri].FullName)) { GameObject g = new GameObject("temp"); BaseRule ruleTemp = (BaseRule)g.AddComponent(supprtedRules1[ri]); _friendlyNames.Add(supprtedRules1[ri].FullName, ruleTemp.FriendlyName); DestroyImmediate(g); } ruleFriendlyName = _friendlyNames[supprtedRules1[ri].FullName]; menu1.AddItem(new GUIContent(ruleFriendlyName), false, AddRule, supprtedRules1[ri]); } menu1.ShowAsContext(); evt.Use(); _triggerToAddRuleTo = trigger; } } } } EditorGUILayout.EndHorizontal(); SetTriggersContextMenu(triggerRect, myTarget, trigger); // show trigger's rules if opened if (trigger.FoldoutOpen) { SerializedObject obj = new SerializedObject(_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue); SerializedProperty rules = obj.FindProperty("Rules"); if (true) { // Add Trigger row - Combo-box + Add Button EditorGUILayout.BeginHorizontal(); { //Adding combo-box control to the inspector with the list of triggers. if (_triggerToAddRuleTo == trigger && _ruleToAdd != null) { // If user pressed on "Add" button - add the selected trigger to the action's supported triggers rules.InsertArrayElementAtIndex(0); rules.GetArrayElementAtIndex(0).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToAdd); // initialize rules _ruleToAdd = null; _triggerToAddRuleTo = null; } } EditorGUILayout.EndHorizontal(); GUILayout.Space(5); } for (int j = 0; j < rules.arraySize; j++) { BaseRule rule = (BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue; DrawRuleInspector(rule); //Reset Rule if (_ruleToReset != null && _ruleToReset == rule) { rule.ActionOwner = null; rules.GetArrayElementAtIndex(j).objectReferenceValue = myTarget.AddHiddenComponent(_ruleToReset.GetType()); // Save folded state ((BaseRule)rules.GetArrayElementAtIndex(j).objectReferenceValue).FoldoutOpen = rule.FoldoutOpen; _ruleToReset = null; } //Remove Rule if (_ruleToRemove != null && _ruleToRemove == rule) { // delete the trigger and reorganize the array var r = rules.GetArrayElementAtIndex(j).objectReferenceValue; rules.DeleteArrayElementAtIndex(j); ((BaseRule)r).ActionOwner = null; for (int k = j; k < rules.arraySize - 1; k++) { rules.MoveArrayElement(k + 1, k); } rules.arraySize--; _ruleToRemove = null; } } //Save changes to the rule obj.ApplyModifiedProperties(); } // Reset Trigger if (_triggerToReset != null && _triggerToReset == trigger) { trigger.ActionOwner = null; foreach (BaseRule r in trigger.Rules) { r.ActionOwner = null; } _supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue = myTarget.AddHiddenComponent(trigger.GetType()); Trigger oldTrigger = trigger; trigger = (Trigger)_supportedTriggers.GetArrayElementAtIndex(i).objectReferenceValue; trigger.CleanRules(); //trigger.SetDefaults(myTarget); myTarget.SetDefaultTriggerValues(i, trigger); // Save folded state trigger.FoldoutOpen = oldTrigger.FoldoutOpen; _triggerToReset = null; break; } // Remove Trigger if (_triggerToRemove != null && _triggerToRemove == trigger) { // delete the trigger and reorganize the array _supportedTriggers.DeleteArrayElementAtIndex(i); trigger.ActionOwner = null; if (trigger.Rules != null) { foreach (BaseRule r in trigger.Rules) { if (r != null) { r.ActionOwner = null; } } } for (int j = i; j < _supportedTriggers.arraySize - 1; j++) { _supportedTriggers.MoveArrayElement(j + 1, j); } _supportedTriggers.arraySize--; break; } } EditorGUILayout.Space(); EditorGUILayout.EndVertical(); // Draw the rest of the control except several predefined fields or the fields which are marked as show first prop = serializedObject.GetIterator(); prop.NextVisible(true); do { if (prop.name != "m_Script" && !ShouldShowFirst(prop)) { EditorGUILayout.PropertyField(prop, true); } } while (prop.NextVisible(false)); //Save changes to the Action Script serializedObject.ApplyModifiedProperties(); }
void Selector(SerializedProperty property) { SpineBone attrib = (SpineBone)attribute; SkeletonData data = skeletonDataAsset.GetSkeletonData(true); if (data == null) return; GenericMenu menu = new GenericMenu(); menu.AddDisabledItem(new GUIContent(skeletonDataAsset.name)); menu.AddSeparator(""); for (int i = 0; i < data.Bones.Count; i++) { string name = data.Bones.Items[i].Name; if (name.StartsWith(attrib.startsWith)) menu.AddItem(new GUIContent(name), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property)); } menu.ShowAsContext(); }
// ------------------------------------------------------------------------------- public static object ShowInspectorForType(System.Type type, object value, string name) { if (type == typeof(bool)) { return(EditorGUILayout.Toggle(name, (bool)value)); } else if (type == typeof(string)) { return(EditorGUILayout.TextField(name, (string)value)); } else if (type == typeof(int)) { return(EditorGUILayout.IntField(name, (int)value)); } else if (type == typeof(float)) { return(EditorGUILayout.FloatField(name, (float)value)); } else if (type == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(name, (Vector2)value)); } else if (type == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(name, (Vector3)value)); } else if (typeof(Enum).IsAssignableFrom(type)) { return(EditorGUILayout.EnumPopup(name, (Enum)value)); } else if (typeof(IList <>).IsAssignableFrom(type)) { EditorGUILayout.LabelField("TODO: LIST SUPPORT"); } else if (typeof(UnityEngine.Object).IsAssignableFrom(type)) { return(EditorGUILayout.ObjectField(name, (UnityEngine.Object)value, type, typeof(Component).IsAssignableFrom(type) || type == typeof(GameObject) || type == typeof(UnityEngine.Object))); } else if (type.IsGenericType && typeof(Variable <>).IsAssignableFrom(type.GetGenericTypeDefinition())) { EditorGUILayout.BeginHorizontal(); if (value == null) { value = System.Activator.CreateInstance(type); } var variableBoundMemberNameField = GetPrivateFieldInfo(value, "mBoundMemberName"); var variableBoundMemberName = (string)variableBoundMemberNameField.GetValue(value); bool isBound = (variableBoundMemberName != null); if (!isBound) { var variableValueField = GetPrivateFieldInfo(value, "mValue"); var variableValue = variableValueField.GetValue(value); var variableValuetype = variableValueField.FieldType; variableValueField.SetValue(value, ShowInspectorForType(variableValuetype, variableValue, name)); } else { var variableBoundOwnerField = GetPrivateFieldInfo(value, "mBoundOwner"); var variableBoundOwnerValue = (MonoBehaviour)variableBoundOwnerField.GetValue(value); if (variableBoundOwnerValue != null) { string path = GetComponentPath(variableBoundOwnerValue); EditorGUILayout.LabelField(name + ": " + path + "/" + variableBoundMemberName); } else { Debug.LogWarning("Bound value couldn't be found, the object may have been deleted? Unbinding..."); UnbindVariable(value); } } if (GUILayout.Button("@", GUILayout.Width(20), GUILayout.Height(16))) { var menu = new GenericMenu(); if (isBound) { menu.AddItem(new GUIContent("Unbind"), false, () => { UnbindVariable(value); }); } else { // Grab a list of all the GameObjects at the root of the scene List <GameObject> sceneGameObjects = new List <GameObject>(); SceneManager.GetActiveScene().GetRootGameObjects(sceneGameObjects); var genericVariableType = type.GetGenericArguments()[0]; // Iterate over all the GameObjects at the root of the scene foreach (var gameObject in sceneGameObjects) { // For each scene object, iterate over all components (and children's components) // and look for any properties or fields that match our Variable's generic type foreach (var component in gameObject.GetComponentsInChildren <Component>()) { // GameObjects are special type because we can get at them from components.. var showComponentsForGameObjects = (genericVariableType == typeof(GameObject)); foreach (PropertyInfo componentPropertyInfo in component.GetType().GetProperties()) { var propertyType = componentPropertyInfo.PropertyType; // Do we actually want to bind to the gameObject property on a component, rather than the component itself? var bindGameObjectFromMonoBehaviour = (showComponentsForGameObjects && typeof(MonoBehaviour).IsAssignableFrom(propertyType)); if (bindGameObjectFromMonoBehaviour || propertyType == genericVariableType || genericVariableType.IsAssignableFrom(propertyType)) { var menuPath = "Properties/" + GetComponentPath(component) + "/" + componentPropertyInfo.Name; menu.AddItem(new GUIContent(menuPath), false, () => { BindVariable(value, component, componentPropertyInfo); }); } } foreach (FieldInfo componentFieldInfo in component.GetType().GetFields()) { var fieldType = componentFieldInfo.FieldType; var bindGameObjectFromComponent = (showComponentsForGameObjects && typeof(MonoBehaviour).IsAssignableFrom(fieldType)); if (bindGameObjectFromComponent || fieldType == genericVariableType || genericVariableType.IsAssignableFrom(fieldType)) { var menuPath = "Fields/" + GetComponentPath(component) + "/" + componentFieldInfo.Name; menu.AddItem(new GUIContent(menuPath), false, () => { MemberInfo memberToBind = componentFieldInfo; // Do we actually want to bind to the gameObject property on a component, rather than the component itself? if (bindGameObjectFromComponent) { memberToBind = component.GetType().GetProperty("gameObject"); } BindVariable(value, component, memberToBind); }); } } } } } menu.ShowAsContext(); } EditorGUILayout.EndHorizontal(); } else { EditorGUILayout.LabelField("Couldn't display inspector for '" + name + "' of type: " + type.ToString()); } return(value); }
private void OnGUI() { switch (Event.current.type) { case EventType.KeyDown: if ((Event.current.modifiers & ~EventModifiers.FunctionKey) == EventModifiers.Control && (Event.current.keyCode == KeyCode.PageUp || Event.current.keyCode == KeyCode.PageDown)) { SelectAdjacentCodeTab(Event.current.keyCode == KeyCode.PageDown); Event.current.Use(); GUIUtility.ExitGUI(); } else if (Event.current.alt && EditorGUI.actionKey) { if (Event.current.keyCode == KeyCode.RightArrow || Event.current.keyCode == KeyCode.LeftArrow) { if (Event.current.shift) { MoveThisTab(Event.current.keyCode == KeyCode.RightArrow); } else { SelectAdjacentCodeTab(Event.current.keyCode == KeyCode.RightArrow); } Event.current.Use(); GUIUtility.ExitGUI(); } } else if (!Event.current.alt && !Event.current.shift && EditorGUI.actionKey) { if (Event.current.keyCode == KeyCode.W || Event.current.keyCode == KeyCode.F4) { Event.current.Use(); FGCodeWindow codeTab = GetAdjacentCodeTab(false); if (codeTab == null) codeTab = GetAdjacentCodeTab(true); Close(); if (codeTab != null) codeTab.Focus(); } } //else if (!Event.current.alt && !Event.current.shift && EditorGUI.actionKey) //{ // if (Event.current.keyCode == KeyCode.M) // { // Event.current.Use(); // ToggleMaximized(); // GUIUtility.ExitGUI(); // } //} break; case EventType.DragUpdated: case EventType.DragPerform: if (DragAndDrop.objectReferences.Length > 0) { bool ask = false; HashSet<Object> accepted = new HashSet<Object>(); foreach (Object obj in DragAndDrop.objectReferences) { if (AssetDatabase.GetAssetPath(obj).EndsWith(".dll", System.StringComparison.OrdinalIgnoreCase)) continue; if (obj is MonoScript) accepted.Add(obj); else if (obj is TextAsset || obj is Shader) accepted.Add(obj); else if (obj is Material) { Material material = obj as Material; if (material.shader != null) { int shaderID = material.shader.GetInstanceID(); if (shaderID != 0) { if (!string.IsNullOrEmpty(AssetDatabase.GetAssetPath(shaderID))) accepted.Add(material.shader); } } } else if (obj is GameObject) { GameObject gameObject = obj as GameObject; MonoBehaviour[] monoBehaviours = gameObject.GetComponents<MonoBehaviour>(); foreach (MonoBehaviour mb in monoBehaviours) { MonoScript monoScript = MonoScript.FromMonoBehaviour(mb); if (monoScript != null) { if (!string.IsNullOrEmpty(AssetDatabase.GetAssetPath(monoScript))) { accepted.Add(monoScript); ask = true; } } } } } if (accepted.Count > 0) { DragAndDrop.AcceptDrag(); DragAndDrop.visualMode = DragAndDropVisualMode.Copy; if (Event.current.type == EventType.DragPerform) { Object[] sorted = accepted.OrderBy((x) => x.name, System.StringComparer.OrdinalIgnoreCase).ToArray(); if (ask && sorted.Length > 1) { GenericMenu popupMenu = new GenericMenu(); foreach (Object target in sorted) { Object tempTarget = target; popupMenu.AddItem( new GUIContent("Open " + System.IO.Path.GetFileName(AssetDatabase.GetAssetPath(target))), false, () => { OpenNewWindow(tempTarget, this, true); }); } popupMenu.AddSeparator(""); popupMenu.AddItem( new GUIContent("Open All"), false, () => { foreach (Object target in sorted) OpenNewWindow(target, this); }); popupMenu.ShowAsContext(); } else { foreach (Object target in sorted) OpenNewWindow(target, this, sorted.Length == 1); } } Event.current.Use(); return; } } break; case EventType.ValidateCommand: if (Event.current.commandName == "ScriptInspector.AddTab") { Event.current.Use(); return; } break; case EventType.ExecuteCommand: if (Event.current.commandName == "ScriptInspector.AddTab") { Event.current.Use(); OpenNewWindow(targetAsset, this); return; } break; } wantsMouseMove = true; textEditor.OnWindowGUI(this, new RectOffset(0, 0, 19, 1)); }
static void OnItemGUI(int instanceID, Rect rect) { var instance = EditorUtility.InstanceIDToObject(instanceID) as GameObject; if (instance == null) { return; } var prefabInstance = instance.GetComponent <PEPrefabScript>(); var isPrefab = PrefabUtility.GetPrefabParent(instance) && PEUtils.FindRootPrefab(instance) == instance; if (prefabInstance) { if (Event.current.type == EventType.Repaint && PEUtils.FindRootPrefab(Selection.activeGameObject) == instance && Selection.activeGameObject != instance) { EditorGUI.DrawRect(rect, new Color(0, 1, 0, 0.25f)); } bool rootPrefab = PrefabUtility.GetPrefabParent(prefabInstance.gameObject) == prefabInstance.Prefab; var color = GUI.color; GUI.color = rootPrefab ? Color.green : (Color.yellow); if (!prefabInstance.enabled) { GUI.color = Color.white; } if (prefabInstance.Prefab == null) { GUI.color = Color.red; } const int width = 15; var br = rect; br.height -= 2; br.y += 2 / 2; br.x += br.width - width; br.width = width; var content = new GUIContent(PEResources.icon, prefabInstance.Prefab ? prefabInstance.Prefab.name : "Missiog prefab with guid: " + prefabInstance.PrefabGUID); var click = GUI.Button(br, content, emptyStyle); GUI.color = color; var evt = Event.current; if (prefabInstance.Prefab && (evt.type == EventType.ContextClick || click || evt.type == EventType.MouseUp)) { var mousePos = evt.mousePosition; if (br.Contains(mousePos)) { var menu = new GenericMenu(); BuildMenu(menu, prefabInstance, rootPrefab); menu.ShowAsContext(); evt.Use(); } } } else if (isPrefab) { var click = PEPrefs.AutoPrefabs; if (click) { MakeNested(instance); } } }
private void DoPopupMenu(EditorWindow console) { var listView = consoleListViewField.GetValue(console); int listViewRow = listView != null ? (int) listViewStateRowField.GetValue(listView) : -1; if (listViewRow < 0) return; string text = (string)consoleActiveTextField.GetValue(console); if (string.IsNullOrEmpty(text)) return; GenericMenu codeViewPopupMenu = new GenericMenu(); string[] lines = text.Split('\n'); foreach (string line in lines) { int atAssetsIndex = line.IndexOf("(at Assets/"); if (atAssetsIndex < 0) continue; int functionNameEnd = line.IndexOf('('); if (functionNameEnd < 0) continue; string functionName = line.Substring(0, functionNameEnd).TrimEnd(' '); int lineIndex = line.LastIndexOf(':'); if (lineIndex <= atAssetsIndex) continue; int atLine = 0; for (int i = lineIndex + 1; i < line.Length; ++i) { char c = line[i]; if (c < '0' || c > '9') break; atLine = atLine * 10 + (c - '0'); } atAssetsIndex += "(at ".Length; string assetPath = line.Substring(atAssetsIndex, lineIndex - atAssetsIndex); string scriptName = assetPath.Substring(assetPath.LastIndexOf('/') + 1); string guid = AssetDatabase.AssetPathToGUID(assetPath); if (!string.IsNullOrEmpty(guid)) { codeViewPopupMenu.AddItem( new GUIContent(scriptName + " - " + functionName.Replace(':', '.') + ", line " + atLine), false, () => FGCodeWindow.OpenAssetInTab(guid, atLine)); } } if (codeViewPopupMenu.GetItemCount() > 0) codeViewPopupMenu.ShowAsContext(); }
public override void Clicked(int button) { var window = StateWindow.Get(); var stateRow = (StateRow)this.row.target; int rowIndex = window.rowIndex[stateRow]; var selected = this.row.table.rows.Where(x => x.selected).ToArray(); if (Event.current.alt && stateRow.requirements.Length > 1) { int length = stateRow.requirements.Length; rowIndex += button == 1 ? -1 : 1; if (rowIndex < 0) { rowIndex = length - 1; } if (rowIndex >= length) { rowIndex = 0; } window.rowIndex[stateRow] = rowIndex; window.BuildTable(); return; } if (!this.row.selected && button == 1) { this.delayedContext = true; } if (button == 0 || !this.row.selected) { if (Event.current.shift) { var allRows = this.row.table.rows; int firstIndex = selected.Length < 1 ? allRows.Count - 1 : allRows.FindIndex(x => x == selected.First()); int lastIndex = selected.Length < 1 ? 0 : allRows.FindIndex(x => x == selected.Last()); int current = allRows.FindIndex(x => x == this.row); int closest = current.Closest(firstIndex, lastIndex); foreach (var row in allRows.Skip(current.Min(closest)).Take(current.Distance(closest) + 1)) { row.selected = !row.disabled; } } else { bool state = !this.row.selected; if (!Event.current.control) { window.DeselectAll(); } this.row.selected = state; } } else if (button == 1) { var menu = new GenericMenu(); string term = selected.Any(x => x.target is StateRow && !x.target.As <StateRow>().section.IsEmpty()) ? "Regroup" : "Group"; menu.AddItem(term + " Selected", false, window.GroupSelected); if (selected.Count(x => !x.target.As <StateRow>().section.IsEmpty()) > 0) { menu.AddItem("Ungroup Selected", false, window.UngroupSelected); } menu.AddItem("Selection/Invert", false, window.InvertSelection); menu.AddItem("Selection/Deselect All", false, window.DeselectAll); if (selected.Length == 1) { menu.AddItem("Add Alternate Row", false, this.AddAlternativeRow, stateRow); if (rowIndex != 0) { menu.AddItem("Remove Alternative Row", false, this.RemoveAlternativeRow, stateRow); } } menu.ShowAsContext(); } window.Repaint(); }
void MouseListener() { // Figure out where the mouse is relative to the DecalGroup layout mouseOver_groupIndex = -1; mouseOver_textureIndex = -1; if(!textureDisplayRect.Contains(e.mousePosition)) return; // first check hovering rect. use this hovering struct because otherwise the gui // runs on/off when checking hover status (if it's over, move it, but then it's moved so // it's not over, and move back... cyclical logic ftw) if(dragging && hovering.bounds.Contains(mousePositionInGroupRect)) { mouseOver_groupIndex = hovering.groupIndex; mouseOver_textureIndex = hovering.textureIndex; } else { if(textureDisplayRect.Contains(e.mousePosition)) for(int i = 0; i < groupRects.Length; i++) { if( groupRects[i].Contains(mousePositionInGroupRect) ) { mouseOver_groupIndex = i; for(int j = 0; j < decalRects[i].Length; j++) { if(decalRects[i][j].Contains(mousePositionInGroupRect)) mouseOver_textureIndex = j; } break; } } } switch(Event.current.type) { case EventType.MouseDown: mouseOrigin = e.mousePosition; if(mouseOver_groupIndex > -1 && mouseOver_textureIndex > -1) validDrag = true; else validDrag = false; break; case EventType.MouseDrag: if(!validDrag) return; if(Vector2.Distance(mouseOrigin, e.mousePosition) > 7f && !dragging && mouseOver_groupIndex > -1 && mouseOver_textureIndex > -1) { dragging = true; dragOriginIndex = mouseOver_groupIndex; if(!selected.Contains(mouseOver_groupIndex, mouseOver_textureIndex)) { selected.Clear(); selected.Add(mouseOver_groupIndex, mouseOver_textureIndex); } dragTextures = new List<Texture2D>(); dragMouseOffset = new List<Vector2>(); foreach(KeyValuePair<int, List<int>> kvp in selected) { bool exit = false; foreach(int n in kvp.Value) { Rect r = decalRects[kvp.Key][n]; dragMouseOffset.Add(new Vector2(r.x - mousePositionInGroupRect.x, r.y - mousePositionInGroupRect.y)); dragTextures.Add(decalGroups[kvp.Key].decals[n].texture); } if(exit) break; } } if(dragging) Repaint(); break; case EventType.Ignore: dragging = false; dragTextures = null; Repaint(); break; case EventType.MouseUp: if(dragging) { dragTextures = null; List<QD.Decal> imgs = new List<QD.Decal>(); foreach(KeyValuePair<int, List<int>> kvp in selected) foreach(int n in kvp.Value) imgs.Add( decalGroups[kvp.Key].decals[n] ); // since we might remove some decals that are before the insert point, // this offset accounts for it and puts the new images in the right place even afeter // deletion int textureOffset = 0; if(selected.ContainsKey(mouseOver_groupIndex)) { foreach(int n in selected[mouseOver_groupIndex]) if(n < mouseOver_textureIndex) textureOffset++; } DeleteSelectedDecals(); PerformDragDrop(imgs, mouseOver_groupIndex, mouseOver_textureIndex-textureOffset); PruneGroups(); } if(!e.shift) selected.Clear(); if(mouseOver_groupIndex > -1) { if(selected.ContainsKey(mouseOver_groupIndex)) { if(mouseOver_textureIndex > -1) { if(!selected[mouseOver_groupIndex].Contains(mouseOver_textureIndex)) selected[mouseOver_groupIndex].Add(mouseOver_textureIndex); else selected[mouseOver_groupIndex].Remove(mouseOver_textureIndex); } } else { if(mouseOver_textureIndex > -1) selected.Add(mouseOver_groupIndex, new List<int>() { mouseOver_textureIndex }); else selected.Add(mouseOver_groupIndex, new List<int>()); } GUIUtility.keyboardControl = 0; GUI.FocusControl(""); } Repaint(); break; case EventType.ContextClick: GenericMenu menu = new GenericMenu(); menu.AddItem (new GUIContent("Open as Floating Window", ""), false, ContextOpenFloatingWindow); menu.AddItem (new GUIContent("Open as Dockable Window", ""), false, ContextOpenDockableWindow); menu.ShowAsContext (); e.Use(); break; } }
public override void OnInspectorGUI() { if (GUILayout.Button("ADD")) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Keycodes"), false, AddAxis, -2); menu.AddItem(new GUIContent("Mouse/Horizontal"), false, AddAxis, 1); menu.AddItem(new GUIContent("Mouse/Vertical"), false, AddAxis, 0); menu.AddItem(new GUIContent("Mouse/Wheel"), false, AddAxis, 2); menu.AddItem(new GUIContent("Joystick/Left Horizontal"), false, AddAxis, 3); menu.AddItem(new GUIContent("Joystick/Left Vertical"), false, AddAxis, 4); menu.AddItem(new GUIContent("Joystick/Right Horizontal"), false, AddAxis, 5); menu.AddItem(new GUIContent("Joystick/Right Vertical"), false, AddAxis, 6); menu.AddItem(new GUIContent("Custom Axis"), false, AddAxis, -1); menu.ShowAsContext(); } EditorGUILayout.Space(); EditorGUILayout.LabelField("Key Axes", EditorStyles.boldLabel); for (int i = 0; i < _keyAxes.arraySize; i++) { SerializedProperty child = _keyAxes.GetArrayElementAtIndex(i); string label = _axis.keyAxes[i].ToString(); EditorGUILayout.BeginHorizontal(); EditorGUILayout.PropertyField(child, new GUIContent(label), true); if (GUILayout.Button("X", GUILayout.Width(18), GUILayout.Height(18))) { _axis.keyAxes.RemoveAt(i); UpdateObject(); return; } EditorGUILayout.EndHorizontal(); } EditorGUILayout.Space(); EditorGUILayout.Space(); EditorGUILayout.LabelField("Non-Key Axes", EditorStyles.boldLabel); for (int i = 0; i < _nativeAxes.arraySize; i++) { SerializedProperty child = _nativeAxes.GetArrayElementAtIndex(i); string label = _axis.nativeAxes[i].GetEditorLabelName(); EditorGUILayout.BeginHorizontal(); EditorGUILayout.PropertyField(child, new GUIContent(label), true); if (GUILayout.Button("X", GUILayout.Width(18), GUILayout.Height(18))) { _axis.nativeAxes.RemoveAt(i); UpdateObject(); return; } EditorGUILayout.EndHorizontal(); string axisName = _axis.nativeAxes[i].GetAxisName(); try { UnityEngine.Input.GetAxis(axisName); } catch { EditorGUILayout.HelpBox("Vous devez avoir un axe nommé " + axisName + " dans l'input natif de unity.", MessageType.Error); } } serializedObject.ApplyModifiedProperties(); }
public override void OnInspectorGUI() { DrawToolbarGUI(); bool dirty = DrawGeneralGUI(); EditorGUILayout.BeginVertical(GUI.skin.box); showMarkers = Foldout(showMarkers, "2D Markers"); if (showMarkers) DrawMarkersGUI(); EditorGUILayout.EndVertical(); if (api.target == OnlineMapsTarget.texture) { EditorGUILayout.BeginVertical(GUI.skin.box); showCreateTexture = Foldout(showCreateTexture, "Create texture"); if (showCreateTexture) DrawCreateTextureGUI(ref dirty); EditorGUILayout.EndVertical(); } EditorGUILayout.BeginVertical(GUI.skin.box); showAdvanced = Foldout(showAdvanced, "Advanced"); if (showAdvanced) DrawAdvancedGUI(ref dirty); EditorGUILayout.EndVertical(); EditorGUILayout.BeginVertical(GUI.skin.box); showTroubleshooting = Foldout(showTroubleshooting, "Troubleshooting"); if (showTroubleshooting) DrawTroubleshootingGUI(ref dirty); EditorGUILayout.EndVertical(); OnlineMapsControlBase[] controls = api.GetComponents<OnlineMapsControlBase>(); if (controls == null || controls.Length == 0) { EditorGUILayout.BeginVertical(GUI.skin.box); EditorGUILayout.HelpBox("Problem detected:\nCan not find OnlineMaps Control component.", MessageType.Error); if (GUILayout.Button("Add Control")) { GenericMenu menu = new GenericMenu(); Type[] types = api.GetType().Assembly.GetTypes(); foreach (Type t in types) { if (t.IsSubclassOf(typeof(OnlineMapsControlBase))) { if (t == typeof(OnlineMapsControlBase2D) || t == typeof(OnlineMapsControlBase3D)) continue; string fullName = t.FullName.Substring(10); int controlIndex = fullName.IndexOf("Control"); fullName = fullName.Insert(controlIndex, " "); int textureIndex = fullName.IndexOf("Texture"); if (textureIndex > 0) fullName = fullName.Insert(textureIndex, " "); menu.AddItem(new GUIContent(fullName), false, data => { Type ct = data as Type; api.gameObject.AddComponent(ct); api.target = (ct == typeof (OnlineMapsTileSetControl)) ? OnlineMapsTarget.tileset : OnlineMapsTarget.texture; Repaint(); }, t); } } menu.ShowAsContext(); } EditorGUILayout.EndVertical(); } if (dirty) { EditorUtility.SetDirty(api); Repaint(); } }
private void DrawMaterialSettings() { string label = "Materials"; string id = "billboardeditor-materials"; GEditorCommon.Foldout(label, false, id, () => { GUI.enabled = false; atlasMaterial = EditorGUILayout.ObjectField("Atlas Material", atlasMaterial, typeof(Material), false) as Material; normalMaterial = EditorGUILayout.ObjectField("Normal Material", normalMaterial, typeof(Material), false) as Material; GUI.enabled = true; EditorGUILayout.BeginHorizontal(); srcColorProps = EditorGUILayout.TextField("Source Color", srcColorProps); if (GUILayout.Button(GEditorCommon.contextIconText, EditorStyles.label, GUILayout.Width(14))) { GenericMenu menu = new GenericMenu(); if (SrcColorSuggestion.Count > 0) { menu.AddDisabledItem(new GUIContent("Suggestion")); menu.AddSeparator(null); for (int i = 0; i < SrcColorSuggestion.Count; ++i) { string s = SrcColorSuggestion[i]; menu.AddItem( new GUIContent(s), false, () => { srcColorProps = s; RenderPreview(); }); } } else { menu.AddDisabledItem(new GUIContent("No suitable property found!")); } menu.ShowAsContext(); } EditorGUILayout.EndHorizontal(); //desColorProps = EditorGUILayout.TextField("Des Color", desColorProps); EditorGUILayout.BeginHorizontal(); srcTextureProps = EditorGUILayout.TextField("Source Texture", srcTextureProps); if (GUILayout.Button(GEditorCommon.contextIconText, EditorStyles.label, GUILayout.Width(14))) { GenericMenu menu = new GenericMenu(); if (SrcTextureSuggestion.Count > 0) { menu.AddDisabledItem(new GUIContent("Suggestion")); menu.AddSeparator(null); for (int i = 0; i < SrcTextureSuggestion.Count; ++i) { string s = SrcTextureSuggestion[i]; menu.AddItem( new GUIContent(s), false, () => { srcTextureProps = s; RenderPreview(); }); } } else { menu.AddDisabledItem(new GUIContent("No suitable property found!")); } menu.ShowAsContext(); } EditorGUILayout.EndHorizontal(); //desTextureProps = EditorGUILayout.TextField("Des Texture", desTextureProps); }); }
/// <summary> /// Default buttons can't handle generic menus as a result so we have to make our own buttons. Below /// this is how it's done. /// </summary> private void DrawAddForgeButton() { Event current = Event.current; Rect buttonRect = GUILayoutUtility.GetRect(ScriptForgeLabels.addWidget, m_Styles.buttonLeft); int controlID = GUIUtility.GetControlID(ScriptForgeLabels.addWidget, FocusType.Keyboard, buttonRect); if (current.type == EventType.MouseDown && buttonRect.Contains(current.mousePosition)) { m_AddForgeButtonSelected = true; GUIUtility.hotControl = controlID; current.Use(); Repaint(); } if (current.type == EventType.MouseUp) { m_AddForgeButtonSelected = false; if (buttonRect.Contains(current.mousePosition) && GUIUtility.hotControl == controlID) { GenericMenu menu = new GenericMenu(); Assembly assembly = Assembly.GetCallingAssembly(); Type[] types = assembly.GetTypes(); for (int i = 0; i < types.Length; i++) { if (!types[i].IsAbstract && typeof(Widget).IsAssignableFrom(types[i])) { bool hasInstance = false; for (int x = 0; x < m_Target.Widgets.Count; x++) { if (m_Target.Widgets[x].GetType() == types[i]) { hasInstance = true; break; } } // Get the menu path. string path = types[i].Name; // We don't want to show widgets that are required because they can never be removed. if (System.Attribute.GetCustomAttribute(types[i], typeof(RequiredWidgetAttribute)) == null) { if (System.Attribute.GetCustomAttribute(types[i], typeof(InDevelopmentAttribute)) != null) { path = "In Development/" + path; } if (hasInstance) { menu.AddDisabledItem(new GUIContent(path)); } else { menu.AddItem(new GUIContent(path), false, OnWidgetAdded, types[i]); } } } menu.ShowAsContext(); } } } else if (m_AddForgeButtonSelected && current.type == EventType.MouseUp) { m_AddForgeButtonSelected = false; current.Use(); GUIUtility.hotControl = 0; Repaint(); } if (current.type == EventType.Repaint) { m_Styles.buttonLeft.Draw(buttonRect, ScriptForgeLabels.addWidget, isHover: m_AddForgeButtonSelected, isActive: m_AddForgeButtonSelected, on: false, hasKeyboardFocus: false); } }
public override bool Render() { if (this.character == null) { return(false); } scroll = EditorGUILayout.BeginScrollView(scroll); bool delete = false; bool close = false; EditorGUILayout.BeginVertical(EditorStyles.helpBox); EditorGUILayout.VerticalScope clickArea = new EditorGUILayout.VerticalScope(); using (clickArea) { EditorGUILayout.BeginHorizontal(); if (showUniqueControls) { EditorGUI.BeginChangeCheck(); GUI.SetNextControlName("user"); GUIStyle style = GUI.GetNameOfFocusedControl() == "user" ? EditorStyles.textField : EditorStyles.label; string charactername = EditorGUILayout.TextField(GUIContent.none, this.character._Name, style); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(UndoObject, "Modify Character"); this.character._Name = charactername; } } else { EditorGUILayout.LabelField(this.character._Name, EditorStyles.label); } if (this.parent != null) { if (GUILayout.Button("Pop")) { this.Show(); TeamEditor teamEdit = Editor.CreateInstance <TeamEditor>(); teamEdit.Do(mission.FindTeam(character), mission); teamEdit.SetParent(this.parent); this.parent.auxWindow = teamEdit; this.parent = null; } } if (GUILayout.Button("X")) { Undo.RecordObject(UndoObject, "Remove Character"); if (this.parent != null) { TeamEditor teamEdit = Editor.CreateInstance <TeamEditor>(); teamEdit.Do(mission.FindTeam(this.character), mission); teamEdit.SetParent(this.parent); this.parent.auxWindow = teamEdit; this.parent = null; } else { this.Close(); } DestroyImmediate(character.SpawnCondition, true); mission.FindTeam(this.character).members.Remove(this.character); mission.RefreshCharacterDictionary(); } if (GUILayout.Button("Close", GUILayout.Width(55))) { close = true; } EditorGUILayout.EndHorizontal(); EditorGUI.BeginDisabledGroup(!showUniqueControls); EditorGUI.BeginChangeCheck(); EditorGUILayout.BeginHorizontal(); Sprite spr = EditorGUILayout.ObjectField(GUIContent.none, this.character.UIIcon, typeof(Sprite), false, GUILayout.Width(75)) as Sprite; GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); if (EditorGUI.EndChangeCheck()) { this.character.UIIcon = spr; } EditorGUI.EndDisabledGroup(); this.character.prefab = EditorGUILayout.ObjectField("Prefab", this.character.prefab, typeof(CharacterBody), false) as CharacterBody; GUILayout.Space(10); EditorGUILayout.LabelField("AI", EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUI.BeginChangeCheck(); AIBehaviour _behav = EditorGUILayout.ObjectField("Ai Behaviour", this.character.aiBehaviour, typeof(AIBehaviour), false) as AIBehaviour; if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(UndoObject, "Modify AI"); this.character.aiBehaviour = _behav; } if (this.character.aiBehaviour && mission != null) { if (character.onStartPath.Count != 0) { if (GUILayout.Button("Modify Path")) { PathMaker.Begin(SetStartPath, character.onStartPath); } } else { if (GUILayout.Button("Create Path")) { PathMaker.Begin(SetStartPath, new List <GridPosition>()); } } } GUILayout.Space(10); EditorGUI.indentLevel--; if (mission != null) { EditorGUILayout.Space(); EditorGUILayout.BeginHorizontal(); EditorGUILayout.Space(); Folds[0] = EditorGUILayout.Foldout(Folds[0], GUIContent.none); GUILayout.Space(-40); EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); if (Folds[0]) { EditorGUI.indentLevel++; EditorGUILayout.BeginHorizontal(); GUILayout.Space(18); this.character.SpawnPositon.EditorField(mission, EditorTools.CurrentInspectedGrid, new GUIContent("Position")); EditorGUILayout.EndHorizontal(); mission.ConditionSelector("Spawn Condition", ref ShowSpanwCondFold, ref character.SpawnCondition, ref currentSelectedCtype); EditorGUI.BeginChangeCheck(); GameGrid.BlockDirections.FaceDirections dir = (GameGrid.BlockDirections.FaceDirections)EditorGUILayout.EnumPopup("Face direction:", character.SpawnDirection); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(UndoObject, "Change Direction"); character.SpawnDirection = dir; } EditorGUI.indentLevel--; } } } Event e = Event.current; if (e.isMouse && e.button == 1 && clickArea.rect.Contains(e.mousePosition)) { GenericMenu CreateMenu = new GenericMenu(); if (CopyCharacter != null) { CreateMenu.AddItem(new GUIContent("Paste Character Values"), false, Paste); } else { CreateMenu.AddDisabledItem(new GUIContent("Paste Character Values")); } CreateMenu.AddItem(new GUIContent("Copy Character Values"), false, Copy); CreateMenu.ShowAsContext(); } EditorGUI.BeginDisabledGroup(!showUniqueControls); EditorGUILayout.BeginHorizontal(); EditorGUILayout.Space(); Folds[1] = EditorGUILayout.Foldout(Folds[1], GUIContent.none); GUILayout.Space(-40); EditorGUILayout.LabelField("Stats", EditorStyles.boldLabel); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); if (Folds[1]) { EditorGUI.indentLevel++; if (statsEditor == null) { statsEditor = new StatsEditor(character.stats, mission, UndoObject); } statsEditor.OnGUI(); EditorGUI.indentLevel--; } EditorGUILayout.Space(); EditorGUILayout.BeginHorizontal(); EditorGUILayout.Space(); Folds[2] = EditorGUILayout.Foldout(Folds[2], GUIContent.none); GUILayout.Space(-40); EditorGUILayout.LabelField("Inventory", EditorStyles.boldLabel); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); if (Folds[2]) { EditorGUI.BeginChangeCheck(); for (int i = 0; i < character.inventroy.Items.Count; i++) { if (!itemFolds.ContainsKey(character.inventroy.Items[i])) { RefreshDictionaries(); break; } } EditorGUI.indentLevel++; EditorGUILayout.BeginHorizontal(); int addItem = EditorGUILayout.Popup("Add Item", 0, EditorTools.ItemDatabase.ItemNames); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(UndoObject, "Modify Inventory"); int index = character.inventroy.Items.FindIndex(a => a.item == EditorTools.ItemDatabase.items[addItem]); if (index == -1) { character.inventroy.Items.Add(new ItemStack(EditorTools.ItemDatabase.items[addItem])); } else { character.inventroy.Items[index].amount++; } } EditorGUI.BeginDisabledGroup(ItemEditor.CopiedItem == null); if (GUILayout.Button("Paste")) { int index = character.inventroy.Items.FindIndex(a => a.item == ItemEditor.CopiedItem); Undo.RecordObject(UndoObject, "Modify Inventory"); if (index == -1) { character.inventroy.Items.Add(new ItemStack(ItemEditor.CopiedItem)); } else { character.inventroy.Items[index].amount++; } } EditorGUI.EndDisabledGroup(); EditorGUILayout.EndHorizontal(); int deleteIndex = -1; for (int i = 0; i < character.inventroy.Items.Count; i++) { if (itemFolds.ContainsKey(character.inventroy.Items[i])) { if (character.inventroy.Items[i].item == null) { character.inventroy.Items.RemoveAt(i); continue; } EditorGUILayout.BeginHorizontal(); itemFolds[character.inventroy.Items[i]] = EditorGUILayout.Foldout(itemFolds[character.inventroy.Items[i]], character.inventroy.Items[i].item.ItemName); character.inventroy.Items[i].amount = EditorGUILayout.IntField(character.inventroy.Items[i].amount); if (GUILayout.Button("X", GUILayout.Width(20)) || character.inventroy.Items[i].amount <= 0) { deleteIndex = i; } EditorGUILayout.EndHorizontal(); if (itemFolds[character.inventroy.Items[i]]) { EditorGUI.indentLevel++; cachedEditors[character.inventroy.Items[i]].OnInspectorGUI(); EditorGUI.indentLevel--; } } else { RefreshDictionaries(); } } if (deleteIndex != -1) { Undo.RecordObject(UndoObject, "Modify Inventory"); character.inventroy.Items.RemoveAt(deleteIndex); } EditorGUI.EndDisabledGroup(); EditorGUI.indentLevel--; } if (GUI.changed && !Application.isPlaying) { EditorUtility.SetDirty(UndoObject); } EditorGUILayout.EndHorizontal(); EditorGUILayout.EndScrollView(); return(delete || close); }