public override void OnGUI()
{
if (CanvasGUI.DoubleClick(position, name[0].ToString(), GUI.skin.box))
{
OverlayMenu.UpdateOverlays(this);
}
}
public override void OnGUI()
{
if (CanvasGUI.DoubleClick(position, new GUIContent(name + ": " + Count), GUI.skin.box, tint))
{
OverlayMenu.UpdateOverlays(this);
}
}
void ToolBar()
{
CanvasGUI.BeginGroup(CanvasGUI.ToolBarRect, GUI.skin.box, cache.States.curSpace == EventSpace.Toolbar);
GUI.Label(new Rect(5, 5, CanvasGUI.ToolBarRect.width - 10, 20), new GUIContent(cache.CanvasName + (cache.AutoLoaded ? " (Last Session)" : "")));
if (CanvasGUI.Button(new Rect(5, 30, CanvasGUI.ToolBarRect.width - 10, 20), "Save"))
{
cache = (cache.IsFileSaved && !cache.AutoLoaded) ? EditorCache.SaveCache(cache.SavePath ?? AssetDatabase.GetAssetPath(cache), cache) : SaveCanvas();
}
if (CanvasGUI.Button(new Rect(5, 55, CanvasGUI.ToolBarRect.width - 10, 20), "Save As"))
{
SaveCanvas();
}
if (CanvasGUI.Button(new Rect(5, 80, CanvasGUI.ToolBarRect.width - 10, 20), "Load"))
{
LoadCanvas();
}
if (CanvasGUI.Button(new Rect(5, 105, CanvasGUI.ToolBarRect.width - 10, 20), "New Canvas"))
{
cache = EditorCache.NewCache();
}
if (CanvasGUI.Button(new Rect(5, 130, CanvasGUI.ToolBarRect.width - 10, 20), "Settings"))
{
Setting();
}
CanvasGUI.EndGroup();
}
public override void OnGUI()
{
Event current = Event.current;
Rect tolerance = new Rect(position);
tolerance.xMin -= 20;
tolerance.xMax += 20;
tolerance.yMin -= 20;
tolerance.yMax += 20;
bool hasFocus = tolerance.Contains(current.mousePosition);
CanvasGUI.BeginGroup(position, GUI.skin.box, hasFocus);
string nodeName = obj.name;
if (CanvasGUI.TextField(new Rect(5, 5, 240, 20), ref nodeName))
{
obj.name = DialogueEditorGUI.Cache.Actors.ItemNames[DialogueEditorGUI.Cache.Actors.ItemNames.IndexOf(obj.name)] = nodeName;
}
obj.Tint = UnityEditor.EditorGUI.ColorField(new Rect(5, 30, 140, 20), obj.Tint);
CanvasGUI.EndGroup();
if (current.type == EventType.MouseUp && !hasFocus)
{
close = true;
}
if (!obj || close)
{
UpdateOverlays(obj);
}
}
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 override void OnGUI()
{
for (int i = 1; i < Count; i++)
{
Condition condition = Get(i);
if (CanvasGUI.Button(new Rect(condition.Position.xMax + 2, condition.Position.yMin, 20, 20), "X"))
{
condition.Delete();
i--;
continue;
}
condition.OnGUI();
}
if (CanvasGUI.Button(new Rect(CanvasGUI.OptionRect.width - 25, 5, 20, 20), "+"))
{
GenericMenu menu = new GenericMenu(CanvasGUI.OptionRect);
string[] values = Enum.GetNames(typeof(ConditionalState));
for (int i = 1; i < values.Length; i++)
{
menu.AddMenuItem(new GUIContent(values[i]), false, AddConditionCallback, values[i]);
}
menu.Show(new Vector2(CanvasGUI.OptionRect.width - 5, 25));
}
}
public void OnGUI()
{
CanvasGUI.Position = position;
if (DateTime.Now - lastCheck >= ResourceManager.CheckRate)
{
if (!EditorCache.ValidateCanvas(cache))
{
Debug.LogWarning("Loading last opened session.");
InitCanvas();
cache = EditorCache.LoadCache();
}
else
{
cache.Init();
}
lastCheck = DateTime.Now;
}
InputSystem.EarlyInputEvents(cache.States);
DialogueEditorGUI.OnGUI(cache.States);
ToolBar();
InputSystem.LateInputEvents(cache.States);
cache.States.UpdateEvents();
if (openDebug = CanvasGUI.Toggle(new Rect(5, 5, 130, 20), new GUIContent("Debug Window"), openDebug))
{
DebuggerWindow();
}
}
public override void OnGUI()
{
base.OnGUI();
CanvasGUI.BeginGroup(Position, GUI.skin.box, actor.Tint, HasControl);
if (Locked)
{
GUI.Label(new Rect(5, 5, 240, 20), name);
}
else
{
string nodeName = name;
if (CanvasGUI.TextField(new Rect(5, 5, 240, 20), ref nodeName))
{
name = DialogueEditorGUI.Cache.Nodes.ItemNames[DialogueEditorGUI.Cache.Nodes.ItemNames.IndexOf(name)] = nodeName;
}
}
if (CanvasGUI.Button(new Rect(Position.size.x - 50, 5, 20, 20), new GUIContent("L"), GUI.skin.button))
{
Locked = !Locked;
}
if (CanvasGUI.Button(new Rect(Position.size.x - 25, 5, 20, 20), new GUIContent("X"), GUI.skin.button))
{
Delete();
}
textArea = CanvasGUI.TextArea(new Rect(5, 30, 290, 65), textArea);
CanvasGUI.EndGroup();
}
protected override void Construct()
{
name = "Start Node";
position = new Rect(CanvasGUI.CanvasToScreenPosition(CanvasGUI.CanvasRect.center), ResourceManager.START_NODE_SIZE);
nodules = NoduleDatabase.CreateNew(this);
nodules.Add(BaseNodule.Create <OutputNodule> (this));
DialogueEditorGUI.Cache.SaveNewObject(this, false);
}
public static void InitCanvas()
{
ResourceManager.SetupPaths();
CanvasGUI.SetupGUI();
NodeTypes.FetchAllNodes();
NoduleTypes.FetchAllNodules();
OverlayMenuTypes.FetchAllOverlayMenus();
InputSystem.SetupInputHandlers();
}
public virtual void DrawConnection()
{
foreach (BaseNodule nodule in nodules.OfType <OutputNodule> ())
{
foreach (BaseNodule connectedNodule in nodule.Nodules)
{
CanvasGUI.DrawConnection(nodule, connectedNodule, Color.cyan);
}
}
}
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));
}
public override void OnGUI()
{
CanvasGUI.Box(new Rect(position.position, new Vector2(20, position.height)),
new GUIContent(conditional.ToString()[0].ToString()));
string nodeName = name;
if (CanvasGUI.TextField(new Rect(new Vector2(position.x + 25, position.y), new Vector2(140, 20)), ref nodeName))
{
name = DialogueEditorGUI.Cache.Conditions.ItemNames[DialogueEditorGUI.Cache.Conditions.ItemNames.IndexOf(name)] = nodeName;
}
}
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 void Show(Vector2 menuPosition, float width = 40)
{
if (items.Count <= 0)
{
return;
}
minWidth = width;
CalculateRects(items, CanvasGUI.GUItoWindowPosition(menuPosition));
groupsToDraw = new List <ItemGroup> ()
{
items
};
OnShow();
}
public override void OnGUI()
{
for (int i = 0; i < Count; i++)
{
OptionNode option = Get(i);
option.OnGUI();
if (!mainNode.Locked && CanvasGUI.Button(new Rect(
new Vector2(option.Position.center.x, option.Position.yMin - optionSpacing * 0.5f) - new Vector2(45, 14) * 0.5f,
new Vector2(45, 14)), "Unlink"))
{
Remove(option);
continue;
}
}
}
public override void OnGUI()
{
base.OnGUI();
CanvasGUI.BeginGroup(Position, GUI.skin.box, actor.Tint, HasControl);
if (Locked)
{
GUI.Label(new Rect(5, 5, 240, 20), name);
GUI.Label(new Rect(5, 30, 240, 20), actor.name);
}
else
{
EditorCache cache = DialogueEditorGUI.Cache;
string nodeName = name;
if (CanvasGUI.TextField(new Rect(5, 5, 240, 20), ref nodeName))
{
name = cache.Nodes.ItemNames[cache.Nodes.ItemNames.IndexOf(name)] = nodeName;
}
ActorDatabase actors = cache.Actors;
actor = actors.Get(CanvasGUI.DropDownMenu(new Rect(5, 30, 240, 20),
position, actors.GetIndex(actor), actors.ItemNames.ToArray()));
}
if (CanvasGUI.Button(new Rect(Position.size.x - 50, 5, 20, 20), new GUIContent("L"), GUI.skin.button))
{
Locked = !Locked;
}
if (CanvasGUI.Button(new Rect(Position.size.x - 25, 5, 20, 20), new GUIContent("X"), GUI.skin.button))
{
Delete();
}
textArea = CanvasGUI.TextArea(new Rect(5, 55, 290, 115), textArea);
if (CanvasGUI.Button(new Rect(5, 175, 290, 20), new GUIContent("Add Dialogue Option"), GUI.skin.button))
{
options.Add(OptionNode.Create(options.NextItemName("Option"), this));
}
CanvasGUI.EndGroup();
options.OnGUI();
}
public override void OnGUI()
{
Event current = Event.current;
Rect tolerance = new Rect(position);
tolerance.xMin -= 20;
tolerance.xMax += 20;
tolerance.yMin -= 20;
tolerance.yMax += 20;
bool hasFocus = tolerance.Contains(current.mousePosition);
CanvasGUI.BeginGroup(position, GUI.skin.box, hasFocus);
ConditionDatabase conditions = DialogueEditorGUI.Cache.Conditions;
obj.Condition = conditions.Get(CanvasGUI.DropDownMenu(new Rect(5, 5, position.width - 10, 20), position,
conditions.GetIndex(obj.Condition), conditions.ItemNames.ToArray()));
for (int i = 0; i < obj.ConditionValues.Count; i++)
{
var val = obj.ConditionValues[i];
CanvasGUI.TextLabel(new Rect(30, 30 + 25 * 1, 20, 20), val.userParam.ToString());
string[] names = Enum.GetNames(typeof(EqualityState));
val.equality = (EqualityState)Enum.Parse(typeof(EqualityState),
names[CanvasGUI.DropDownMenu(new Rect(5, 30 + 25, 100, 20), (int)val.equality, names)]);
}
CanvasGUI.EndGroup();
if (current.type == EventType.MouseUp && !hasFocus)
{
close = true;
}
if (!obj || close)
{
UpdateOverlays(obj);
}
}
ValueType DrawParam(Rect rect, ValueType param)
{
ConditionalState conditional = obj.Condition.Conditional;
switch (conditional)
{
case (ConditionalState.Bool):
return(CanvasGUI.DropDownMenu(rect, (int)param, new string[] { "False", "True" }));
case (ConditionalState.Float):
break;
case (ConditionalState.Int):
break;
case (ConditionalState.None):
break;
}
return(null);
}
public override void OnGUI()
{
for (int i = 0; i < Count; i++)
{
Actor actor = Get(i);
if (i > 0 && CanvasGUI.Button(new Rect(actor.Position.xMax + 2, actor.Position.yMin, 20, 20), "X"))
{
actor.Delete();
continue;
}
actor.OnGUI();
}
if (CanvasGUI.Button(new Rect(CanvasGUI.OptionRect.width - 25, 5, 20, 20), "+"))
{
Add(Actor.Create(NextItemName("New Actor"),
new Color(Random.Range(0.000f, 1.000f), Random.Range(0.000f, 1.000f), Random.Range(0.000f, 1.000f)),
new Rect(5, 27 + 22 * (Count), CanvasGUI.OptionRect.width - 34, 20)));
}
}
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 GenericMenu()
{
items = new ItemGroup();
controlID = GUIUtility.GetControlID(items.GetHashCode(), FocusType.Keyboard, new Rect(CanvasGUI.GUItoWindowPosition(items.position.position), items.position.size));
}
protected override void OnGUI()
{
for (int i = 0; i < groupsToDraw.Count; i++)
{
ItemGroup itemGroup = groupsToDraw[i];
Rect tolerance = new Rect(itemGroup.position);
tolerance.xMin -= 20;
tolerance.yMin -= 20;
tolerance.xMax += 20;
tolerance.yMax += 20;
bool hasFocus = tolerance.Contains(Event.current.mousePosition);
CanvasGUI.BeginGroup(itemGroup.position, GUI.skin.box, hasFocus);
foreach (MenuItem item in itemGroup)
{
if (item.content.text.Equals("Saparator"))
{
GUI.Label(item.position, "----------");
}
else if (item.position.Contains(Event.current.mousePosition))
{
if (Event.current.type == EventType.MouseUp && Event.current.button == 0)
{
if (item.Group)
{
groupsToDraw.Add(item.subItems);
}
else
{
item.Execute();
close = true;
}
Event.current.Use();
}
if (item.Group && groupsToDraw.Exists(j => j == item.subItems))
{
item.subItems.forceFocus = true;
}
CanvasGUI.Box(item.position, item.content);
}
else
{
if (item.Group && groupsToDraw.Exists(j => j == item.subItems))
{
item.subItems.forceFocus = false;
}
GUI.Label(item.position, item.content);
}
if (item.Group)
{
GUI.Label(new Rect(item.position.position + new Vector2(item.position.size.x - GroupIconSize, 0),
new Vector2(GroupIconSize, minHeight)), ">");
}
}
CanvasGUI.EndGroup();
if (!hasFocus && !itemGroup.forceFocus)
{
if (i != 0)
{
groupsToDraw.Remove(itemGroup);
}
else if (Event.current.type == EventType.MouseUp)
{
close = true;
}
}
}
if (groupsToDraw.Count == 0 || close)
{
OnClose();
}
DialogueEditorGUI.OnRepaint();
}
static void AddCallBack(object callBackObj)
{
EditorStates states = callBackObj as EditorStates;
if (states == null)
{
throw new UnityException();
}
EditorState state = states.curState;
if (states.info.Contains("Node"))
{
switch (states.curSpace)
{
case EventSpace.Node:
if (states.info == "OptionNode")
{
if (state.selectedObject is MainNode)
{
MainNode main = state.selectedObject as MainNode;
main.Options.Add(OptionNode.Create(main.Options.NextItemName("Option"), main));
}
else
{
goto default;
}
}
else if (states.info == "MainNode")
{
goto default;
}
else
{
Debug.LogError("Cannot recognise name of 'Node'. Add More Error here");
return;
}
break;
default:
EditorCache cache = DialogueEditorGUI.Cache;
cache.Nodes.Add(DialogueNode.Create(states.info,
cache.Nodes.NextItemName(states.info),
CanvasGUI.CanvasToScreenPosition(state, states.mousePos),
cache.Actors.DefaultActor));
break;
}
}
else if (states.info.Contains("Nodule"))
{
BaseNode node = (states.curSpace == EventSpace.Node) ? state.selectedObject as BaseNode :
(states.curSpace == EventSpace.Nodule) ? (state.selectedObject as BaseNodule).MainNode :
null;
if (node)
{
node.Nodules.Add(BaseNodule.Create(states.info, node.Nodules.NextItemName(states.info), node));
}
}
else
{
throw new UnityException();
}
}
public GenericMenu(Rect newBoundingRect)
{
items = new ItemGroup();
controlID = GUIUtility.GetControlID(items.GetHashCode(), FocusType.Keyboard, new Rect(CanvasGUI.GUItoWindowPosition(items.position.position), items.position.size));
if (newBoundingRect != Rect.zero)
{
boundingRect = newBoundingRect;
}
}
public override void OnGUI()
{
base.OnGUI();
CanvasGUI.Box(position, new GUIContent("Start Node"), Color.green);
}
