public static void OnNodeDrag(EditorStates states)
{
EditorState state = states.curState;
if (state.dragNode)
{
if (states.mousePos.x < CanvasGUI.CanvasRect.xMin || states.mousePos.x > CanvasGUI.CanvasRect.xMax)
{
states.mousePos.x = state.dragStartPos.x;
}
if (states.mousePos.y < CanvasGUI.CanvasRect.yMin || states.mousePos.y > CanvasGUI.CanvasRect.yMax)
{
states.mousePos.y = state.dragStartPos.y;
}
BaseNode node = state.selectedObject as BaseNode;
if (node is OptionNode && (node as OptionNode).MainNode)
{
EndNodeDrag(states);
}
state.dragDelta = states.mousePos - state.dragStartPos;
node.UpdateAllPosition(state.dragDelta);
state.dragStartPos = states.mousePos;
DialogueEditorGUI.Repaint();
}
}
public static void DuplicateNode(EditorStates states)
{
if (states.curState.selectedObject is DialogueNode)
{
DialogueEditorGUI.Cache.Nodes.DuplicateNode(states.curState.selectedObject as DialogueNode);
}
}
public static void UpdateSelection(EditorStates states)
{
if (string.IsNullOrEmpty(states.info))
{
throw new UnityException();
}
if (states.info == "none")
{
States.curState.focusedObjects = new ScriptableObject[] { null }
}
;
else
{
states.info = states.info.Substring(1, states.info.Length - 2);
string[] coords = states.info.Split(',');
if (coords.Length == 2)
{
states.curState.focusedObjects = CanvasGUI.ObjectAtPosition(new Vector2(float.Parse(coords[0]), float.Parse(coords[1])));
}
}
InputSystem.HandleEventSpace(states);
InputSystem.HandleSelecting(states);
}
public static void DeleteNode(EditorStates states)
{
EditorState state = states.curState;
DialogueEditorGUI.Cache.Nodes.Remove(state.selectedObject as DialogueNode);
(state.selectedObject as DialogueNode).Delete();
}
public static void LateInputEvents(EditorStates states)
{
if (!OverlayMenu.HasPopup)
{
CallEventHandler(states, true);
}
OverlayMenu.EndOverlay();
}
public static void AddNodules(EditorStates states, GenericMenu menu)
{
foreach (var noduleTypes in NoduleTypes.noduleTypes)
{
menu.AddMenuItem(new GUIContent("Add Nodule/" + noduleTypes.Key.ContextPath), false,
AddCallBack, new EditorStates(noduleTypes.Key.GetClassName, states));
}
}
public void Init()
{
States = new EditorStates(this);
DialogueEditorGUI.UpdateEnvironment(this);
Actors.Init();
Conditions.Init();
Nodes.Init();
}
public static void EndWindowPan(EditorStates states)
{
EditorState state = states.curState;
if (state.panWindow)
{
state.panWindow = false;
}
}
public static void HandleFocusing(EditorStates states)
{
if (unfocusControls == states && states.curEvent.type == EventType.Repaint)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
unfocusControls = null;
}
states.curState.focusedObjects = CanvasGUI.ObjectAtPosition(CanvasGUI.CanvasToScreenPosition(states.curState, states.mousePos));
}
static void CallEventHandler(EditorStates states, bool late)
{
foreach (var handler in eventHandlers)
{
if ((handler.eType == null || handler.eType == states.curEvent.type) &&
(handler.eSpace == EventSpace.Everything || handler.eSpace == states.curSpace) &&
(late ? handler.priority >= 100 : handler.priority < 100))
{
handler.actionDel.DynamicInvoke(new object[] { states });
}
}
}
public EditorStates(string message, EditorStates editorStates)
{
info = message;
mousePos = editorStates.mousePos;
curEvent = editorStates.curEvent;
curSpace = editorStates.curSpace;
states = editorStates.states;
curState = editorStates.curState;
capacity = editorStates.capacity;
curIndex = editorStates.curIndex;
}
public EditorStates(EditorStates editorStates)
{
info = editorStates.info;
mousePos = editorStates.mousePos;
curEvent = editorStates.curEvent;
curSpace = editorStates.curSpace;
states = editorStates.states;
curState = editorStates.curState;
capacity = editorStates.capacity;
curIndex = editorStates.curIndex;
}
static void CallHotkeyHandler(EditorStates states)
{
foreach (var handler in hotKeyHandlers)
{
if (handler.hotKey == states.curEvent.keyCode &&
(handler.eModifiers == null || handler.eModifiers == states.curEvent.modifiers) &&
(handler.eSpace == EventSpace.Everything || handler.eSpace == states.curSpace))
{
handler.actionDel.DynamicInvoke(new object[] { states });
}
}
}
public static void OnGUI(EditorStates states)
{
States = states;
EditorState curState = states.curState;
CanvasGUI.BeginGroup(new Rect(curState.panDelta, curState.canvasSize), (states.curSpace | EventSpace.CanvasSpace) == EventSpace.CanvasSpace);
for (int i = 0; i < Cache.Nodes.Count; i++)
{
Cache.Nodes.Get(i).DrawConnection();
}
if (curState.connectionIndex > -1)
{
BaseNodule startNodule = curState.selectedObject as BaseNodule;
if (curState.connectionIndex > startNodule.Nodules.Count - 1)
{
InputHandlers.OnSelectConnection(states);
}
else
{
CanvasGUI.DrawConnection(startNodule, startNodule.Nodules.Get(curState.connectionIndex), Color.red);
}
}
Cache.Nodes.OnGUI();
CanvasGUI.EndGroup();
CanvasGUI.BeginGroup(CanvasGUI.OptionRect, GUI.skin.box, states.curSpace == EventSpace.Actor);
switch (tab)
{
case OptionTab.actor:
Cache.Actors.OnGUI();
break;
case OptionTab.condition:
Cache.Conditions.OnGUI();
break;
}
if (CanvasGUI.Button(new Rect(5, 5, 70, 20), "Conditions"))
{
tab = OptionTab.condition;
}
else if (CanvasGUI.Button(new Rect(80, 5, 50, 20), "Actors"))
{
tab = OptionTab.actor;
}
CanvasGUI.EndGroup();
}
public static void EarlyInputEvents(EditorStates states)
{
OverlayMenu.BeginOverlay();
if (!OverlayMenu.HasPopup)
{
CallEventHandler(states, false);
CallHotkeyHandler(states);
}
else if (states.curEvent.type == EventType.Layout)
{
HandleGUILayout(states);
}
}
public static void HandleGUILayout(EditorStates states)
{
ScriptableObject selectedObject = states.curState.selectedObject;
BaseNode selectedNode = (selectedObject is MainNode) ? selectedObject as BaseNode:
(selectedObject is BaseNodule) ? (selectedObject as BaseNodule).MainNode :
(selectedObject is OptionNode) ? (selectedObject as OptionNode).MainNode :
selectedObject as BaseNode;
if (selectedNode || states.Nodes.Contains(selectedNode))
{
states.Nodes.Move(selectedNode, states.Nodes.Count - 1);
}
}
public static void DeleteConnection(EditorStates states)
{
EditorState state = states.curState;
BaseNodule nodule = state.selectedObject as BaseNodule;
if (nodule.Nodules.Count > 0 && state.connectionIndex == -1)
{
state.connectionIndex++;
}
if (state.connectionIndex > -1)
{
nodule.Nodules.RemoveAt(state.connectionIndex);
state.connectionIndex--;
}
}
public static void HandleSelecting(EditorStates states)
{
EditorState state = states.curState;
if (state.focusedObjects[0] != state.selectedObject)
{
state.selectedObject = state.focusedObjects[0];
unfocusControls = states;
if (state.selectedObject != null)
{
Selection.activeObject = state.selectedObject;
}
DialogueEditorGUI.Repaint();
}
}
public static void Makeconnections(EditorStates states, GenericMenu menu)
{
switch (states.curSpace)
{
case EventSpace.Node:
foreach (var noduleTypes in NoduleTypes.noduleTypes)
{
menu.AddMenuItem(new GUIContent("Make Connections/" + noduleTypes.Key.ContextPath), states.curState.makeConnection,
ConnectionCallBack, new EditorStates(noduleTypes.Key.GetClassName, states));
}
break;
case EventSpace.Nodule:
menu.AddMenuItem(new GUIContent("Make Connections"), states.curState.makeConnection, ConnectionCallBack, new EditorStates("nodule", states));
break;
}
}
public static void OnSelectConnection(EditorStates states)
{
EditorState state = states.curState;
switch (states.curSpace)
{
case EventSpace.Nodule:
int count = (state.selectedObject as BaseNodule).Nodules.Count;
state.connectionIndex = (count > 0 && state.connectionIndex < count - 1) ? state.connectionIndex + 1 : (count == 0) ? -1 : 0;
break;
default:
state.connectionIndex = -1;
break;
}
DialogueEditorGUI.Repaint();
}
public static void StartWindowPan(EditorStates states)
{
if (states.curEvent.type == EventType.Used)
{
return;
}
EditorState state = states.curState;
if (states.curEvent.button == 0 && !state.panWindow)
{
state.dragStartPos = states.mousePos;
state.panWindow = true;
}
else if (state.panWindow)
{
EndWindowPan(states);
}
}
public static void StartNodeDrag(EditorStates states)
{
if (states.curEvent.type == EventType.Used)
{
return;
}
EditorState state = states.curState;
if (states.curEvent.button == 0 && !state.dragNode && GUIUtility.hotControl == 0)
{
state.dragStartPos = state.startPos = states.mousePos;
state.dragNode = true;
}
else if (state.dragNode)
{
EndNodeDrag(states);
}
}
public static void OnMakingConnection(EditorStates states)
{
EditorState state = states.curState;
if (state.makeConnection)
{
switch (states.curSpace)
{
case EventSpace.Node:
BaseNode node = state.selectedObject as BaseNode;
state.endNodule = node.Nodules.Find(i => i.GetType() == (state.startNodule is OutputNodule ?
typeof(InputNodule) : typeof(OutputNodule))) ??
BaseNodule.Create(state.startNodule is OutputNodule ? "InputNodule" : "OutputNodule", node);
if (!state.endNodule.MainNode)
{
goto default;
}
if (state.startNodule && state.endNodule)
{
node.Nodules.Add(state.endNodule);
state.startNodule.Nodules.Add(state.endNodule);
}
goto default;
case EventSpace.Nodule:
state.endNodule = state.selectedObject as BaseNodule;
if (state.startNodule && state.endNodule)
{
state.startNodule.Nodules.Add(state.endNodule);
}
goto default;
default:
state.startNodule = null;
state.endNodule = null;
state.makeConnection = false;
break;
}
}
}
public static void HandleEventSpace(EditorStates states)
{
EditorState state = states.curState;
if (CanvasGUI.OptionRect.Contains(states.mousePos))
{
states.curSpace = EventSpace.Actor;
if (!(state.focusedObjects[0] is Actor))
{
state.focusedObjects = new ScriptableObject[] { null }
}
;
}
else if (CanvasGUI.ToolBarRect.Contains(states.mousePos))
{
states.curSpace = EventSpace.Toolbar;
if (state.focusedObjects.Length > 0)
{
state.focusedObjects = new ScriptableObject[] { null }
}
;
}
else if (state.focusedObjects[0] is BaseNodule)
{
states.curSpace = EventSpace.Nodule;
}
else if (state.focusedObjects[0] is BaseNode)
{
states.curSpace = EventSpace.Node;
}
else if (CanvasGUI.CanvasRect.Contains(states.mousePos))
{
states.curSpace = EventSpace.Canvas;
}
else
{
states.curSpace = EventSpace.Everything;
}
}
public static void OnWindowPan(EditorStates states)
{
EditorState state = states.curState;
if (state.panWindow)
{
if (states.mousePos.x < CanvasGUI.CanvasRect.xMin || states.mousePos.x > CanvasGUI.CanvasRect.xMax)
{
states.mousePos.x = state.dragStartPos.x;
}
if (states.mousePos.y < CanvasGUI.CanvasRect.yMin || states.mousePos.y > CanvasGUI.CanvasRect.yMax)
{
states.mousePos.y = state.dragStartPos.y;
}
state.panDelta += states.mousePos - state.dragStartPos;
if (state.panDelta.x > 0)
{
state.panDelta.x = 0;
}
else if ((state.panDelta - CanvasGUI.CanvasRect.size).x < -state.canvasSize.x)
{
state.panDelta.x = (CanvasGUI.CanvasRect.size - state.canvasSize).x;
}
if (state.panDelta.y > 0)
{
state.panDelta.y = 0;
}
else if ((state.panDelta - CanvasGUI.CanvasRect.size).y < -state.canvasSize.y)
{
state.panDelta.y = (CanvasGUI.CanvasRect.size - state.canvasSize).y;
}
state.dragStartPos = states.mousePos;
DialogueEditorGUI.Repaint();
}
}
public static void EndNodeDrag(EditorStates states)
{
EditorState state = states.curState;
if (state.dragNode)
{
if (state.selectedObject is OptionNode && (states.mousePos - state.startPos).magnitude > 10)
{
states.mousePos = CanvasGUI.CanvasToScreenPosition(state, states.mousePos);
foreach (MainNode node in DialogueEditorGUI.Cache.Nodes.OfType <MainNode> ())
{
if (node.Options.OptionAddRect.Contains(states.mousePos))
{
DialogueEditorGUI.Cache.Nodes.Remove(state.selectedObject as OptionNode);
node.Options.Add(state.selectedObject as OptionNode);
break;
}
}
}
state.dragNode = false;
DialogueEditorGUI.Repaint();
}
}
public static void HandleContextMenu(EditorStates states)
{
if (states.curEvent.button == 1)
{
GenericMenu menu = new GenericMenu();
foreach (var filler in contextFillers)
{
if (filler.eSpace == EventSpace.Everything || filler.eSpace == states.curSpace)
{
filler.actionDel.DynamicInvoke(new object[] { states, menu });
}
}
foreach (var entry in contextEntries)
{
if (entry.eSpace == EventSpace.Everything || entry.eSpace == states.curSpace)
{
menu.AddMenuItem(new GUIContent(entry.contextPath), false, entry.menufunc2, states);
}
}
menu.Show(states.mousePos);
}
}
public bool EntrySwitch(EditorStates states)
{
return(false);
}
public static void Refresh(EditorStates states)
{
}
public static void Delete(EditorStates states)
{
}
