protected override void OnGUI()
{
PersistentGUILayout.PropertyField(target.Find("interactive"));
var transition = target.Find("transition");
PersistentGUILayout.PropertyField(transition);
if (!transition.hasMultipleDifferentValues)
{
EditorGUI.indentLevel += 1;
PersistentGUI.BeginLabelWidth(120f);
PersistentGUILayout.PropertyField(target.Find("targetGraphic"));
switch (transition.GetValue <Selectable.Transition>())
{
case Selectable.Transition.ColorTint:
var colorState = target.Find("colorState");
PersistentGUILayout.PropertyField(colorState.Find("normalColor"));
PersistentGUILayout.PropertyField(colorState.Find("focusedColor"));
PersistentGUILayout.PropertyField(colorState.Find("pressedColor"));
PersistentGUILayout.PropertyField(colorState.Find("disabledColor"));
break;
case Selectable.Transition.SpriteSwap:
var spriteState = target.Find("spriteState");
PersistentGUILayout.PropertyField(spriteState.Find("focusedSprite"));
PersistentGUILayout.PropertyField(spriteState.Find("pressedSprite"));
PersistentGUILayout.PropertyField(spriteState.Find("disabledSprite"));
break;
}
PersistentGUI.EndLabelWidth();
EditorGUI.indentLevel -= 1;
}
}
protected virtual void OnTitleGUI()
{
var title = new GUIContent(target.type.Name);
var rect = EditorGUILayout.GetControlRect(false, EditorStyles.toolbarButton.fixedHeight);
var fsize = EditorStyles.foldout.CalcSize(GUIContent.none);
var frect = new Rect(rect.x + 5, rect.y + (rect.height - fsize.y) * 0.5f, fsize.x, fsize.y);
var tsize = EditorStyles.toggle.CalcSize(GUIContent.none);
var trect = new Rect(frect.xMax, rect.y + (rect.height - tsize.y) * 0.5f - 1, tsize.x, tsize.y);
var lheight = EditorStyles.boldLabel.CalcHeight(title, rect.width);
var lrect = new Rect(trect.xMax, rect.y + (rect.height - lheight) * 0.5f, rect.width, lheight);
var controlId = GUIUtility.GetControlID(FocusType.Passive);
var eventType = Event.current.GetTypeForControl(controlId);
switch (eventType)
{
case EventType.Repaint:
{
EditorStyles.toolbarButton.Draw(rect, GUIContent.none, controlId, mFoldout);
EditorStyles.foldout.Draw(frect, GUIContent.none, controlId, mFoldout);
break;
}
case EventType.MouseDown:
{
if (rect.Contains(Event.current.mousePosition) &&
!trect.Contains(Event.current.mousePosition))
{
if (Event.current.button == 0)
{
mFoldout = !mFoldout;
Event.current.Use();
}
else if (Event.current.button == 1)
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent(Locale.L_RemoveLeaf), false, () =>
{
var leaves = target.GetValues <Leaf>();
UserUtil.RemoveLeaf(leaves);
});
menu.ShowAsContext();
Event.current.Use();
}
}
break;
}
}
if (enableDisplayed)
{
PersistentGUI.PropertyField(trect, GUIContent.none, target.Find("enabled"), false);
}
EditorGUI.LabelField(lrect, title, EditorStyles.boldLabel);
}
public override void OnGUI(Rect position, PersistentProperty property, GUIContent label)
{
var rect = position;
rect.height = EditorGUIUtility.singleLineHeight;
var propLength = property.Find("Length");
PersistentGUI.BeginShowMixedValue(propLength.hasMultipleDifferentValues);
EditorGUI.BeginChangeCheck();
var length = EditorGUI.DelayedIntField(rect, label, propLength.GetValue <int>());
if (EditorGUI.EndChangeCheck())
{
length = Mathf.Max(0, length);
property.ResizeArray(length);
}
PersistentGUI.EndShowMixedValue();
rect.y += EditorGUIUtility.singleLineHeight;
rect.y += EditorGUIUtility.standardVerticalSpacing;
var elType = property.type.GetElementType();
if (property.length == 1 &&
PersistentGUI.IsDefaultPropertyType(elType))
{
EditorGUI.indentLevel += 1;
var array = property.GetValue <Array>();
for (int i = 0; i < array.Length; i++)
{
EditorGUI.BeginChangeCheck();
var itemLabel = new GUIContent("Element " + i);
var itemValue = PersistentGUI.DefaultTypeField(rect, itemLabel, array.GetValue(i));
if (EditorGUI.EndChangeCheck())
{
var newArray = Array.CreateInstance(elType, array.Length);
Array.Copy(array, newArray, array.Length);
newArray.SetValue(itemValue, i);
property.SetValue(newArray);
}
rect.y += PersistentGUI.GetDefaultTypeHeight(itemLabel, elType);
rect.y += EditorGUIUtility.standardVerticalSpacing;
}
EditorGUI.indentLevel -= 1;
}
else
{
PersistentGUI.BeginColor(Color.yellow);
EditorGUI.LabelField(rect, new GUIContent("Array's element is not editable."));
PersistentGUI.EndColor();
}
}
private void DrawNetGrid()
{
PersistentGUI.BeginHandlesColor(UserSetting.NetGridLineColor);
for (int x = 0, index = 0; x < rect.width; x += UserSetting.NetGridLineSpace, index += 1)
{
Handles.DrawAAPolyLine(UserSetting.NetGridLineWidth * (index % 10 == 0 ? 2 : 1), new Vector3(x, 0, 0),
new Vector3(x, rect.height, 0));
}
for (int y = 0, index = 0; y < rect.height; y += UserSetting.NetGridLineSpace, index += 1)
{
Handles.DrawAAPolyLine(UserSetting.NetGridLineWidth * (index % 10 == 0 ? 2 : 1), new Vector3(0, y, 0),
new Vector3(rect.width, y, 0));
}
PersistentGUI.EndHandlesColor();
}
public virtual void OnDraw()
{
EditorGUI.DrawRect(rect, backgroundColor);
if (focused)
{
PersistentGUI.DrawAAPolyLine(rect, UserSetting.FrameFocusedLineWidth,
UserSetting.FrameFocusedLineColor);
}
GUILayout.BeginArea(rect);
if (scrollEnabled)
{
mScrollPos = GUILayout.BeginScrollView(mScrollPos);
}
PersistentGUI.BeginWideMode(rect.width > 330f);
OnGUI();
PersistentGUI.EndWideMode();
if (scrollEnabled)
{
GUILayout.EndScrollView();
}
GUILayout.EndArea();
var controlId = GUIUtility.GetControlID(FocusType.Passive);
var eventType = Event.current.GetTypeForControl(controlId);
switch (eventType)
{
case EventType.MouseDrag:
if (UserDragDrop.dragging)
{
if (new Rect(rect.x, rect.yMax - 20, rect.width, 20).Contains(Event.current.mousePosition))
{
mScrollPos += new Vector2(0, 2);
Event.current.Use();
}
else if (new Rect(rect.x, rect.y, rect.width, 20).Contains(Event.current.mousePosition))
{
mScrollPos -= new Vector2(0, 2);
Event.current.Use();
}
}
break;
}
}
public static void PropertyField(GUIContent label, PersistentProperty property, bool includeChildren,
params GUILayoutOption[] options)
{
Rect rect;
var propertyType = property.type;
var propertyDrawer = UserDatabase.caches.GetPropertyDrawer(propertyType);
if (propertyType == typeof(bool) && propertyDrawer == null)
{
rect = GetToggleRect(true, options);
}
else
{
rect = EditorGUILayout.GetControlRect(PersistentGUI.LabelHasContent(label),
PersistentGUI.GetPropertyHeight(label, property, includeChildren), options);
}
PersistentGUI.PropertyField(rect, label, property, includeChildren);
}
public override float GetHeight(PersistentProperty property, GUIContent label)
{
var height = EditorGUIUtility.singleLineHeight;
var elType = property.type.GetElementType();
if (property.length == 1 &&
PersistentGUI.IsDefaultPropertyType(elType))
{
var array = property.GetValue <Array>();
for (int i = 0; i < array.Length; i++)
{
var itemLabel = new GUIContent("Element " + i);
height += EditorGUIUtility.standardVerticalSpacing;
height += PersistentGUI.GetDefaultTypeHeight(itemLabel, elType);
}
}
else
{
height += EditorGUIUtility.singleLineHeight;
}
return(height);
}
private void OnDrawSelection()
{
var selectedNodes = UserDatabase.selection.nodes;
if (selectedNodes == null || selectedNodes.Length == 0)
{
return;
}
foreach (var selectedNode in selectedNodes)
{
PersistentGUI.BeginMatrix(GUI.matrix * selectedNode.guiMatrix);
var localRect = selectedNode.localRect;
var scale = selectedNode.worldScale;
scale.x = Mathf.Max(scale.x, 0.01f);
scale.y = Mathf.Max(scale.y, 0.01f);
var ww = UserSetting.SceneNodeSelectionLineWidth / scale.x;
var wh = UserSetting.SceneNodeSelectionLineWidth / scale.y;
var ww2 = ww * 0.5f;
var wh2 = wh * 0.5f;
PersistentGUI.BeginHandlesColor(UserSetting.SceneNodeSelectionColor);
Handles.DrawAAPolyLine(wh,
new Vector3(localRect.x + ww2, localRect.y + wh2, 0),
new Vector3(localRect.xMax - ww2, localRect.y + wh2, 0));
Handles.DrawAAPolyLine(ww,
new Vector3(localRect.xMax - ww2, localRect.y + wh2, 0),
new Vector3(localRect.xMax - ww2, localRect.yMax - wh2, 0));
Handles.DrawAAPolyLine(wh,
new Vector3(localRect.xMax - ww2, localRect.yMax - wh2, 0),
new Vector3(localRect.x + ww2, localRect.yMax - wh2, 0));
Handles.DrawAAPolyLine(ww,
new Vector3(localRect.x + ww2, localRect.yMax - wh2, 0),
new Vector3(localRect.x + ww2, localRect.y + wh2, 0));
PersistentGUI.EndHandlesColor();
PersistentGUI.EndMatrix();
}
}
protected override void OnGUI()
{
if (target == null)
{
EditorGUI.LabelField(nativeRect, Locale.L_Inspector, UserSetting.FrameTipsLabelStyle);
return;
}
PersistentGUI.BeginLabelWidth(100);
var brect = EditorGUILayout.GetControlRect(false, EditorStyles.toolbarButton.fixedHeight);
var tsize = EditorStyles.toggle.CalcSize(GUIContent.none);
var trect = new Rect(brect.x + 5, brect.y + (brect.height - tsize.y) * 0.5f - 1, tsize.x, tsize.y);
var lheight = EditorStyles.textField.CalcHeight(GUIContent.none, brect.width);
var lrect = new Rect(trect.xMax, brect.y + (brect.height - lheight) * 0.5f, brect.width - trect.xMax,
lheight);
PersistentGUI.PropertyField(trect, GUIContent.none, target.Find("enabled"));
PersistentGUI.PropertyField(lrect, GUIContent.none, target.Find("name"));
var nodes = target.GetValues <Node>();
if (nodes.Length > 1)
{
PersistentGUILayout.PropertyField(target.Find("anchoredPosition"));
PersistentGUILayout.PropertyField(target.Find("size"));
}
else
{
var node = nodes[0];
var anchorMin = node.anchorMin;
var anchorMax = node.anchorMax;
var labels = new GUIContent[4];
var props = new PersistentProperty[4];
if (anchorMin.x == anchorMax.x)
{
labels[0] = new GUIContent("Pos X");
props[0] = target.Find("anchoredPosition.x");
labels[2] = new GUIContent("Width");
props[2] = target.Find("size.x");
}
else
{
labels[0] = new GUIContent("Left");
props[0] = target.Find("offsetMin.x");
labels[2] = new GUIContent("Right");
props[2] = target.Find("offsetMax.x");
}
if (anchorMin.y == anchorMax.y)
{
labels[1] = new GUIContent("Pos Y");
props[1] = target.Find("anchoredPosition.y");
labels[3] = new GUIContent("Height");
props[3] = target.Find("size.y");
}
else
{
labels[1] = new GUIContent("Top");
props[1] = target.Find("offsetMin.y");
labels[3] = new GUIContent("Bottom");
props[3] = target.Find("offsetMax.y");
}
var position = EditorGUILayout.GetControlRect(false,
EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 2 : 3));
position.height = EditorGUIUtility.singleLineHeight;
PersistentGUI.MultiPropertyField2x2(position, new GUIContent("Position"), labels, props, 50);
}
PersistentGUILayout.PropertyField(target.Find("anchorMin"));
PersistentGUILayout.PropertyField(target.Find("anchorMax"));
PersistentGUILayout.PropertyField(target.Find("pivot"));
PersistentGUILayout.FloatSlider(target.Find("localAngle"), 0f, 360f);
PersistentGUILayout.PropertyField(target.Find("localScale"));
var leafTypes = new List <Type>();
foreach (var node in nodes)
{
var leaves = node.GetAllLeaves();
foreach (var leaf in leaves)
{
var leafType = leaf.GetType();
if (!leafTypes.Contains(leafType))
{
leafTypes.Add(leafType);
}
}
}
leafTypes = leafTypes.FindAll(t => nodes.All(n => n.GetLeaf(t) != null));
leafTypes.Sort((t1, t2) => String.Compare(t1.Name, t2.Name, StringComparison.Ordinal));
foreach (var leafType in leafTypes)
{
var leaves = Array.ConvertAll(nodes, n => n.GetLeaf(leafType));
var obj = new PersistentObject(leaves);
PersistentGUILayout.UserDrawerLayout(obj);
EditorGUILayout.Space();
}
if (nodes.Length > 1 && nodes.Any(n => n.GetAllLeaves(true).Count() != leafTypes.Count))
{
EditorGUILayout.Separator();
PersistentGUI.BeginColor(Color.yellow);
EditorGUILayout.LabelField(Locale.L_MultiEditLeavesTips);
PersistentGUI.EndColor();
}
EditorGUILayout.Separator();
if (GUILayout.Button(Locale.L_AddLeaf, GUILayout.MaxWidth(100)))
{
var allTypes = CoreUtil.FindSubTypes(typeof(Leaf));
Array.Sort(allTypes, (t1, t2) => String.Compare(t1.Name, t2.Name, StringComparison.Ordinal));
var menu = new GenericMenu();
foreach (var type in allTypes)
{
var leafType = type;
menu.AddItem(new GUIContent(leafType.Name), false, () => { UserUtil.AddLeaf(nodes, leafType); });
}
menu.ShowAsContext();
}
PersistentGUI.EndLabelWidth();
}
private void OnCommonEvent()
{
var controlId = GUIUtility.GetControlID(FocusType.Keyboard);
var eventType = Event.current.GetTypeForControl(controlId);
switch (eventType)
{
case EventType.MouseMove:
{
if (!nativeRect.Contains(Event.current.mousePosition))
{
break;
}
var selectedNodes = UserDatabase.selection.nodes;
if (selectedNodes == null || selectedNodes.Length == 0)
{
break;
}
var flag = false;
foreach (var selectedNode in selectedNodes)
{
PersistentGUI.BeginMatrix(GUI.matrix * selectedNode.guiMatrix);
var mousePos = Event.current.mousePosition;
var localRect = selectedNode.localRect;
var scale = selectedNode.worldScale;
scale.x = Mathf.Max(scale.x, 0.01f);
scale.y = Mathf.Max(scale.y, 0.01f);
var dragRects = CalcDragSizeRect(localRect, 4f / scale.x, 4f / scale.y);
var dir = Array.FindIndex(dragRects, r => r.Contains(mousePos));
switch (dir)
{
case Direction.Top:
case Direction.Bottom:
{
Cursor.SetState(Cursor.State.Vertical);
Event.current.Use();
break;
}
case Direction.Left:
case Direction.Right:
{
Cursor.SetState(Cursor.State.Horizontal);
Event.current.Use();
break;
}
case Direction.TopRight:
case Direction.BottomLeft:
{
Cursor.SetState(Cursor.State.Diagonal1);
Event.current.Use();
break;
}
case Direction.TopLeft:
case Direction.BottomRight:
{
Cursor.SetState(Cursor.State.Diagonal2);
Event.current.Use();
break;
}
}
PersistentGUI.EndMatrix();
if (dir >= 0)
{
Cursor.matrix = Node.BuildGUIRotationMatrix(selectedNode);
flag = true;
break;
}
}
if (!flag)
{
Cursor.SetState(Cursor.State.Default);
Cursor.matrix = Matrix4x4.identity;
Event.current.Use();
}
break;
}
case EventType.MouseDown:
{
if (!nativeRect.Contains(Event.current.mousePosition))
{
break;
}
if (Event.current.button != 0)
{
break;
}
GUIUtility.hotControl = controlId;
var dragState = (DragState)GUIUtility.GetStateObject(typeof(DragState), controlId);
dragState.dir = -1;
dragState.mousePos = Event.current.mousePosition;
var selectedNodes = UserDatabase.selection.nodes;
if (selectedNodes == null || selectedNodes.Length == 0)
{
break;
}
foreach (var selectedNode in selectedNodes)
{
PersistentGUI.BeginMatrix(GUI.matrix * selectedNode.guiMatrix);
var mousePos = Event.current.mousePosition;
var localRect = selectedNode.localRect;
var scale = selectedNode.worldScale;
scale.x = Mathf.Max(scale.x, 0.01f);
scale.y = Mathf.Max(scale.y, 0.01f);
var dragRects = CalcDragSizeRect(localRect, 4f / scale.x, 4f / scale.y);
var dir = Array.FindIndex(dragRects, r => r.Contains(mousePos));
if (dir >= 0 || localRect.Contains(mousePos))
{
dragState.dir = dir;
dragState.localPosition = selectedNodes.Select(i => i.localPosition).ToArray();
dragState.size = selectedNodes.Select(i => i.size).ToArray();
break;
}
PersistentGUI.EndMatrix();
}
break;
}
case EventType.MouseDrag:
{
if (!nativeRect.Contains(Event.current.mousePosition))
{
break;
}
if (Event.current.button != 0 || GUIUtility.hotControl != controlId)
{
break;
}
var selectedNodes = UserUtil.FilterNested(UserDatabase.selection.nodes);
if (selectedNodes == null || selectedNodes.Length == 0)
{
break;
}
foreach (var selectedNode in selectedNodes)
{
PersistentGUI.BeginMatrix(GUI.matrix * selectedNode.guiMatrix);
var delta = Event.current.delta;
var scale = selectedNode.localScale;
scale.x = Mathf.Abs(scale.x);
scale.y = Mathf.Abs(scale.y);
var pivot = selectedNode.pivot;
selectedNode.pivot = Vector2.zero;
var deltaMatrix = Matrix4x4.TRS(Vector3.zero,
Quaternion.Euler(0, 0, selectedNode.localAngle), scale);
var dragState = (DragState)GUIUtility.GetStateObject(typeof(DragState), controlId);
switch (dragState.dir)
{
case Direction.Top:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(0, delta.y));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
selectedNode.size += new Vector2(0, -delta.y);
break;
}
case Direction.Bottom:
{
selectedNode.size += new Vector2(0, delta.y);
break;
}
case Direction.Left:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(delta.x, 0));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
selectedNode.size += new Vector2(-delta.x, 0);
break;
}
case Direction.Right:
{
selectedNode.size += new Vector2(delta.x, 0);
break;
}
case Direction.TopLeft:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(delta.x, delta.y));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
selectedNode.size += new Vector2(-delta.x, -delta.y);
break;
}
case Direction.TopRight:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(0, delta.y));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
selectedNode.size += new Vector2(delta.x, -delta.y);
break;
}
case Direction.BottomRight:
{
selectedNode.size += new Vector2(delta.x, delta.y);
break;
}
case Direction.BottomLeft:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(delta.x, 0));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
selectedNode.size += new Vector2(-delta.x, delta.y);
break;
}
default:
{
var offset = deltaMatrix.MultiplyVector(new Vector2(delta.x, delta.y));
selectedNode.localPosition += new Vector2(offset.x, offset.y);
break;
}
}
selectedNode.pivot = pivot;
PersistentGUI.EndMatrix();
Event.current.Use();
}
break;
}
case EventType.MouseUp:
{
if (!nativeRect.Contains(Event.current.mousePosition))
{
break;
}
if (Event.current.button == 1)
{
UserMenu.ShowNodeContext(root);
Event.current.Use();
}
if (GUIUtility.hotControl != controlId)
{
break;
}
var dragState = (DragState)GUIUtility.GetStateObject(typeof(DragState), controlId);
if (Event.current.button == 0)
{
var selectedNodes = UserDatabase.selection.nodes;
if (selectedNodes != null && selectedNodes.Length > 0 && dragState.localPosition != null &&
selectedNodes.Length == dragState.localPosition.Length)
{
var commands = new List <Command>();
for (var i = 0; i < selectedNodes.Length; i++)
{
var selectedNode = selectedNodes[i];
PersistentGUI.BeginMatrix(GUI.matrix * selectedNode.guiMatrix);
var localPosition = dragState.localPosition[i];
var size = dragState.size[i];
var currentLocalPosition = selectedNode.localPosition;
var currentSize = selectedNode.size;
if (Vector2.Distance(localPosition, currentLocalPosition) >
UserSetting.DistanceComparisionTolerance ||
Vector2.Distance(size, currentSize) > UserSetting.DistanceComparisionTolerance)
{
selectedNode.localPosition = localPosition;
selectedNode.size = size;
commands.Add(new UpdateMemberCommand(selectedNode, "localPosition",
currentLocalPosition));
commands.Add(new UpdateMemberCommand(selectedNode, "size", currentSize));
}
PersistentGUI.EndMatrix();
}
if (commands.Count > 0)
{
Command.Execute(new CombinedCommand(commands.ToArray()));
Event.current.Use();
}
}
}
var mousePos = Event.current.mousePosition;
if (Event.current.button == 0 &&
Vector2.Distance(dragState.mousePos, mousePos) <
UserSetting.DistanceComparisionTolerance)
{
var hits = Raycaster.RaycastAll(mousePos, root);
if (hits.Length > 0)
{
var current = UserDatabase.selection.node;
if (current == null)
{
UserUtil.SelectNodes(new[] { hits[0] });
Event.current.Use();
}
else
{
var hold = hits[0];
var nodes = CoreUtil.CopyArray(UserDatabase.selection.nodes);
foreach (var node in nodes)
{
var index = Array.IndexOf(hits, node);
if (index >= 0)
{
ArrayUtility.Remove(ref nodes, node);
var next = index + 1;
if (next >= hits.Length)
{
next = 0;
}
hold = hits[next];
break;
}
}
if (Event.current.control)
{
if (nodes.Length > 0)
{
ArrayUtility.Add(ref nodes, hold);
}
}
else
{
nodes = new Node[] { hold };
}
UserUtil.SelectNodes(nodes);
Event.current.Use();
}
}
else
{
UserUtil.SelectNodes(null);
Event.current.Use();
}
}
GUIUtility.hotControl = 0;
break;
}
case EventType.KeyDown:
{
if (!focused)
{
break;
}
switch (Event.current.keyCode)
{
case KeyCode.Delete:
{
UserUtil.DeleteNodes();
Event.current.Use();
break;
}
case KeyCode.LeftArrow:
case KeyCode.RightArrow:
case KeyCode.UpArrow:
case KeyCode.DownArrow:
{
var selectedNodes = UserUtil.FilterNested(UserDatabase.selection.nodes);
if (selectedNodes == null || selectedNodes.Length == 0)
{
break;
}
foreach (var selectedNode in selectedNodes)
{
var distance = 1;
if (Event.current.control)
{
distance = 5;
}
else if (Event.current.shift)
{
distance = 10;
}
switch (Event.current.keyCode)
{
case KeyCode.LeftArrow:
{
Command.Execute(new UpdateMemberCommand(selectedNode, "localPosition",
selectedNode.localPosition + new Vector2(-distance, 0)));
Event.current.Use();
break;
}
case KeyCode.UpArrow:
{
Command.Execute(new UpdateMemberCommand(selectedNode, "localPosition",
selectedNode.localPosition + new Vector2(0, -distance)));
Event.current.Use();
break;
}
case KeyCode.RightArrow:
{
Command.Execute(new UpdateMemberCommand(selectedNode, "localPosition",
selectedNode.localPosition + new Vector2(distance, 0)));
Event.current.Use();
break;
}
case KeyCode.DownArrow:
{
Command.Execute(new UpdateMemberCommand(selectedNode, "localPosition",
selectedNode.localPosition + new Vector2(0, distance)));
Event.current.Use();
break;
}
}
}
break;
}
}
break;
}
case EventType.ValidateCommand:
{
if (!focused)
{
break;
}
if (Event.current.commandName == "Copy" ||
Event.current.commandName == "Paste" ||
Event.current.commandName == "Duplicate")
{
Event.current.Use();
}
break;
}
case EventType.ExecuteCommand:
{
if (!focused)
{
break;
}
switch (Event.current.commandName)
{
case "Copy":
{
UserUtil.CopyNodes(root);
Event.current.Use();
break;
}
case "Paste":
{
UserUtil.PasteNodes(root);
Event.current.Use();
break;
}
case "Duplicate":
{
UserUtil.DuplicateNodes(root);
Event.current.Use();
break;
}
}
break;
}
}
}
private void OnNodeGUI(Node node)
{
var nodeRect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
nodeRect.height += EditorGUIUtility.standardVerticalSpacing;
var selected = selectedNodes != null && selectedNodes.Contains(node);
if (selected)
{
EditorGUI.DrawRect(nodeRect,
focused ? UserSetting.HierarchySelectedFocusedColor : UserSetting.HierarchySelectedColor);
}
var controlId = GUIUtility.GetControlID(FocusType.Keyboard);
var eventType = Event.current.GetTypeForControl(controlId);
var mousePos = Event.current.mousePosition;
var foldout = UserDatabase.caches.GetHierarchyFoldout(node);
var topRect = new Rect(nodeRect.x, nodeRect.y - 2, nodeRect.width, 4);
var bottomRect = new Rect(nodeRect.x, nodeRect.yMax - 1, nodeRect.width, 4);
var centerRect = new Rect(nodeRect.x, nodeRect.y + 2, nodeRect.width, nodeRect.height - 4);
var fsize = EditorStyles.foldout.CalcSize(GUIContent.none);
var frect = new Rect(nodeRect.x + PersistentGUI.indent, nodeRect.y, fsize.x, fsize.y);
switch (eventType)
{
case EventType.Repaint:
{
if (node.childCount > 0)
{
EditorStyles.foldout.Draw(frect, GUIContent.none, controlId, foldout);
}
if (UserDatabase.highlight.node == node)
{
if (mHighlightProgress == 0)
{
UserDatabase.highlight.node = null;
}
else
{
var color = UserSetting.HierarchyHighlightColor;
color.a = (float)mHighlightProgress / mHighlightDuration;
PersistentGUI.DrawAAPolyLine(nodeRect, 2, color);
}
mHighlightProgress -= 1;
}
break;
}
case EventType.MouseDown:
{
if (node.childCount > 0 &&
frect.Contains(mousePos))
{
foldout = !foldout;
UserDatabase.caches.SetHierarchyFoldout(node, foldout);
Event.current.Use();
}
else if (nodeRect.Contains(mousePos) &&
(Event.current.button == 0 ||
Event.current.button == 1))
{
var nodes = UserDatabase.selection.nodes != null
? CoreUtil.CopyArray(UserDatabase.selection.nodes)
: new Node[0];
if (Event.current.control)
{
if (selected)
{
ArrayUtility.Remove(ref nodes, node);
}
else
{
ArrayUtility.Add(ref nodes, node);
var list = GUIUtility.GetStateObject(typeof(List <Node>), controlId) as List <Node>;
list.Add(node);
}
mTemps = nodes;
}
else if (Event.current.shift && nodes.Length > 0)
{
var filter = new List <Node>();
var list = new List <Node>();
foreach (var n in root)
{
FlattenNode(list, n);
}
var index = list.IndexOf(node);
var nIndex = nodes.Select(n => list.IndexOf(n)).Min();
var from = Mathf.Min(nIndex, index);
var to = Mathf.Max(nIndex, index);
for (var i = @from; i <= to; i++)
{
if (!filter.Contains(list[i]))
{
filter.Add(list[i]);
}
}
mTemps = filter.ToArray();
}
else
{
if (!selected)
{
mTemps = new[] { node }
}
;
if (node.childCount > 0 && Event.current.clickCount == 2)
{
foldout = !foldout;
UserDatabase.caches.SetHierarchyFoldout(node, foldout);
}
}
Event.current.Use();
}
break;
}
case EventType.MouseUp:
{
if (!focused || frect.Contains(mousePos))
{
break;
}
if (UserDragDrop.dragging)
{
var nodes = UserDragDrop.data as Node[];
if (nodes != null && nodes.Length > 0)
{
if (topRect.Contains(mousePos))
{
UserUtil.MoveNodes(nodes, node.parent, node.GetSiblingIndex());
UserDragDrop.StopDrag();
Cursor.SetState(Cursor.State.Default);
UserDatabase.caches.SetHierarchyFoldout(node.parent, true);
Event.current.Use();
}
else if (bottomRect.Contains(mousePos))
{
UserUtil.MoveNodes(nodes, node.parent, node.GetSiblingIndex() + 1);
UserDragDrop.StopDrag();
Cursor.SetState(Cursor.State.Default);
UserDatabase.caches.SetHierarchyFoldout(node.parent, true);
Event.current.Use();
}
else if (centerRect.Contains(mousePos))
{
UserUtil.MoveNodes(nodes, node, -1);
UserDragDrop.StopDrag();
Cursor.SetState(Cursor.State.Default);
UserDatabase.caches.SetHierarchyFoldout(node, true);
Event.current.Use();
}
}
}
else
{
if (Event.current.button == 0 && nodeRect.Contains(mousePos))
{
var nodes = UserDatabase.selection.nodes != null
? CoreUtil.CopyArray(UserDatabase.selection.nodes)
: new Node[0];
if (Event.current.control)
{
if (selected)
{
var list =
GUIUtility.QueryStateObject(typeof(List <Node>), controlId) as List <Node>;
if (list != null && list.Count > 0)
{
if (list[0] != node)
{
ArrayUtility.Remove(ref nodes, node);
UserUtil.SelectNodes(nodes);
}
list.Clear();
}
}
}
else if (!Event.current.shift)
{
if (selected)
{
UserUtil.SelectNodes(new[] { node });
}
}
if (Event.current.button != 1)
{
Event.current.Use();
}
}
}
break;
}
case EventType.MouseDrag:
{
if (focused && Event.current.button == 0 && !UserDragDrop.dragging)
{
var nodes = selectedNodes;
if (nodes != null && nodes.Contains(node) && nodeRect.Contains(mousePos))
{
var data = new Node[nodes.Length];
Array.Copy(nodes, data, data.Length);
UserDragDrop.StartDrag(data);
Cursor.SetState(Cursor.State.DragAnything);
Event.current.Use();
}
}
break;
}
}
EditorGUI.LabelField(new Rect(nodeRect.x + 12, nodeRect.y, nodeRect.width, nodeRect.height),
new GUIContent(node.name));
if (UserDragDrop.dragging)
{
var indentOffset = PersistentGUI.indent + 12;
if (topRect.Contains(mousePos))
{
PersistentGUI.DrawAAPolyLine(
new Rect(topRect.x + indentOffset, topRect.y, topRect.width - indentOffset, topRect.height), 2,
UserSetting.HierarchyDragTipsColor);
}
else if (centerRect.Contains(mousePos))
{
PersistentGUI.DrawAAPolyLine(
new Rect(centerRect.x + indentOffset, centerRect.y, centerRect.width - indentOffset,
centerRect.height), 2, UserSetting.HierarchyDragTipsColor);
}
}
if (foldout && node.childCount > 0)
{
EditorGUI.indentLevel += 1;
for (int i = 0; i < node.childCount; i++)
{
OnNodeGUI(node.GetChild(i));
}
EditorGUI.indentLevel -= 1;
}
else
{
if (UserDragDrop.dragging)
{
if (bottomRect.Contains(mousePos))
{
var indentOffset = PersistentGUI.indent + 12;
PersistentGUI.DrawAAPolyLine(
new Rect(bottomRect.x + indentOffset, bottomRect.y, bottomRect.width - indentOffset,
bottomRect.height), 2, UserSetting.HierarchyDragTipsColor);
}
}
}
}
public static bool ToggleBar(GUIContent label, bool value)
{
var rect = EditorGUILayout.GetControlRect(false, EditorStyles.toolbarButton.fixedHeight);
return(PersistentGUI.ToggleBar(rect, label, value));
}
public static void FloatSlider(PersistentProperty property, float leftValue, float rightValue)
{
var rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
PersistentGUI.FloatSlider(rect, new GUIContent(property.displayName), property, leftValue, rightValue);
}
