|
public AddDisabledItem ( |
||
| content | ||
| return | void | |
private void ContextMenu(Model instance)
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent("New"), false, New);
if (instance != null) {
menu.AddItem(new GUIContent("Edit"), false, ShowEditWindow, instance);
} else {
menu.AddDisabledItem(new GUIContent("Edit"));
}
menu.AddSeparator("");
if (instance != null) {
menu.AddItem(new GUIContent("Copy"), false, Copy, instance);
} else {
menu.AddDisabledItem(new GUIContent("Copy"));
}
if (CanPaste()) {
menu.AddItem(new GUIContent("Paste"), false, Paste);
} else {
menu.AddDisabledItem(new GUIContent("Paste"));
}
if (instance != null) {
menu.AddItem(new GUIContent("Delete"), false, Delete, instance);
} else {
menu.AddDisabledItem(new GUIContent("Delete"));
}
menu.ShowAsContext();
}
/// <summary>
/// Shows a context menu to add a new parent.
/// </summary>
void OnContextMenu()
{
var menu = new UnityEditor.GenericMenu();
// Get the active game object
var gameObject = Selection.activeGameObject;
// The selected game object is not null?
if (gameObject != null)
{
// Gets all scripts that inherits from ParentBehaviour class
MonoScript[] scripts = FileUtility.GetScripts <ParentBehaviour>();
for (int i = 0; i < scripts.Length; i++)
{
var type = scripts[i].GetClass();
// Get the component path
string componentPath = "Add Parent/";
AddComponentMenu componentMenu = AttributeUtility.GetAttribute <AddComponentMenu>(type, false);
if (componentMenu == null || componentMenu.componentMenu != string.Empty)
{
componentMenu = AttributeUtility.GetAttribute <AddComponentMenu>(type, true);
if (componentMenu != null && componentMenu.componentMenu != string.Empty)
{
componentPath += componentMenu.componentMenu;
}
else
{
componentPath += type.ToString().Replace('.', '/');
}
// Add to menu
menu.AddItem(new GUIContent(componentPath), false, delegate() { BehaviourWindow.activeParent = StateUtility.AddState(gameObject, type) as ParentBehaviour; });
}
}
}
else
{
menu.AddDisabledItem(new GUIContent("Add Parent/"));
ShowNotification(new GUIContent("Select a Game Object and right click in this window!"));
}
// Add option to paste states
if (Selection.activeGameObject != null && StateUtility.statesToPaste != null && StateUtility.statesToPaste.Length > 0)
{
menu.AddItem(new GUIContent("Paste State"), false, delegate() { StateUtility.CloneStates(Selection.activeGameObject, StateUtility.statesToPaste, null); });
}
else
{
menu.AddDisabledItem(new GUIContent("Paste State"));
}
// Refresh window?
// menu.AddSeparator("");
// menu.AddItem(new GUIContent("Refresh"), false ,Refresh);
// Shows the controller menu
menu.ShowAsContext();
}
protected override void AddDefaultItemsToMenu(GenericMenu menu, EditorWindow view)
{
if (menu.GetItemCount() != 0)
{
menu.AddSeparator(string.Empty);
}
if (base.parent.window.showMode == ShowMode.MainWindow)
{
menu.AddItem(EditorGUIUtility.TextContent("Maximize"), !(base.parent is SplitView), new GenericMenu.MenuFunction2(this.Maximize), view);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Maximize"));
}
menu.AddItem(EditorGUIUtility.TextContent("Close Tab"), false, new GenericMenu.MenuFunction2(this.Close), view);
menu.AddSeparator(string.Empty);
System.Type[] paneTypes = base.GetPaneTypes();
GUIContent content = EditorGUIUtility.TextContent("Add Tab");
foreach (System.Type type in paneTypes)
{
if (type != null)
{
GUIContent content2;
content2 = new GUIContent(EditorWindow.GetLocalizedTitleContentFromType(type)) {
text = content.text + "/" + content2.text
};
menu.AddItem(content2, false, new GenericMenu.MenuFunction2(this.AddTabToHere), type);
}
}
}
//yeah this is very special but....
public static void ShowConfiguredTypeSelectionMenu(Type type, Action <Type> callback, bool showInterfaces = true)
{
GenericMenu.MenuFunction2 Selected = delegate(object t){
callback((Type)t);
};
var menu = new UnityEditor.GenericMenu();
foreach (System.Type t in NCPrefs.GetCommonlyUsedTypes(typeof(object)))
{
if (type.IsAssignableFrom(t) || (t.IsInterface && showInterfaces))
{
var category = "Classes/";
if (t.IsInterface)
{
category = "Interfaces/";
}
if (t.IsEnum)
{
category = "Enumerations/";
}
var nsString = string.IsNullOrEmpty(t.Namespace)? "No Namespace/" : (t.Namespace.Replace(".", "/") + "/");
menu.AddItem(new GUIContent(category + nsString + TypeName(t)), false, Selected, t);
}
}
menu.AddDisabledItem(new GUIContent("Add more in Type Configurator"));
menu.ShowAsContext();
Event.current.Use();
}
void AddMenuItem(GenericMenu mnu, string item, GenericMenu.MenuFunction func, bool enabled=true)
{
if (enabled)
mnu.AddItem(new GUIContent(item), false, func);
else
mnu.AddDisabledItem(new GUIContent(item));
}
public static void CreateVCContextMenu(ref GenericMenu menu, string assetPath, Object instance = null)
{
if (VCUtility.ValidAssetPath(assetPath))
{
bool ready = VCCommands.Instance.Ready;
if (ready)
{
var assetStatus = VCCommands.Instance.GetAssetStatus(assetPath);
if (instance && ObjectUtilities.ChangesStoredInScene(instance)) assetPath = SceneManagerUtilities.GetCurrentScenePath();
var validActions = GetValidActions(assetPath, instance);
if (validActions.showDiff) menu.AddItem(new GUIContent(Terminology.diff), false, () => VCUtility.DiffWithBase(assetPath));
if (validActions.showAdd) menu.AddItem(new GUIContent(Terminology.add), false, () => VCCommands.Instance.Add(new[] { assetPath }));
if (validActions.showOpen) menu.AddItem(new GUIContent(Terminology.getlock), false, () => GetLock(assetPath, instance));
if (validActions.showOpenLocal) menu.AddItem(new GUIContent(Terminology.allowLocalEdit), false, () => AllowLocalEdit(assetPath, instance));
if (validActions.showForceOpen) menu.AddItem(new GUIContent("Force " + Terminology.getlock),false, () => GetLock(assetPath, instance, OperationMode.Force));
if (validActions.showCommit) menu.AddItem(new GUIContent(Terminology.commit), false, () => Commit(assetPath, instance));
if (validActions.showUnlock) menu.AddItem(new GUIContent(Terminology.unlock), false, () => VCCommands.Instance.ReleaseLock(new[] { assetPath }));
if (validActions.showDisconnect)menu.AddItem(new GUIContent("Disconnect"), false, () => PrefabHelper.DisconnectPrefab(instance as GameObject));
if (validActions.showDelete) menu.AddItem(new GUIContent(Terminology.delete), false, () => VCCommands.Instance.Delete(new[] { assetPath }));
if (validActions.showRevert) menu.AddItem(new GUIContent(Terminology.revert), false, () => Revert(assetPath, instance));
}
else
{
menu.AddDisabledItem(new GUIContent("..Busy.."));
}
}
}
public void AddItemsToMenu(GenericMenu menu)
{
menu.AddItem(m_GUIRunOnRecompile, m_Settings.runOnRecompilation, ToggleRunOnRecompilation);
menu.AddItem(m_GUIRunTestsOnNewScene, m_Settings.runTestOnANewScene, m_Settings.ToggleRunTestOnANewScene);
if(!m_Settings.runTestOnANewScene)
menu.AddDisabledItem(m_GUIAutoSaveSceneBeforeRun);
else
menu.AddItem(m_GUIAutoSaveSceneBeforeRun, m_Settings.autoSaveSceneBeforeRun, m_Settings.ToggleAutoSaveSceneBeforeRun);
menu.AddItem(m_GUIShowDetailsBelowTests, m_Settings.horizontalSplit, m_Settings.ToggleHorizontalSplit);
}
protected override void AddDefaultItemsToMenu(GenericMenu menu, EditorWindow view)
{
if (menu.GetItemCount() != 0)
menu.AddSeparator(string.Empty);
menu.AddItem(EditorGUIUtility.TextContent("Maximize"), !(this.parent is SplitView), new GenericMenu.MenuFunction2(this.Unmaximize), (object) view);
menu.AddDisabledItem(EditorGUIUtility.TextContent("Close Tab"));
menu.AddSeparator(string.Empty);
System.Type[] paneTypes = this.GetPaneTypes();
GUIContent guiContent = EditorGUIUtility.TextContent("Add Tab");
foreach (System.Type t in paneTypes)
{
if (t != null)
{
GUIContent content = new GUIContent(EditorWindow.GetLocalizedTitleContentFromType(t));
content.text = guiContent.text + "/" + content.text;
menu.AddDisabledItem(content);
}
}
}
protected override void AddDefaultItemsToMenu(GenericMenu menu, EditorWindow view)
{
if (menu.GetItemCount() != 0)
{
menu.AddSeparator("");
}
menu.AddItem(EditorGUIUtility.TextContent("Maximize"), !(base.parent is SplitView), new GenericMenu.MenuFunction2(this.Unmaximize), view);
menu.AddDisabledItem(EditorGUIUtility.TextContent("Close Tab"));
menu.AddSeparator("");
Type[] paneTypes = base.GetPaneTypes();
GUIContent content = EditorGUIUtility.TextContent("Add Tab");
foreach (Type type in paneTypes)
{
if (type != null)
{
GUIContent content2 = new GUIContent(EditorWindow.GetLocalizedTitleContentFromType(type));
content2.text = content.text + "/" + content2.text;
menu.AddDisabledItem(content2);
}
}
}
internal static void Show(SerializedProperty prop)
{
GUIContent content1 = new GUIContent("Copy");
GUIContent content2 = new GUIContent("Paste");
GenericMenu genericMenu = new GenericMenu();
genericMenu.AddItem(content1, false, new GenericMenu.MenuFunction(new GradientContextMenu(prop).Copy));
if (ParticleSystemClipboard.HasSingleGradient())
genericMenu.AddItem(content2, false, new GenericMenu.MenuFunction(new GradientContextMenu(prop).Paste));
else
genericMenu.AddDisabledItem(content2);
genericMenu.ShowAsContext();
}
public static void DiaplayVCContextMenu(string assetPath, Object instance = null, float xoffset = 0.0f, float yoffset = 0.0f, bool showAssetName = false)
{
var menu = new GenericMenu();
if (showAssetName)
{
menu.AddDisabledItem(new GUIContent(Path.GetFileName(assetPath)));
menu.AddSeparator("");
}
CreateVCContextMenu(ref menu, assetPath, instance);
menu.DropDown(new Rect(Event.current.mousePosition.x + xoffset, Event.current.mousePosition.y + yoffset, 0.0f, 0.0f));
Event.current.Use();
}
protected override void AddDefaultItemsToMenu(GenericMenu menu, EditorWindow view)
{
if (menu.GetItemCount() != 0)
{
menu.AddSeparator(string.Empty);
}
menu.AddItem(EditorGUIUtility.TextContent("DockAreaMaximize"), !(base.parent is SplitView), new GenericMenu.MenuFunction2(this.Unmaximize), view);
menu.AddDisabledItem(EditorGUIUtility.TextContent("DockAreaCloseTab"));
menu.AddSeparator(string.Empty);
Type[] paneTypes = base.GetPaneTypes();
GUIContent gUIContent = EditorGUIUtility.TextContent("DockAreaAddTab");
Type[] array = paneTypes;
for (int i = 0; i < array.Length; i++)
{
Type type = array[i];
if (type != null)
{
GUIContent gUIContent2 = new GUIContent(EditorGUIUtility.TextContent(type.ToString()));
gUIContent2.text = gUIContent.text + "/" + gUIContent2.text;
menu.AddDisabledItem(gUIContent2);
}
}
}
/************************************************************************************************************************/
/// <summary>Adds the details of this state to the menu.</summary>
protected override void AddContextMenuFunctions(UnityEditor.GenericMenu menu)
{
menu.AddDisabledItem(new GUIContent(DetailsPrefix + "Animation Type: " +
Editor.AnimancerEditorUtilities.GetAnimationType(Target._Clip)));
base.AddContextMenuFunctions(menu);
menu.AddItem(new GUIContent("Inverse Kinematics/Apply Animator IK"),
Target.ApplyAnimatorIK,
() => Target.ApplyAnimatorIK = !Target.ApplyAnimatorIK);
menu.AddItem(new GUIContent("Inverse Kinematics/Apply Foot IK"),
Target.ApplyFootIK,
() => Target.ApplyFootIK = !Target.ApplyFootIK);
}
protected virtual void AddColumnVisibilityItems(GenericMenu menu)
{
for (int i = 0; i < this.state.columns.Length; i++)
{
MultiColumnHeaderState.Column column = this.state.columns[i];
if (column.allowToggleVisibility)
{
menu.AddItem(new GUIContent(column.headerText), Enumerable.Contains<int>(this.state.visibleColumns, i), new GenericMenu.MenuFunction2(this.ToggleVisibility), i);
}
else
{
menu.AddDisabledItem(new GUIContent(column.headerText));
}
}
}
public override void OnFlowToolsMenuGUI(string prefix, GenericMenu menu) {
menu.AddSeparator(prefix);
#if WEBPLAYER
menu.AddDisabledItem(new GUIContent("Compile UI..."));
#else
menu.AddItem(new GUIContent(prefix + "Compile UI..."), on: false, func: () => {
Compiler.ShowEditor(null, null);
});
#endif
}
internal static void Show(Rect position, SerializedProperty property, SerializedProperty property2, SerializedProperty scalar, Rect curveRanges, ParticleSystemCurveEditor curveEditor)
{
GUIContent content1 = new GUIContent("Copy");
GUIContent content2 = new GUIContent("Paste");
GenericMenu genericMenu = new GenericMenu();
bool flag1 = property != null && property2 != null;
bool flag2 = flag1 && ParticleSystemClipboard.HasDoubleAnimationCurve() || !flag1 && ParticleSystemClipboard.HasSingleAnimationCurve();
AnimationCurveContextMenu curveContextMenu = new AnimationCurveContextMenu(property, property2, scalar, curveRanges, curveEditor);
genericMenu.AddItem(content1, false, new GenericMenu.MenuFunction(curveContextMenu.Copy));
if (flag2)
genericMenu.AddItem(content2, false, new GenericMenu.MenuFunction(curveContextMenu.Paste));
else
genericMenu.AddDisabledItem(content2);
genericMenu.DropDown(position);
}
private void DrawItemMenu()
{
if (GUILayout.Button("Menu", "MiniPullDown", GUILayout.Width(56))) {
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("New Item"), false, AddNewItem);
if (template.treatItemsAsQuests) {
menu.AddItem(new GUIContent("New Quest"), false, AddNewQuest);
} else {
menu.AddDisabledItem(new GUIContent("New Quest"));
}
menu.AddItem(new GUIContent("Use Quest System"), template.treatItemsAsQuests, ToggleUseQuestSystem);
menu.AddItem(new GUIContent("Sort/By Name"), false, SortItemsByName);
menu.AddItem(new GUIContent("Sort/By ID"), false, SortItemsByID);
menu.AddItem(new GUIContent("Sync From DB"), database.syncInfo.syncItems, ToggleSyncItemsFromDB);
menu.ShowAsContext();
}
}
internal static void Show(Rect activatorRect, List<ExposablePopupMenu.ItemData> buttonData, ExposablePopupMenu caller)
{
ExposablePopupMenu.PopUpMenu.m_Data = buttonData;
ExposablePopupMenu.PopUpMenu.m_Caller = caller;
GenericMenu genericMenu = new GenericMenu();
foreach (ExposablePopupMenu.ItemData current in ExposablePopupMenu.PopUpMenu.m_Data)
{
if (current.m_Enabled)
{
genericMenu.AddItem(current.m_GUIContent, current.m_On, new GenericMenu.MenuFunction2(ExposablePopupMenu.PopUpMenu.SelectionCallback), current);
}
else
{
genericMenu.AddDisabledItem(current.m_GUIContent);
}
}
genericMenu.DropDown(activatorRect);
}
internal static void Show(Rect position, SerializedProperty property, SerializedProperty property2, SerializedProperty scalar, Rect curveRanges, ParticleSystemCurveEditor curveEditor)
{
GUIContent content = new GUIContent("Copy");
GUIContent content2 = new GUIContent("Paste");
GenericMenu menu = new GenericMenu();
bool flag = (property != null) && (property2 != null);
bool flag2 = (flag && ParticleSystemClipboard.HasDoubleAnimationCurve()) || (!flag && ParticleSystemClipboard.HasSingleAnimationCurve());
AnimationCurveContextMenu menu2 = new AnimationCurveContextMenu(property, property2, scalar, curveRanges, curveEditor);
menu.AddItem(content, false, new GenericMenu.MenuFunction(menu2.Copy));
if (flag2)
{
menu.AddItem(content2, false, new GenericMenu.MenuFunction(menu2.Paste));
}
else
{
menu.AddDisabledItem(content2);
}
menu.DropDown(position);
}
public static void Show(Rect buttonRect, string[] classNames, int initialSelectedInstanceID)
{
GenericMenu genericMenu = new GenericMenu();
List<UnityEngine.Object> list = AssetSelectionPopupMenu.FindAssetsOfType(classNames);
if (list.Any<UnityEngine.Object>())
{
list.Sort((UnityEngine.Object result1, UnityEngine.Object result2) => EditorUtility.NaturalCompare(result1.name, result2.name));
foreach (UnityEngine.Object current in list)
{
GUIContent content = new GUIContent(current.name);
bool on = current.GetInstanceID() == initialSelectedInstanceID;
genericMenu.AddItem(content, on, new GenericMenu.MenuFunction2(AssetSelectionPopupMenu.SelectCallback), current);
}
}
else
{
genericMenu.AddDisabledItem(new GUIContent("No Audio Mixers found in this project"));
}
genericMenu.DropDown(buttonRect);
}
public static void Show(Rect buttonRect, string[] classNames, int initialSelectedInstanceID)
{
GenericMenu genericMenu = new GenericMenu();
List<UnityEngine.Object> assetsOfType = AssetSelectionPopupMenu.FindAssetsOfType(classNames);
if (assetsOfType.Any<UnityEngine.Object>())
{
assetsOfType.Sort((Comparison<UnityEngine.Object>) ((result1, result2) => EditorUtility.NaturalCompare(result1.name, result2.name)));
using (List<UnityEngine.Object>.Enumerator enumerator = assetsOfType.GetEnumerator())
{
while (enumerator.MoveNext())
{
UnityEngine.Object current = enumerator.Current;
GUIContent content = new GUIContent(current.name);
bool on = current.GetInstanceID() == initialSelectedInstanceID;
genericMenu.AddItem(content, on, new GenericMenu.MenuFunction2(AssetSelectionPopupMenu.SelectCallback), (object) current);
}
}
}
else
genericMenu.AddDisabledItem(new GUIContent("No Audio Mixers found in this project"));
genericMenu.DropDown(buttonRect);
}
/// <summary>
/// Show the node menu.
/// <param name="node">The target node.</param>
/// </summary>
void NodeContextMenu(ActionNode node)
{
// Validate Paramenters
if (node == null)
{
return;
}
// Create the menu
var menu = new UnityEditor.GenericMenu();
// Copy/Cut/Paste/Duplicate
menu.AddItem(new GUIContent("Copy"), false, delegate() { BehaviourTreeUtility.nodeToPaste = node; });
menu.AddItem(new GUIContent("Cut"), false, delegate() { BehaviourTreeUtility.nodeToPaste = node; OnDestroyNode(node); });
ActionNode[] nodesToPaste = ActionStateUtility.GetActionsAndConditions(BehaviourTreeUtility.nodeToPaste != null ? new ActionNode[] { BehaviourTreeUtility.nodeToPaste } : new ActionNode[0]);
if (nodesToPaste.Length > 0)
{
menu.AddItem(new GUIContent("Paste"), false, delegate() { ActionStateUtility.PasteNodes(m_ActionState, nodesToPaste); });
}
else
{
menu.AddDisabledItem(new GUIContent("Paste"));
}
menu.AddItem(new GUIContent("Duplicate"), false, delegate() { ActionStateUtility.PasteNodes(m_ActionState, new ActionNode[] { node }); });
// Separator
menu.AddSeparator("");
// Delete
menu.AddItem(new GUIContent("Delete"), false, delegate() { this.OnDestroyNode(node); });
// Show the context menu
menu.ShowAsContext();
}
//This is called outside Begin/End Windows from GraphEditor.
void ShowToolbar(Event e)
{
var owner = this.agent != null && agent is GraphOwner && (agent as GraphOwner).graph == this? (GraphOwner)agent : null;
GUILayout.BeginHorizontal(EditorStyles.toolbar);
GUI.backgroundColor = new Color(1f,1f,1f,0.5f);
///FILE
if (GUILayout.Button("File", EditorStyles.toolbarDropDown, GUILayout.Width(50))){
var menu = new GenericMenu();
#if !UNITY_WEBPLAYER
//Import JSON
menu.AddItem (new GUIContent ("Import JSON"), false, ()=>
{
if (allNodes.Count > 0 && !EditorUtility.DisplayDialog("Import Graph", "All current graph information will be lost. Are you sure?", "YES", "NO"))
return;
var path = EditorUtility.OpenFilePanel( string.Format("Import '{0}' Graph", this.GetType().Name), "Assets", exportFileExtension);
if (!string.IsNullOrEmpty(path)){
if ( this.Deserialize( System.IO.File.ReadAllText(path), true, null ) == null){ //true: validate, null: this._objectReferences
EditorUtility.DisplayDialog("Import Failure", "Please read the logs for more information", "OK", "");
}
}
});
//Expot JSON
menu.AddItem (new GUIContent ("Export JSON"), false, ()=>
{
var path = EditorUtility.SaveFilePanelInProject (string.Format("Export '{0}' Graph", this.GetType().Name), "", exportFileExtension, "");
if (!string.IsNullOrEmpty(path)){
System.IO.File.WriteAllText( path, this.Serialize(true, null) ); //true: pretyJson, null: this._objectReferences
AssetDatabase.Refresh();
}
});
#else
menu.AddDisabledItem(new GUIContent("Import JSON (not possible with webplayer active platform)"));
menu.AddDisabledItem(new GUIContent("Export JSON (not possible with webplayer active platform)"));
#endif
menu.ShowAsContext();
}
///EDIT
if (GUILayout.Button("Edit", EditorStyles.toolbarDropDown, GUILayout.Width(50))){
var menu = new GenericMenu();
//Bind
if (!Application.isPlaying && owner != null && !owner.graphIsLocal){
menu.AddItem(new GUIContent("Bind To Owner"), false, ()=>
{
if (EditorUtility.DisplayDialog("Bind To Owner", "This will create a local copy of the graph binded to the owner.\nIt will allow you to assign direct scene references in the graph.\nContinue?", "YES", "NO")){
var newGraph = (Graph)EditorUtils.AddScriptableComponent(owner.gameObject, owner.graphType);
newGraph.hideFlags = HideFlags.HideInInspector;
EditorUtility.CopySerialized(owner.graph, newGraph);
newGraph.Validate();
Undo.RegisterCreatedObjectUndo(newGraph, "New Local Graph");
Undo.RecordObject(owner, "New Local Graph");
owner.graph = newGraph;
EditorUtility.SetDirty(owner);
EditorUtility.SetDirty(newGraph);
}
});
}
else menu.AddDisabledItem(new GUIContent("Bind To Owner"));
//Save to asset
if (owner != null && owner.graphIsLocal){
menu.AddItem(new GUIContent("Save To Asset"), false, ()=>
{
var newGraph = (Graph)EditorUtils.CreateAsset(this.GetType(), true);
if (newGraph != null){
EditorUtility.CopySerialized(this, newGraph);
newGraph.Validate();
AssetDatabase.SaveAssets();
}
});
}
else menu.AddDisabledItem(new GUIContent("Save To Asset"));
//Create defined vars
if (blackboard != null){
menu.AddItem(new GUIContent("Create Defined Blackboard Variables"), false, ()=>
{
if (EditorUtility.DisplayDialog("Create Defined Variables", "This will fill the current Blackboard for each defined variable parameter in the graph.\nContinue?", "YES", "NO"))
CreateDefinedParameterVariables(blackboard);
});
}
else menu.AddDisabledItem(new GUIContent("Create Defined Blackboard Variables"));
menu.ShowAsContext();
}
//////
///PREFS
if (GUILayout.Button("Prefs", EditorStyles.toolbarDropDown, GUILayout.Width(50))){
var menu = new GenericMenu();
menu.AddItem (new GUIContent ("Icon Mode"), NCPrefs.iconMode, ()=> {NCPrefs.iconMode = !NCPrefs.iconMode;});
menu.AddItem (new GUIContent ("Show Node Help"), NCPrefs.showNodeInfo, ()=> {NCPrefs.showNodeInfo = !NCPrefs.showNodeInfo;});
menu.AddItem (new GUIContent ("Show Comments"), NCPrefs.showComments, ()=> {NCPrefs.showComments = !NCPrefs.showComments;});
menu.AddItem (new GUIContent ("Show Summary Info"), NCPrefs.showTaskSummary, ()=> {NCPrefs.showTaskSummary = !NCPrefs.showTaskSummary;});
menu.AddItem (new GUIContent ("Log Events"), NCPrefs.logEvents, ()=>{ NCPrefs.logEvents = !NCPrefs.logEvents; });
menu.AddItem (new GUIContent ("Grid Snap"), NCPrefs.doSnap, ()=> {NCPrefs.doSnap = !NCPrefs.doSnap;});
if (autoSort){
menu.AddItem (new GUIContent ("Automatic Hierarchical Move"), NCPrefs.hierarchicalMove, ()=> {NCPrefs.hierarchicalMove = !NCPrefs.hierarchicalMove;});
}
menu.AddItem (new GUIContent ("Connection Mode/Curved"), NCPrefs.curveMode == 0, ()=> {NCPrefs.curveMode = 0;});
menu.AddItem (new GUIContent ("Connection Mode/Stepped"), NCPrefs.curveMode == 1, ()=> {NCPrefs.curveMode = 1;});
menu.AddItem (new GUIContent ("Connection Mode/Straight"), NCPrefs.curveMode == 2, ()=> {NCPrefs.curveMode = 2;});
//menu.AddItem (new GUIContent ("Use External Inspector"), NCPrefs.useExternalInspector, ()=> {NCPrefs.useExternalInspector = !NCPrefs.useExternalInspector;});
menu.AddItem( new GUIContent("Preferred Types Editor..."), false, ()=>{PreferedTypesEditorWindow.ShowWindow();} );
menu.ShowAsContext();
}
/////////
GUILayout.Space(10);
////CLICK SELECT
if (agent != null && GUILayout.Button("Select Owner", EditorStyles.toolbarButton, GUILayout.Width(80))){
Selection.activeObject = agent;
EditorGUIUtility.PingObject(agent);
}
if (EditorUtility.IsPersistent(this) && GUILayout.Button("Select Graph", EditorStyles.toolbarButton, GUILayout.Width(80))){
Selection.activeObject = this;
EditorGUIUtility.PingObject(this);
}
////////////////
GUILayout.Space(10);
GUILayout.FlexibleSpace();
//DROPDOWN GRAPHOWNER JUMP SELECTION
if (owner != null && !NCPrefs.isLocked){
if (GUILayout.Button(string.Format("[{0}]", owner.gameObject.name), EditorStyles.toolbarDropDown, GUILayout.Width(120))){
var menu = new GenericMenu();
foreach(var _o in FindObjectsOfType<GraphOwner>()){
var o = _o;
menu.AddItem (new GUIContent(o.GetType().Name + "s/" + o.gameObject.name), false, ()=> { Selection.activeObject = o; Selection.selectionChanged(); });
}
menu.ShowAsContext();
}
}
////////////////////////////////////
NCPrefs.isLocked = GUILayout.Toggle(NCPrefs.isLocked, "Lock", EditorStyles.toolbarButton);
GUILayout.Space(2);
GUI.backgroundColor = new Color(1, 0.8f, 0.8f, 1);
if (GUILayout.Button("Clear", EditorStyles.toolbarButton, GUILayout.Width(50))){
if (EditorUtility.DisplayDialog("Clear Canvas", "This will delete all nodes of the currently viewing graph!\nAre you sure?", "YES", "NO!")){
ClearGraph();
e.Use();
return;
}
}
GUILayout.EndHorizontal();
GUI.backgroundColor = Color.white;
}
public void AddItemsToMenu(GenericMenu menu)
{
if (!string.IsNullOrEmpty(textEditor.targetPath))
{
var fileName = System.IO.Path.GetFileName(textEditor.targetPath);
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2
fileName = fileName.Replace('_', '\xFF3F');
#endif
menu.AddItem(new GUIContent("Ping " + fileName), false, () => {
EditorApplication.ExecuteMenuItem("Window/Project");
EditorGUIUtility.PingObject(targetAsset);
});
#if UNITY_EDITOR_OSX
menu.AddItem(new GUIContent("Reveal in Finder"), false, () => {
Selection.activeObject = targetAsset;
EditorApplication.ExecuteMenuItem("Assets/Reveal in Finder");
});
#else
menu.AddItem(new GUIContent("Show in Explorer"), false, () => {
Selection.activeObject = targetAsset;
EditorApplication.ExecuteMenuItem("Assets/Show in Explorer");
});
#endif
menu.AddSeparator("");
var isMaximized = IsMaximized();
menu.AddItem("Maximize", "&\n", "Maximize", "&enter", isMaximized, () => ToggleMaximized(this));
if (isMaximized)
{
menu.AddDisabledItem(new GUIContent("Close Tab"));
menu.AddDisabledItem(new GUIContent("Close All SI Tabs"));
menu.AddItem("Close Other SI Tabs", "#%w", "Close Other SI Tabs", "#%w", false, null);
}
else
{
menu.AddItem("Close Tab", "#%w", "Close Tab", "%w", false, () => {
Close();
});
menu.AddItem(new GUIContent("Close All SI Tabs"), false, () => {
var allWindows = new FGCodeWindow[codeWindows.Count];
codeWindows.CopyTo(allWindows);
foreach (var window in allWindows)
if (window)
window.Close();
});
menu.AddItem("Close Other SI Tabs", "", "Close Other SI Tabs", "#%w", false, CloseOtherTabs);
}
menu.ShowAsContext();
GUIUtility.ExitGUI();
}
}
/// <summary>
/// Shows a context menu to add a new parent.
/// </summary>
void OnContextMenu () {
var menu = new UnityEditor.GenericMenu();
// Get the active game object
var gameObject = Selection.activeGameObject;
// The selected game object is not null?
if (gameObject != null) {
// Gets all scripts that inherits from ParentBehaviour class
MonoScript[] scripts = FileUtility.GetScripts<ParentBehaviour>();
for (int i = 0; i < scripts.Length; i++) {
var type = scripts[i].GetClass();
// Get the component path
string componentPath = "Add Parent/";
AddComponentMenu componentMenu = AttributeUtility.GetAttribute<AddComponentMenu>(type, false);
if (componentMenu == null || componentMenu.componentMenu != string.Empty) {
componentMenu = AttributeUtility.GetAttribute<AddComponentMenu>(type, true);
if (componentMenu != null && componentMenu.componentMenu != string.Empty)
componentPath += componentMenu.componentMenu;
else
componentPath += type.ToString().Replace('.','/');
// Add to menu
menu.AddItem(new GUIContent(componentPath), false, delegate () {BehaviourWindow.activeParent = StateUtility.AddState(gameObject, type) as ParentBehaviour;});
}
}
}
else {
menu.AddDisabledItem(new GUIContent("Add Parent/"));
ShowNotification(new GUIContent("Select a Game Object and right click in this window!"));
}
// Add option to paste states
if (Selection.activeGameObject != null && StateUtility.statesToPaste != null && StateUtility.statesToPaste.Length > 0)
menu.AddItem(new GUIContent("Paste State"), false, delegate () {StateUtility.CloneStates(Selection.activeGameObject, StateUtility.statesToPaste, null);});
else
menu.AddDisabledItem(new GUIContent("Paste State"));
// Refresh window?
// menu.AddSeparator("");
// menu.AddItem(new GUIContent("Refresh"), false ,Refresh);
// Shows the controller menu
menu.ShowAsContext();
}
static void SetupMinMaxCurve(SerializedProperty property, GenericMenu menu, Event evt)
{
var canCopy = !property.hasMultipleDifferentValues;
var canPasteWhole = GUI.enabled && Clipboard.HasSerializedProperty();
if (menu != null)
{
AddSeparator(menu);
var copyContent = overrideCopyContent ?? kCopyContent;
if (canCopy)
{
menu.AddItem(copyContent, false, o => Clipboard.SetSerializedProperty((SerializedProperty)o), property);
}
else
{
menu.AddDisabledItem(copyContent);
}
var pasteContent = overridePasteContent ?? kPasteContent;
if (canPasteWhole)
{
menu.AddItem(pasteContent, false,
delegate(object o)
{
var prop = (SerializedProperty)o;
Clipboard.GetSerializedProperty(prop);
prop.serializedObject.ApplyModifiedProperties();
}, property);
}
else if (GUI.enabled && Clipboard.hasFloat)
{
MinMaxCurveState state = (MinMaxCurveState)property.FindPropertyRelative("minMaxState").intValue;
if (state == MinMaxCurveState.k_Scalar)
{
AddPasteFloatItem(property.FindPropertyRelative("scalar"), menu, pasteContent);
}
else if (state == MinMaxCurveState.k_TwoScalars)
{
// Allow the user to choose whether to paste the float on their clipboard to either the min or max
AddPasteFloatItem(property.FindPropertyRelative("minScalar"), menu, kPasteMinScalarContent);
AddPasteFloatItem(property.FindPropertyRelative("scalar"), menu, kPasteMaxScalarContent);
}
else
{
menu.AddDisabledItem(pasteContent);
}
}
else if (GUI.enabled && Clipboard.hasAnimationCurve)
{
MinMaxCurveState state = (MinMaxCurveState)property.FindPropertyRelative("minMaxState").intValue;
if (state == MinMaxCurveState.k_Curve)
{
AddPasteCurveItem(property.FindPropertyRelative("maxCurve"), menu, pasteContent);
}
else if (state == MinMaxCurveState.k_TwoCurves)
{
// Allow the user to choose whether to paste the color on their clipboard to either the max or min
AddPasteCurveItem(property.FindPropertyRelative("maxCurve"), menu, kPasteMaxCurveContent);
AddPasteCurveItem(property.FindPropertyRelative("minCurve"), menu, kPasteMinCurveContent);
}
else
{
menu.AddDisabledItem(pasteContent);
}
}
else
{
menu.AddDisabledItem(pasteContent);
}
}
if (evt != null)
{
if (canCopy && evt.commandName == EventCommandNames.Copy)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
Clipboard.SetSerializedProperty(property);
evt.Use();
}
}
if (canPasteWhole && evt.commandName == EventCommandNames.Paste)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
Clipboard.GetSerializedProperty(property);
property.serializedObject.ApplyModifiedProperties();
evt.Use();
}
}
}
}
protected override GenericMenu OnContextMenu(GenericMenu menu)
{
if (allowAsPrime){
if (Application.isPlaying){
menu.AddItem (new GUIContent ("Enter State"), false, delegate{FSM.EnterState(this);});
} else {
menu.AddDisabledItem(new GUIContent ("Enter State"));
}
}
return menu;
}
private void CreateFileMenu(Rect position)
{
GenericMenu fileMenu = new GenericMenu();
fileMenu.AddItem(new GUIContent("Overwrite Input Settings"), false, HandleFileMenuOption, FileMenuOptions.OverriteInputSettings);
if(EditorToolbox.HasInputAdapterAddon())
fileMenu.AddItem(new GUIContent("Configure For Input Adapter"), false, HandleFileMenuOption, FileMenuOptions.ConfigureForInputAdapter);
fileMenu.AddSeparator("");
if(_inputManager.inputConfigurations.Count > 0)
fileMenu.AddItem(new GUIContent("Create Snapshot"), false, HandleFileMenuOption, FileMenuOptions.CreateSnapshot);
else
fileMenu.AddDisabledItem(new GUIContent("Create Snapshot"));
if(EditorToolbox.CanLoadSnapshot())
fileMenu.AddItem(new GUIContent("Load Snapshot"), false, HandleFileMenuOption, FileMenuOptions.LoadSnapshot);
else
fileMenu.AddDisabledItem(new GUIContent("Load Snapshot"));
fileMenu.AddSeparator("");
if(_inputManager.inputConfigurations.Count > 0)
fileMenu.AddItem(new GUIContent("Export"), false, HandleFileMenuOption, FileMenuOptions.Export);
else
fileMenu.AddDisabledItem(new GUIContent("Export"));
fileMenu.AddItem(new GUIContent("Import"), false, HandleFileMenuOption, FileMenuOptions.Import);
if(EditorToolbox.HasJoystickMappingAddon())
fileMenu.AddItem(new GUIContent("Import Joystick Mapping"), false, HandleFileMenuOption, FileMenuOptions.ImportJoystickMapping);
fileMenu.DropDown(position);
}
void MixedLightingGUI()
{
if (!SupportedRenderingFeatures.IsLightmapBakeTypeSupported(LightmapBakeType.Baked))
{
return;
}
m_ShowMixedLightsSettings = EditorGUILayout.FoldoutTitlebar(m_ShowMixedLightsSettings, Styles.MixedLightsLabel, true);
if (m_ShowMixedLightsSettings)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_EnabledBakedGI, Styles.EnableBaked);
if (!m_EnabledBakedGI.boolValue)
{
EditorGUILayout.HelpBox(Styles.BakedGIDisabledInfo.text, MessageType.Info);
}
using (new EditorGUI.DisabledScope(!m_EnabledBakedGI.boolValue))
{
bool mixedGISupported = SupportedRenderingFeatures.IsLightmapBakeTypeSupported(LightmapBakeType.Mixed);
using (new EditorGUI.DisabledScope(!mixedGISupported))
{
var rect = EditorGUILayout.GetControlRect();
EditorGUI.BeginProperty(rect, Styles.MixedLightMode, m_MixedBakeMode);
rect = EditorGUI.PrefixLabel(rect, Styles.MixedLightMode);
int index = Math.Max(0, Array.IndexOf(Styles.MixedModeValues, m_MixedBakeMode.intValue));
if (EditorGUI.DropdownButton(rect, Styles.MixedModeStrings[index], FocusType.Passive))
{
var menu = new GenericMenu();
for (int i = 0; i < Styles.MixedModeValues.Length; i++)
{
int value = Styles.MixedModeValues[i];
bool selected = (value == m_MixedBakeMode.intValue);
if (!SupportedRenderingFeatures.IsMixedLightingModeSupported((MixedLightingMode)value))
{
menu.AddDisabledItem(Styles.MixedModeStrings[i], selected);
}
else
{
menu.AddItem(Styles.MixedModeStrings[i], selected, OnMixedModeSelected, value);
}
}
menu.DropDown(rect);
}
EditorGUI.EndProperty();
if (mixedGISupported)
{
if (!SupportedRenderingFeatures.IsMixedLightingModeSupported((MixedLightingMode)m_MixedBakeMode.intValue))
{
string fallbackMode = Styles.MixedModeStrings[(int)SupportedRenderingFeatures.FallbackMixedLightingMode()].text;
EditorGUILayout.HelpBox(Styles.MixedModeNotSupportedWarning.text + fallbackMode, MessageType.Warning);
}
else if (m_EnabledBakedGI.boolValue)
{
EditorGUILayout.HelpBox(Styles.HelpStringsMixed[m_MixedBakeMode.intValue].text, MessageType.Info);
}
}
if (m_MixedBakeMode.intValue == (int)MixedLightingMode.Subtractive)
{
EditorGUILayout.PropertyField(m_SubtractiveShadowColor, Styles.SubtractiveShadowColor);
m_RenderSettingsSO.ApplyModifiedProperties();
EditorGUILayout.Space();
}
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
}
/// <summary>
/// Invoked to generate context menu for list item.
/// </summary>
/// <param name="menu">Menu which can be populated.</param>
/// <param name="itemIndex">Zero-based index of item which was right-clicked.</param>
/// <param name="adaptor">Reorderable list adaptor.</param>
protected virtual void AddItemsToMenu(GenericMenu menu, int itemIndex, IReorderableListAdaptor adaptor) {
if ((Flags & ReorderableListFlags.DisableReordering) == 0) {
if (itemIndex > 0)
menu.AddItem(CommandMoveToTop, false, DefaultContextHandler, CommandMoveToTop);
else
menu.AddDisabledItem(CommandMoveToTop);
if (itemIndex + 1 < adaptor.Count)
menu.AddItem(CommandMoveToBottom, false, DefaultContextHandler, CommandMoveToBottom);
else
menu.AddDisabledItem(CommandMoveToBottom);
if (HasAddButton) {
menu.AddSeparator("");
menu.AddItem(CommandInsertAbove, false, DefaultContextHandler, CommandInsertAbove);
menu.AddItem(CommandInsertBelow, false, DefaultContextHandler, CommandInsertBelow);
if ((Flags & ReorderableListFlags.DisableDuplicateCommand) == 0)
menu.AddItem(CommandDuplicate, false, DefaultContextHandler, CommandDuplicate);
}
}
if (HasRemoveButtons) {
if (menu.GetItemCount() > 0)
menu.AddSeparator("");
menu.AddItem(CommandRemove, false, DefaultContextHandler, CommandRemove);
menu.AddSeparator("");
menu.AddItem(CommandClearAll, false, DefaultContextHandler, CommandClearAll);
}
}
public void AddTangentMenuItems(GenericMenu menu, List <KeyIdentifier> keyList)
{
bool anyKeys = (keyList.Count > 0);
// Find out which qualities apply to all the keys
bool allClampedAuto = anyKeys;
bool allAuto = anyKeys;
bool allFreeSmooth = anyKeys;
bool allFlat = anyKeys;
bool allBroken = anyKeys;
bool allLeftWeighted = anyKeys;
bool allLeftFree = anyKeys;
bool allLeftLinear = anyKeys;
bool allLeftConstant = anyKeys;
bool allRightWeighted = anyKeys;
bool allRightFree = anyKeys;
bool allRightLinear = anyKeys;
bool allRightConstant = anyKeys;
foreach (KeyIdentifier sel in keyList)
{
Keyframe key = sel.keyframe;
TangentMode leftMode = AnimationUtility.GetKeyLeftTangentMode(key);
TangentMode rightMode = AnimationUtility.GetKeyRightTangentMode(key);
bool broken = AnimationUtility.GetKeyBroken(key);
if (leftMode != TangentMode.ClampedAuto || rightMode != TangentMode.ClampedAuto)
{
allClampedAuto = false;
}
if (leftMode != TangentMode.Auto || rightMode != TangentMode.Auto)
{
allAuto = false;
}
if (broken || leftMode != TangentMode.Free || rightMode != TangentMode.Free)
{
allFreeSmooth = false;
}
if (broken || leftMode != TangentMode.Free || key.inTangent != 0 || rightMode != TangentMode.Free || key.outTangent != 0)
{
allFlat = false;
}
if (!broken)
{
allBroken = false;
}
if (!broken || leftMode != TangentMode.Free)
{
allLeftFree = false;
}
if (!broken || leftMode != TangentMode.Linear)
{
allLeftLinear = false;
}
if (!broken || leftMode != TangentMode.Constant)
{
allLeftConstant = false;
}
if (!broken || rightMode != TangentMode.Free)
{
allRightFree = false;
}
if (!broken || rightMode != TangentMode.Linear)
{
allRightLinear = false;
}
if (!broken || rightMode != TangentMode.Constant)
{
allRightConstant = false;
}
if ((key.weightedMode & WeightedMode.In) == WeightedMode.None)
{
allLeftWeighted = false;
}
if ((key.weightedMode & WeightedMode.Out) == WeightedMode.None)
{
allRightWeighted = false;
}
}
if (anyKeys)
{
menu.AddItem(EditorGUIUtility.TrTextContent("Clamped Auto"), allClampedAuto, SetClampedAuto, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Auto"), allAuto, SetAuto, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Free Smooth"), allFreeSmooth, SetEditable, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Flat"), allFlat, SetFlat, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Broken"), allBroken, SetBroken, keyList);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Free"), allLeftFree, SetLeftEditable, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Linear"), allLeftLinear, SetLeftLinear, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Constant"), allLeftConstant, SetLeftConstant, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Left Tangent/Weighted"), allLeftWeighted, ToggleLeftWeighted, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Free"), allRightFree, SetRightEditable, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Linear"), allRightLinear, SetRightLinear, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Constant"), allRightConstant, SetRightConstant, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Right Tangent/Weighted"), allRightWeighted, ToggleRightWeighted, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Free"), allRightFree && allLeftFree, SetBothEditable, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Linear"), allRightLinear && allLeftLinear, SetBothLinear, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Constant"), allRightConstant && allLeftConstant, SetBothConstant, keyList);
menu.AddItem(EditorGUIUtility.TrTextContent("Both Tangents/Weighted"), allRightWeighted && allLeftWeighted, ToggleBothWeighted, keyList);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Weighted"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Auto"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Free Smooth"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Flat"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Broken"));
menu.AddSeparator("");
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Left Tangent/Weighted"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Right Tangent/Weighted"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Free"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Both Tangents/Weighted"));
}
}
protected override void ContextClickedItem(int id)
{
UnityEditor.GenericMenu menu = new UnityEditor.GenericMenu();
var item = Find(id);
if (CheckWaapi())
{
if (CanPlay(item))
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Play \u2215 Stop _SPACE"), false,
() => AkWaapiUtilities.TogglePlayEvent(item.objectType, item.objectGuid));
}
else
{
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Play \u2215 Stop _Space"));
}
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Stop All"), false,
() => AkWaapiUtilities.StopAllTransports());
menu.AddSeparator("");
if (CanRenameWithLog(item, false))
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Rename _F2"), false,
() => BeginRename(item));
}
else
{
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Rename"));
}
if (CanDelete(item, false))
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Delete _Delete"), false,
() => AkWaapiUtilities.Delete(item.objectGuid));
}
else
{
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Delete"));
}
menu.AddSeparator("");
if (item.objectType == WwiseObjectType.Soundbank)
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Open Folder/WorkUnit #O"), false,
() => AkWaapiUtilities.OpenWorkUnitInExplorer(item.objectGuid));
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Open Folder/SoundBank "), false,
() => AkWaapiUtilities.OpenSoundBankInExplorer(item.objectGuid));
}
else
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Open Containing Folder #O"), false,
() => AkWaapiUtilities.OpenWorkUnitInExplorer(item.objectGuid));
}
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Find in Project Explorer #F"), false,
() => m_dataSource.SelectObjectInAuthoring(item.objectGuid));
}
else
{
if (AkWwiseProjectInfo.GetData().currentDataSource == AkWwiseProjectInfo.DataSourceType.WwiseAuthoring)
{
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Wwise Connection Settings"), false,
OpenSettings);
menu.AddSeparator("");
}
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Play \u2215 Stop"));
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Stop all"));
menu.AddSeparator("");
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Rename"));
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Delete"));
menu.AddSeparator("");
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Open Containing Folder"));
menu.AddDisabledItem(UnityEditor.EditorGUIUtility.TrTextContent("Find in Project Explorer"));
}
menu.AddItem(UnityEditor.EditorGUIUtility.TrTextContent("Find References in Scene #R"), false,
() => FindReferencesInScene(item));
menu.ShowAsContext();
}
/// <summary>
/// Shows the context menu.
/// </summary>
protected virtual void OnContextMenu()
{
// Create the menu
var menu = new UnityEditor.GenericMenu();
if (m_State != null)
{
// Set as start state
if (m_State.fsm != null && !(m_State is InternalAnyState))
{
menu.AddItem(new GUIContent("Set as Start"), false, delegate() { StateUtility.SetAsStart(m_State); this.Refresh(); });
}
else
{
menu.AddDisabledItem(new GUIContent("Set as Start"));
}
// Set as concurrent state
if (m_State.fsm != null && !(m_State is InternalAnyState))
{
if (m_IsConcurrent)
{
menu.AddItem(new GUIContent("Set as Not Concurrent"), false, delegate() { StateUtility.RemoveConcurrentState(m_State.fsm); this.Refresh(); });
}
else
{
menu.AddItem(new GUIContent("Set as Concurrent"), false, delegate() { StateUtility.SetAsConcurrent(m_State); this.Refresh(); });
}
}
else
{
menu.AddDisabledItem(new GUIContent("Set as Concurrent"));
}
// Set as enabled
if (m_State.fsm != null /*&& m_State.fsm.enabled*/ && Application.isPlaying && !(m_State is InternalAnyState))
{
menu.AddItem(new GUIContent("Set as Enabled"), false, delegate() { m_State.enabled = true; });
}
else
{
menu.AddDisabledItem(new GUIContent("Set as Enabled"));
}
// Add Transitions
// Add none
menu.AddItem(new GUIContent("Add Transition/None"), false, delegate() { StateUtility.AddTransition(m_State, 0); CreateTransitionGUIs(); });
// Add blackboard events
var blackboard = m_State.blackboard;
if (blackboard != null)
{
foreach (var fsmEvent in blackboard.fsmEvents)
{
int eventId = fsmEvent.id;
menu.AddItem(new GUIContent("Add Transition/" + fsmEvent.name), false, delegate() { StateUtility.AddTransition(m_State, eventId); CreateTransitionGUIs(); });
}
}
// Add GlobalBlackboard events
// This is not The GlobalBlackboard?
if (InternalGlobalBlackboard.Instance != null && blackboard != InternalGlobalBlackboard.Instance)
{
foreach (var globalEvent in InternalGlobalBlackboard.Instance.fsmEvents)
{
int eventId = globalEvent.id;
var eventName = globalEvent.isSystem ? "Add Transition/System/" + globalEvent.name : "Add Transition/Global/" + globalEvent.name;
menu.AddItem(new GUIContent(eventName), false, delegate() { StateUtility.AddTransition(m_State, eventId); CreateTransitionGUIs(); });
}
}
// Separator
menu.AddSeparator("");
// Copy
menu.AddItem(new GUIContent("Copy State"), false, delegate() { StateUtility.CopySelectedStates(); });
// Paste
if (StateUtility.statesToPaste != null && StateUtility.statesToPaste.Length > 0 && m_State.fsm != null)
{
menu.AddItem(new GUIContent("Paste State"), false, delegate() { StateUtility.PasteStates(m_State.fsm); });
}
else
{
menu.AddDisabledItem(new GUIContent("Paste State"));
}
// Duplicate
if (m_State.fsm != null)
{
menu.AddItem(new GUIContent("Duplicate State"), false, delegate()
{
var statesToPaste = new List <InternalStateBehaviour>(BehaviourWindow.activeStates);
if (!statesToPaste.Contains(m_State))
{
statesToPaste.Add(m_State);
}
StateUtility.CloneStates(m_State.gameObject, statesToPaste.ToArray(), m_State.fsm);
}
);
}
else
{
menu.AddDisabledItem(new GUIContent("Duplicate State"));
}
// Separator
menu.AddSeparator("");
// Delete
menu.AddItem(new GUIContent("Delete"), false, delegate() { StateUtility.Destroy(m_State); this.Refresh(); });
}
else
{
menu.AddDisabledItem(new GUIContent("Set as Start"));
menu.AddDisabledItem(new GUIContent("Set as Enabled"));
menu.AddDisabledItem(new GUIContent("Add Transition"));
menu.AddSeparator("");
menu.AddDisabledItem(new GUIContent("Copy State"));
menu.AddDisabledItem(new GUIContent("Paste State"));
menu.AddSeparator("");
menu.AddDisabledItem(new GUIContent("Delete"));
}
// Show the context menu
menu.ShowAsContext();
}
static void SetupObjectReference(SerializedProperty property, GenericMenu menu, Event evt)
{
var hasPasteObject = Clipboard.hasObject;
var hasPasteGuid = Clipboard.hasGuid;
var hasPastePath = !new GUID(AssetDatabase.AssetPathToGUID(Clipboard.stringValue)).Empty();
var obj = property.objectReferenceValue;
var canCopy = !property.hasMultipleDifferentValues && obj != null;
var canPaste = GUI.enabled && (hasPasteGuid || hasPastePath || hasPasteObject);
if (menu != null)
{
AddSeparator(menu);
var hasAsset = canCopy && AssetDatabase.Contains(obj);
if (canCopy)
{
menu.AddItem(kCopyContent, false, o => Clipboard.objectValue = (UnityEngine.Object)o, obj);
}
else
{
menu.AddDisabledItem(kCopyContent);
}
if (hasAsset)
{
menu.AddItem(kCopyPathContent, false, o => Clipboard.stringValue = AssetDatabase.GetAssetPath((UnityEngine.Object)o).ToString(), obj);
menu.AddItem(kCopyGuidContent, false, o => Clipboard.guidValue = new GUID(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath((UnityEngine.Object)o))), obj);
}
else
{
menu.AddDisabledItem(kCopyPathContent);
menu.AddDisabledItem(kCopyGuidContent);
}
if (canPaste)
{
menu.AddItem(kPasteContent, false, o => PasteObjectReference((SerializedProperty)o), property);
}
else
{
menu.AddDisabledItem(kPasteContent);
}
}
if (evt != null)
{
if (canCopy && evt.commandName == EventCommandNames.Copy)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
Clipboard.objectValue = obj;
evt.Use();
}
}
if (canPaste && evt.commandName == EventCommandNames.Paste)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
PasteObjectReference(property);
evt.Use();
}
}
}
}
public void AddTangentMenuItems(GenericMenu menu, List <KeyIdentifier> keyList)
{
bool flag = keyList.Count > 0;
bool on = flag;
bool flag3 = flag;
bool flag4 = flag;
bool flag5 = flag;
bool flag6 = flag;
bool flag7 = flag;
bool flag8 = flag;
bool flag9 = flag;
bool flag10 = flag;
bool flag11 = flag;
bool flag12 = flag;
foreach (KeyIdentifier identifier in keyList)
{
Keyframe key = identifier.keyframe;
AnimationUtility.TangentMode keyLeftTangentMode = AnimationUtility.GetKeyLeftTangentMode(key);
AnimationUtility.TangentMode keyRightTangentMode = AnimationUtility.GetKeyRightTangentMode(key);
bool keyBroken = AnimationUtility.GetKeyBroken(key);
if ((keyLeftTangentMode != AnimationUtility.TangentMode.ClampedAuto) || (keyRightTangentMode != AnimationUtility.TangentMode.ClampedAuto))
{
on = false;
}
if ((keyLeftTangentMode != AnimationUtility.TangentMode.Auto) || (keyRightTangentMode != AnimationUtility.TangentMode.Auto))
{
flag3 = false;
}
if ((keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free)) || (keyRightTangentMode != AnimationUtility.TangentMode.Free))
{
flag4 = false;
}
if ((keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free)) || (((key.inTangent != 0f) || (keyRightTangentMode != AnimationUtility.TangentMode.Free)) || (key.outTangent != 0f)))
{
flag5 = false;
}
if (!keyBroken)
{
flag6 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Free))
{
flag7 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Linear))
{
flag8 = false;
}
if (!keyBroken || (keyLeftTangentMode != AnimationUtility.TangentMode.Constant))
{
flag9 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Free))
{
flag10 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Linear))
{
flag11 = false;
}
if (!keyBroken || (keyRightTangentMode != AnimationUtility.TangentMode.Constant))
{
flag12 = false;
}
}
if (flag)
{
menu.AddItem(EditorGUIUtility.TextContent("Clamped Auto"), on, new GenericMenu.MenuFunction2(this.SetClampedAuto), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Auto"), flag3, new GenericMenu.MenuFunction2(this.SetAuto), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Free Smooth"), flag4, new GenericMenu.MenuFunction2(this.SetEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Flat"), flag5, new GenericMenu.MenuFunction2(this.SetFlat), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Broken"), flag6, new GenericMenu.MenuFunction2(this.SetBroken), keyList);
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Free"), flag7, new GenericMenu.MenuFunction2(this.SetLeftEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Linear"), flag8, new GenericMenu.MenuFunction2(this.SetLeftLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Constant"), flag9, new GenericMenu.MenuFunction2(this.SetLeftConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Free"), flag10, new GenericMenu.MenuFunction2(this.SetRightEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Linear"), flag11, new GenericMenu.MenuFunction2(this.SetRightLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Constant"), flag12, new GenericMenu.MenuFunction2(this.SetRightConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Free"), flag10 && flag7, new GenericMenu.MenuFunction2(this.SetBothEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Linear"), flag11 && flag8, new GenericMenu.MenuFunction2(this.SetBothLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Constant"), flag12 && flag9, new GenericMenu.MenuFunction2(this.SetBothConstant), keyList);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Clamped Auto"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Auto"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Free Smooth"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Flat"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Broken"));
menu.AddSeparator("");
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Constant"));
}
}
public static void ShowFilterKeyTypeMenu(string current, Action<string> Selected)
{
var menu = new GenericMenu();
menu.AddDisabledItem(new GUIContent(current));
menu.AddSeparator(string.Empty);
for (var i = 0; i < TypeUtility.KeyTypes.Count; i++) {
var type = TypeUtility.KeyTypes[i];
if (type == current) continue;
menu.AddItem(
new GUIContent(type),
false,
() => {
Selected(type);
}
);
}
menu.ShowAsContext();
}
public void ObjectPreview(Rect r)
{
if (r.height <= 0)
{
return;
}
if (m_ZoomablePreview == null)
{
m_ZoomablePreview = new ZoomableArea(true);
m_ZoomablePreview.hRangeMin = 0.0f;
m_ZoomablePreview.vRangeMin = 0.0f;
m_ZoomablePreview.hRangeMax = 1.0f;
m_ZoomablePreview.vRangeMax = 1.0f;
m_ZoomablePreview.SetShownHRange(0, 1);
m_ZoomablePreview.SetShownVRange(0, 1);
m_ZoomablePreview.uniformScale = true;
m_ZoomablePreview.scaleWithWindow = true;
}
// Draw background
GUI.Box(r, "", "PreBackground");
// Top menu rect
Rect menuRect = new Rect(r);
menuRect.y += 1;
menuRect.height = 18;
GUI.Box(menuRect, "", EditorStyles.toolbar);
// Top menu dropdown
Rect dropRect = new Rect(r);
dropRect.y += 1;
dropRect.height = 18;
dropRect.width = 120;
// Drawable area
Rect drawableArea = new Rect(r);
drawableArea.yMin += dropRect.height;
drawableArea.yMax -= 14;
drawableArea.width -= 11;
int index = Array.IndexOf(Styles.ObjectPreviewTextureOptions, m_SelectedObjectPreviewTexture);
if (index < 0 || !LightmapVisualizationUtility.IsTextureTypeEnabled(kObjectPreviewTextureTypes[index]))
{
index = 0;
m_SelectedObjectPreviewTexture = Styles.ObjectPreviewTextureOptions[index];
}
if (EditorGUI.DropdownButton(dropRect, m_SelectedObjectPreviewTexture, FocusType.Passive, EditorStyles.toolbarPopup))
{
GenericMenu menu = new GenericMenu();
for (int i = 0; i < Styles.ObjectPreviewTextureOptions.Length; i++)
{
if (LightmapVisualizationUtility.IsTextureTypeEnabled(kObjectPreviewTextureTypes[i]))
{
menu.AddItem(Styles.ObjectPreviewTextureOptions[i], index == i, SelectPreviewTextureOption, Styles.ObjectPreviewTextureOptions.ElementAt(i));
}
else
{
menu.AddDisabledItem(Styles.ObjectPreviewTextureOptions.ElementAt(i));
}
}
menu.DropDown(dropRect);
}
GITextureType textureType = kObjectPreviewTextureTypes[Array.IndexOf(Styles.ObjectPreviewTextureOptions, m_SelectedObjectPreviewTexture)];
if (m_CachedTexture.type != textureType || m_CachedTexture.contentHash != LightmapVisualizationUtility.GetSelectedObjectGITextureHash(textureType) || m_CachedTexture.contentHash == new Hash128())
{
m_CachedTexture = LightmapVisualizationUtility.GetSelectedObjectGITexture(textureType);
}
if (m_CachedTexture.textureAvailability == GITextureAvailability.GITextureNotAvailable || m_CachedTexture.textureAvailability == GITextureAvailability.GITextureUnknown)
{
if (LightmapVisualizationUtility.IsBakedTextureType(textureType))
{
if (textureType == GITextureType.BakedShadowMask)
{
GUI.Label(drawableArea, Styles.TextureNotAvailableBakedShadowmask);
}
else
{
GUI.Label(drawableArea, Styles.TextureNotAvailableBaked);
}
}
else
{
GUI.Label(drawableArea, Styles.TextureNotAvailableRealtime);
}
return;
}
if (m_CachedTexture.textureAvailability == GITextureAvailability.GITextureLoading && m_CachedTexture.texture == null)
{
GUI.Label(drawableArea, Styles.TextureLoading);
return;
}
LightmapType lightmapType = LightmapVisualizationUtility.GetLightmapType(textureType);
// Framing and drawing
var evt = Event.current;
switch (evt.type)
{
// 'F' will zoom to uv bounds
case EventType.ValidateCommand:
case EventType.ExecuteCommand:
if (Event.current.commandName == EventCommandNames.FrameSelected)
{
Vector4 lightmapTilingOffset = LightmapVisualizationUtility.GetLightmapTilingOffset(lightmapType);
if ((textureType == GITextureType.BakedAlbedo || textureType == GITextureType.BakedEmissive) && LightmapEditorSettings.lightmapper == LightmapEditorSettings.Lightmapper.ProgressiveCPU)
{
lightmapTilingOffset = new Vector4(1f, 1f, 0f, 0f);
}
Vector2 min = new Vector2(lightmapTilingOffset.z, lightmapTilingOffset.w);
Vector2 max = min + new Vector2(lightmapTilingOffset.x, lightmapTilingOffset.y);
min = Vector2.Max(min, Vector2.zero);
max = Vector2.Min(max, Vector2.one);
float swap = 1f - min.y;
min.y = 1f - max.y;
max.y = swap;
// Make sure that the focus rectangle is a even square
Rect rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y);
rect.x -= Mathf.Clamp(rect.height - rect.width, 0, float.MaxValue) / 2;
rect.y -= Mathf.Clamp(rect.width - rect.height, 0, float.MaxValue) / 2;
rect.width = rect.height = Mathf.Max(rect.width, rect.height);
m_ZoomablePreview.shownArea = rect;
Event.current.Use();
}
break;
// Scale and draw texture and uv's
case EventType.Repaint:
Texture2D texture = m_CachedTexture.texture;
if (texture && Event.current.type == EventType.Repaint)
{
Rect textureRect = new Rect(0, 0, texture.width, texture.height);
textureRect = ResizeRectToFit(textureRect, drawableArea);
//textureRect.x = -textureRect.width / 2;
//textureRect.y = -textureRect.height / 2;
textureRect = CenterToRect(textureRect, drawableArea);
textureRect = ScaleRectByZoomableArea(textureRect, m_ZoomablePreview);
// Draw texture and UV
Rect uvRect = new Rect(textureRect);
uvRect.x += 3;
uvRect.y += drawableArea.y + 20;
Rect clipRect = new Rect(drawableArea);
clipRect.y += dropRect.height + 3;
// fix 635838 - We need to offset the rects for rendering.
{
float offset = clipRect.y - 14;
uvRect.y -= offset;
clipRect.y -= offset;
}
// Texture shouldn't be filtered since it will make previewing really blurry
FilterMode prevMode = texture.filterMode;
texture.filterMode = FilterMode.Point;
LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture, Selection.activeGameObject, clipRect, uvRect, textureType);
texture.filterMode = prevMode;
}
break;
}
// Reset zoom if selection is changed
if (m_PreviousSelection != Selection.activeInstanceID)
{
m_PreviousSelection = Selection.activeInstanceID;
m_ZoomablePreview.SetShownHRange(0, 1);
m_ZoomablePreview.SetShownVRange(0, 1);
}
// Handle zoomable area
Rect zoomRect = new Rect(r);
zoomRect.yMin += dropRect.height;
m_ZoomablePreview.rect = zoomRect;
m_ZoomablePreview.BeginViewGUI();
m_ZoomablePreview.EndViewGUI();
GUILayoutUtility.GetRect(r.width, r.height);
}
void OnGUI()
{
Event e = Event.current;
//判断是否在某个节点内部
int in_node_region_index = GetMousePositionInRegion (e.mousePosition);
if (e.button == 1&&e.type==EventType.mouseUp) {
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("新加一个节点"),false,ContextCallback,e.mousePosition);
menu.AddItem(new GUIContent("a/b/c"),false,null,null);
if(in_node_region_index>=0)
{
this.transition_from_node = nodes[in_node_region_index];
menu.AddItem(new GUIContent("新加一条边"),false,AddTransitionCallback,this.transition_from_node);
}
else
{
menu.AddDisabledItem(new GUIContent("新加一条边"));
}
menu.AddItem(new GUIContent("保存所选节点"),false,SaveNodeCallback,null);
menu.AddItem(new GUIContent("加载文件"),false,LoadNodeCallback,null);
menu.ShowAsContext();
}
if (e.button == 0 &&( e.type == EventType.mouseDown ||e.type == EventType.mouseUp)) {
if(this.is_draw_curve)
LinkTarget(e.mousePosition);
this.is_draw_curve = false;
if (in_node_region_index < 0 && e.button == 0 && e.type == EventType.mouseDown) {
this.is_selected_state = true;
this.pre_button_position = new Vector3 (e.mousePosition.x, e.mousePosition.y, 0);
} else if (in_node_region_index < 0 && e.button == 0 && e.type == EventType.mouseUp) {
this.is_selected_state = false;
this.pre_button_position = Vector3.zero;
}
}
Handles.BeginGUI();
if (this.is_selected_state) {
verts[0] = this.pre_button_position;
verts[1] = new Vector3(this.pre_button_position.x,e.mousePosition.y,0);
verts[2] = new Vector3(e.mousePosition.x,e.mousePosition.y,0);
verts[3] = new Vector3(e.mousePosition.x,this.pre_button_position.y,0);
Handles.DrawSolidRectangleWithOutline(verts, new Color(1,1,1,0.2f),new Color(0,0,0,1));
CheckNodeIsSelected(verts[0],verts[2]);
Repaint();
}
for (int i=0; i<nodes.Count; i++) {
nodes[i].DrawCurve();
}
if (this.transition_from_node != null&&this.is_draw_curve) {
Vector3 s = this.transition_from_node.GetCenterPosition();
Vector3 end = new Vector3(e.mousePosition.x,e.mousePosition.y,0);
DrawBezierCurve(s,end);
if(e.button==0&&e.type==EventType.mouseUp){
LinkTarget(e.mousePosition);
}
Repaint ();
}
Handles.EndGUI();
BeginWindows();
for (int i=0; i<nodes.Count; i++) {
nodes[i].DrawNode(i,DoWindow);
}
EndWindows();
}
public void AddTangentMenuItems(GenericMenu menu, List <KeyIdentifier> keyList)
{
bool flag = keyList.Count > 0;
bool on = flag;
bool on2 = flag;
bool on3 = flag;
bool on4 = flag;
bool flag2 = flag;
bool flag3 = flag;
bool flag4 = flag;
bool flag5 = flag;
bool flag6 = flag;
bool flag7 = flag;
foreach (KeyIdentifier current in keyList)
{
Keyframe keyframe = current.keyframe;
TangentMode keyTangentMode = CurveUtility.GetKeyTangentMode(keyframe, 0);
TangentMode keyTangentMode2 = CurveUtility.GetKeyTangentMode(keyframe, 1);
bool keyBroken = CurveUtility.GetKeyBroken(keyframe);
if (keyTangentMode != TangentMode.Smooth || keyTangentMode2 != TangentMode.Smooth)
{
on = false;
}
if (keyBroken || keyTangentMode != TangentMode.Editable || keyTangentMode2 != TangentMode.Editable)
{
on2 = false;
}
if (keyBroken || keyTangentMode != TangentMode.Editable || keyframe.inTangent != 0f || keyTangentMode2 != TangentMode.Editable || keyframe.outTangent != 0f)
{
on3 = false;
}
if (!keyBroken)
{
on4 = false;
}
if (!keyBroken || keyTangentMode != TangentMode.Editable)
{
flag2 = false;
}
if (!keyBroken || keyTangentMode != TangentMode.Linear)
{
flag3 = false;
}
if (!keyBroken || keyTangentMode != TangentMode.Stepped)
{
flag4 = false;
}
if (!keyBroken || keyTangentMode2 != TangentMode.Editable)
{
flag5 = false;
}
if (!keyBroken || keyTangentMode2 != TangentMode.Linear)
{
flag6 = false;
}
if (!keyBroken || keyTangentMode2 != TangentMode.Stepped)
{
flag7 = false;
}
}
if (flag)
{
menu.AddItem(EditorGUIUtility.TextContent("Auto"), on, new GenericMenu.MenuFunction2(this.SetSmooth), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Free Smooth"), on2, new GenericMenu.MenuFunction2(this.SetEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Flat"), on3, new GenericMenu.MenuFunction2(this.SetFlat), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Broken"), on4, new GenericMenu.MenuFunction2(this.SetBroken), keyList);
menu.AddSeparator(string.Empty);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Free"), flag2, new GenericMenu.MenuFunction2(this.SetLeftEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Linear"), flag3, new GenericMenu.MenuFunction2(this.SetLeftLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Left Tangent/Constant"), flag4, new GenericMenu.MenuFunction2(this.SetLeftConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Free"), flag5, new GenericMenu.MenuFunction2(this.SetRightEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Linear"), flag6, new GenericMenu.MenuFunction2(this.SetRightLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Right Tangent/Constant"), flag7, new GenericMenu.MenuFunction2(this.SetRightConstant), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Free"), flag5 && flag2, new GenericMenu.MenuFunction2(this.SetBothEditable), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Linear"), flag6 && flag3, new GenericMenu.MenuFunction2(this.SetBothLinear), keyList);
menu.AddItem(EditorGUIUtility.TextContent("Both Tangents/Constant"), flag7 && flag4, new GenericMenu.MenuFunction2(this.SetBothConstant), keyList);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Auto"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Free Smooth"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Flat"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Broken"));
menu.AddSeparator(string.Empty);
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Left Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Right Tangent/Constant"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Free"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Linear"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Both Tangents/Constant"));
}
}
public void OnTreeViewContextClick(int index)
{
TreeViewItem treeViewItem = this.m_AudioGroupTree.FindNode(index);
if (treeViewItem != null)
{
AudioMixerTreeViewNode audioMixerTreeViewNode = treeViewItem as AudioMixerTreeViewNode;
if (audioMixerTreeViewNode != null && audioMixerTreeViewNode.group != null)
{
GenericMenu genericMenu = new GenericMenu();
if (!EditorApplication.isPlaying)
{
genericMenu.AddItem(new GUIContent("Add child group"), false, new GenericMenu.MenuFunction2(this.AddChildGroupPopupCallback), new AudioMixerGroupPopupContext(this.m_Controller, audioMixerTreeViewNode.group));
if (audioMixerTreeViewNode.group != this.m_Controller.masterGroup)
{
genericMenu.AddItem(new GUIContent("Add sibling group"), false, new GenericMenu.MenuFunction2(this.AddSiblingGroupPopupCallback), new AudioMixerGroupPopupContext(this.m_Controller, audioMixerTreeViewNode.group));
genericMenu.AddSeparator(string.Empty);
genericMenu.AddItem(new GUIContent("Rename"), false, new GenericMenu.MenuFunction2(this.RenameGroupCallback), treeViewItem);
AudioMixerGroupController[] array = this.GetGroupSelectionWithoutMasterGroup().ToArray();
genericMenu.AddItem(new GUIContent((array.Length <= 1) ? "Duplicate group (and children)" : "Duplicate groups (and children)"), false, new GenericMenu.MenuFunction2(this.DuplicateGroupPopupCallback), this);
genericMenu.AddItem(new GUIContent((array.Length <= 1) ? "Remove group (and children)" : "Remove groups (and children)"), false, new GenericMenu.MenuFunction2(this.DeleteGroupsPopupCallback), this);
}
}
else
{
genericMenu.AddDisabledItem(new GUIContent("Modifying group topology in play mode is not allowed"));
}
genericMenu.ShowAsContext();
}
}
}
internal static void DisplayObjectContextMenu(Rect position, Object[] context, int contextUserData)
{
// Don't show context menu if we're inside the side-by-side diff comparison.
if (EditorGUIUtility.comparisonViewMode != EditorGUIUtility.ComparisonViewMode.None)
{
return;
}
Vector2 temp = GUIUtility.GUIToScreenPoint(new Vector2(position.x, position.y));
position.x = temp.x;
position.y = temp.y;
GenericMenu pm = new GenericMenu();
if (context != null && context.Length == 1 && context[0] is Component)
{
Object targetObject = context[0];
Component targetComponent = (Component)targetObject;
// Do nothing if component is not on a prefab instance.
if (PrefabUtility.GetCorrespondingConnectedObjectFromSource(targetComponent.gameObject) == null)
{
}
// Handle added component.
else if (PrefabUtility.GetCorrespondingObjectFromSource(targetObject) == null && targetComponent != null)
{
GameObject instanceGo = targetComponent.gameObject;
PrefabUtility.HandleApplyRevertMenuItems(
"Added Component",
instanceGo,
(menuItemContent, sourceGo) =>
{
TargetChoiceHandler.ObjectInstanceAndSourcePathInfo info = new TargetChoiceHandler.ObjectInstanceAndSourcePathInfo();
info.instanceObject = targetComponent;
info.assetPath = AssetDatabase.GetAssetPath(sourceGo);
GameObject rootObject = PrefabUtility.GetRootGameObject(sourceGo);
if (!PrefabUtility.IsPartOfPrefabThatCanBeAppliedTo(rootObject) || EditorUtility.IsPersistent(instanceGo))
{
pm.AddDisabledItem(menuItemContent);
}
else
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.ApplyPrefabAddedComponent, info);
}
},
(menuItemContent) =>
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.RevertPrefabAddedComponent, targetComponent);
}
);
}
else
{
SerializedObject so = new SerializedObject(targetObject);
SerializedProperty property = so.GetIterator();
bool hasPrefabOverride = false;
while (property.Next(property.hasChildren))
{
if (property.isInstantiatedPrefab && property.prefabOverride && !property.isDefaultOverride)
{
hasPrefabOverride = true;
break;
}
}
// Handle modified component.
if (hasPrefabOverride)
{
bool defaultOverrides =
PrefabUtility.IsObjectOverrideAllDefaultOverridesComparedToAnySource(targetObject);
PrefabUtility.HandleApplyRevertMenuItems(
"Modified Component",
targetObject,
(menuItemContent, sourceObject) =>
{
TargetChoiceHandler.ObjectInstanceAndSourcePathInfo info = new TargetChoiceHandler.ObjectInstanceAndSourcePathInfo();
info.instanceObject = targetObject;
info.assetPath = AssetDatabase.GetAssetPath(sourceObject);
GameObject rootObject = PrefabUtility.GetRootGameObject(sourceObject);
if (!PrefabUtility.IsPartOfPrefabThatCanBeAppliedTo(rootObject) || EditorUtility.IsPersistent(targetObject))
{
pm.AddDisabledItem(menuItemContent);
}
else
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.ApplyPrefabObjectOverride, info);
}
},
(menuItemContent) =>
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.RevertPrefabObjectOverride, targetObject);
},
defaultOverrides
);
}
}
}
pm.ObjectContextDropDown(position, context, contextUserData);
ResetMouseDown();
}
private void CreateEditMenu(Rect position)
{
GenericMenu editMenu = new GenericMenu();
editMenu.AddItem(new GUIContent("New Configuration"), false, HandleEditMenuOption, EditMenuOptions.NewInputConfiguration);
if(_selectionPath.Count >= 1)
editMenu.AddItem(new GUIContent("New Axis"), false, HandleEditMenuOption, EditMenuOptions.NewAxisConfiguration);
else
editMenu.AddDisabledItem(new GUIContent("New Axis"));
editMenu.AddSeparator("");
if(_selectionPath.Count > 0)
editMenu.AddItem(new GUIContent("Duplicate Shift+D"), false, HandleEditMenuOption, EditMenuOptions.Duplicate);
else
editMenu.AddDisabledItem(new GUIContent("Duplicate Shift+D"));
if(_selectionPath.Count > 0)
editMenu.AddItem(new GUIContent("Delete Del"), false, HandleEditMenuOption, EditMenuOptions.Delete);
else
editMenu.AddDisabledItem(new GUIContent("Delete Del"));
if(_inputManager.inputConfigurations.Count > 0)
editMenu.AddItem(new GUIContent("Delete All"), false, HandleEditMenuOption, EditMenuOptions.DeleteAll);
else
editMenu.AddDisabledItem(new GUIContent("Delete All"));
if(_selectionPath.Count >= 2)
editMenu.AddItem(new GUIContent("Copy"), false, HandleEditMenuOption, EditMenuOptions.Copy);
else
editMenu.AddDisabledItem(new GUIContent("Copy"));
if(_copySource != null && _selectionPath.Count >= 2)
editMenu.AddItem(new GUIContent("Paste"), false, HandleEditMenuOption, EditMenuOptions.Paste);
else
editMenu.AddDisabledItem(new GUIContent("Paste"));
editMenu.AddSeparator("");
editMenu.AddItem(new GUIContent("Select Target"), false, HandleEditMenuOption, EditMenuOptions.SelectTarget);
editMenu.AddItem(new GUIContent("Ignore Timescale"), _inputManager.ignoreTimescale, HandleEditMenuOption, EditMenuOptions.IgnoreTimescale);
editMenu.AddItem(new GUIContent("Dont Destroy On Load"), _inputManager.dontDestroyOnLoad, HandleEditMenuOption, EditMenuOptions.DontDestroyOnLoad);
editMenu.DropDown(position);
}
internal static void DoToolContextMenu()
{
var toolHistoryMenu = new GenericMenu()
{
allowDuplicateNames = true
};
var foundTool = false;
// Recent history
if (EditorToolContext.GetLastCustomTool() != null)
{
foundTool = true;
toolHistoryMenu.AddDisabledItem(Styles.recentTools);
EditorToolContext.GetToolHistory(s_ToolList, true);
for (var i = 0; i < Math.Min(k_MaxToolHistory, s_ToolList.Count); i++)
{
var tool = s_ToolList[i];
if (EditorToolUtility.IsCustomEditorTool(tool.GetType()))
{
continue;
}
var name = EditorToolUtility.GetToolName(tool.GetType());
if (tool.IsAvailable())
{
toolHistoryMenu.AddItem(new GUIContent(name), false, () => { EditorToolContext.activeTool = tool; });
}
else
{
toolHistoryMenu.AddDisabledItem(new GUIContent(name));
}
}
toolHistoryMenu.AddSeparator("");
}
EditorToolContext.GetCustomEditorTools(s_ToolList, false);
// Current selection
if (s_ToolList.Any())
{
foundTool = true;
toolHistoryMenu.AddDisabledItem(Styles.selectionTools);
for (var i = 0; i < s_ToolList.Count; i++)
{
var tool = s_ToolList[i];
if (!EditorToolUtility.IsCustomEditorTool(tool.GetType()))
{
continue;
}
var path = new GUIContent(EditorToolUtility.GetToolMenuPath(tool));
if (tool.IsAvailable())
{
toolHistoryMenu.AddItem(path, false, () => { EditorToolContext.activeTool = tool; });
}
else
{
toolHistoryMenu.AddDisabledItem(path);
}
}
toolHistoryMenu.AddSeparator("");
}
var global = EditorToolUtility.GetCustomEditorToolsForType(null);
if (global.Any())
{
foundTool = true;
toolHistoryMenu.AddDisabledItem(Styles.availableTools);
foreach (var toolType in global)
{
toolHistoryMenu.AddItem(
new GUIContent(EditorToolUtility.GetToolMenuPath(toolType)),
false,
() => { EditorTools.EditorTools.SetActiveTool(toolType); });
}
}
if (!foundTool)
{
toolHistoryMenu.AddDisabledItem(Styles.noToolsAvailable);
}
toolHistoryMenu.ShowAsContext();
}
private GenericMenu GenerateMenu(DopeLine dopeline, bool clickedEmpty)
{
GenericMenu menu = new GenericMenu();
this.state.recording = true;
this.state.ResampleAnimation();
string text1 = "Add Key";
if (clickedEmpty)
menu.AddItem(new GUIContent(text1), false, new GenericMenu.MenuFunction2(this.AddKeyToDopeline), (object) dopeline);
else
menu.AddDisabledItem(new GUIContent(text1));
string text2 = this.state.selectedKeys.Count <= 1 ? "Delete Key" : "Delete Keys";
if (this.state.selectedKeys.Count > 0)
menu.AddItem(new GUIContent(text2), false, new GenericMenu.MenuFunction(this.DeleteSelectedKeys));
else
menu.AddDisabledItem(new GUIContent(text2));
if (AnimationWindowUtility.ContainsFloatKeyframes(this.state.selectedKeys))
{
menu.AddSeparator(string.Empty);
List<KeyIdentifier> keyList = new List<KeyIdentifier>();
using (List<AnimationWindowKeyframe>.Enumerator enumerator = this.state.selectedKeys.GetEnumerator())
{
while (enumerator.MoveNext())
{
AnimationWindowKeyframe current = enumerator.Current;
if (!current.isPPtrCurve)
{
int keyframeIndex = current.curve.GetKeyframeIndex(AnimationKeyTime.Time(current.time, this.state.frameRate));
if (keyframeIndex != -1)
{
CurveRenderer curveRenderer = CurveRendererCache.GetCurveRenderer(this.state.activeAnimationClip, current.curve.binding);
int curveId = CurveUtility.GetCurveID(this.state.activeAnimationClip, current.curve.binding);
keyList.Add(new KeyIdentifier(curveRenderer, curveId, keyframeIndex, current.curve.binding));
}
}
}
}
new CurveMenuManager((CurveUpdater) this).AddTangentMenuItems(menu, keyList);
}
return menu;
}
private void DrawWindowToolbar(FD.FlowWindow window) {
/*if (FlowSystem.GetData().modeLayer != ModeLayer.Flow) {
return;
}*/
//var edit = false;
var id = window.id;
var buttonStyle = ME.Utilities.CacheStyle("FlowEditor.DrawWindowToolbar.Styles", "toolbarButton", (name) => {
var _buttonStyle = new GUIStyle(EditorStyles.toolbarButton);
_buttonStyle.stretchWidth = false;
return _buttonStyle;
});
var buttonDropdownStyle = ME.Utilities.CacheStyle("FlowEditor.DrawWindowToolbar.Styles", "toolbarDropDown", (name) => {
var _buttonStyle = new GUIStyle(EditorStyles.toolbarDropDown);
_buttonStyle.stretchWidth = false;
return _buttonStyle;
});
var buttonWarningStyle = ME.Utilities.CacheStyle("FlowEditor.DrawWindowToolbar.Styles", "buttonWarningStyle", (name) => {
var _buttonStyle = new GUIStyle(EditorStyles.toolbarButton);
_buttonStyle.stretchWidth = false;
_buttonStyle.fontStyle = FontStyle.Bold;
return _buttonStyle;
});
GUILayout.BeginHorizontal(EditorStyles.toolbar, GUILayout.ExpandWidth(true));
if (this.waitForAttach == false || this.currentAttachComponent == null) {
if (this.waitForAttach == true) {
if (id != this.currentAttachId) {
var currentAttach = FlowSystem.GetWindow(this.currentAttachId);
if (currentAttach != null) {
//var attachTo = FlowSystem.GetWindow(id);
//var hasContainer = currentAttach.HasContainer();
if (currentAttach.IsContainer() == false) {
if (FlowSystem.AlreadyAttached(this.currentAttachId, this.currentAttachIndex, id) == true) {
if (GUILayout.Button(string.Format("Detach Here{0}", (Event.current.alt == true ? " (Double Direction)" : string.Empty)), buttonStyle) == true) {
FlowSystem.Detach(this.currentAttachId, this.currentAttachIndex, id, oneWay: Event.current.alt == false);
if (this.onAttach != null) this.onAttach(id, this.currentAttachIndex, false);
if (Event.current.shift == false) this.WaitForAttach(-1);
}
} else {
var abTests = (window.abTests.sourceWindowId >= 0/* || currentAttach.attachItems.Any(x => FlowSystem.GetWindow(x.targetId).IsABTest() == true) == true*/);
if (this.currentAttachIndex == 0 &&
(currentAttach.IsABTest() == true ||
abTests == true)) {
/*
if (abTests == true) {
if (GUILayout.Button("Attach Here", buttonStyle) == true) {
this.ShowNotification(new GUIContent("You can't connect using this method. Use `Attach` function on `A/B Test Condition`"));
}
}*/
} else {
if (GUILayout.Button(string.Format("Attach Here{0}", (Event.current.alt == true ? " (Double Direction)" : string.Empty)), buttonStyle) == true) {
FlowSystem.Attach(this.currentAttachId, this.currentAttachIndex, id, oneWay: Event.current.alt == false);
if (this.onAttach != null) this.onAttach(id, this.currentAttachIndex, true);
if (Event.current.shift == false) this.WaitForAttach(-1);
}
}
}
}
}
} else {
if (GUILayout.Button("Cancel", buttonStyle) == true) {
this.WaitForAttach(-1);
}
}
} else {
if (window.IsSmall() == false ||
window.IsFunction() == true ||
window.IsABTest() == true) {
if (GUILayout.Button("Attach/Detach", buttonStyle) == true) {
this.ShowNotification(new GUIContent("Use Attach/Detach buttons to Connect/Disconnect a window"));
this.WaitForAttach(id);
}
}
}
if (window.IsSmall() == false) {
//var isExit = false;
var functionWindow = window.GetFunctionContainer();
if (functionWindow != null) {
if (functionWindow.functionRootId == 0) functionWindow.functionRootId = id;
if (functionWindow.functionExitId == 0) functionWindow.functionExitId = id;
//isExit = (functionWindow.functionExitId == id);
}
var isRoot = (FlowSystem.GetRootWindow() == id || (functionWindow != null && functionWindow.functionRootId == id));
if (GUILayout.Toggle(isRoot, new GUIContent("R", "Set as root"), buttonStyle) != isRoot) {
if (functionWindow != null) {
if (isRoot == true) {
// Was root
// Setup root for the first window in function
functionWindow.functionRootId = window.id;
} else {
// Was not root
// Setup as root but inside this function only
functionWindow.functionRootId = window.id;
}
} else {
if (isRoot == true) {
// Was root
FlowSystem.SetRootWindow(-1);
} else {
// Was not root
FlowSystem.SetRootWindow(id);
}
}
FlowSystem.SetDirty();
}
/*
if (functionWindow != null) {
if (GUILayout.Toggle(isExit, new GUIContent("E", "Set as exit point"), buttonStyle) != isExit) {
if (isExit == true) {
// Was exit
// Setup exit for the first window in function
functionWindow.functionExitId = window.id;
} else {
// Was not exit
// Setup as exit but inside this function only
functionWindow.functionExitId = window.id;
}
FlowSystem.SetDirty();
}
}*/
var isDefault = FlowSystem.GetDefaultWindows().Contains(id);
if (GUILayout.Toggle(isDefault, new GUIContent("D", "Set as default"), buttonStyle) != isDefault) {
if (isDefault == true) {
// Was as default
FlowSystem.GetDefaultWindows().Remove(id);
} else {
// Was not as default
FlowSystem.GetDefaultWindows().Add(id);
}
FlowSystem.SetDirty();
}
}
GUILayout.FlexibleSpace();
if (window.IsSmall() == false && FlowSceneView.IsActive() == false && window.storeType == FD.FlowWindow.StoreType.NewScreen) {
var state = GUILayout.Button("Screen", buttonDropdownStyle);
if (Event.current.type == EventType.Repaint) {
this.layoutStateSelectButtonRect = GUILayoutUtility.GetLastRect();
}
if (state == true) {
var menu = new GenericMenu();
menu.AddItem(new GUIContent("Select Package"), on: false, func: () => { this.SelectWindow(window); });
if (window.compiled == true) {
menu.AddItem(new GUIContent("Edit..."), on: false, func: () => {
var path = Path.GetDirectoryName(AssetDatabase.GetAssetPath(window.GetScreen()));
var filename = window.compiledDerivedClassName + ".cs";
EditorUtility.OpenWithDefaultApp(string.Format("{0}/../{1}", path, filename));
});
}
menu.AddItem(new GUIContent("Create on Scene"), on: false, func: () => { this.CreateOnScene(window); });
var screen = window.GetScreen();
var methodsCount = 0;
WindowSystem.CollectCallVariations(screen, (types, names) => {
++methodsCount;
});
menu.AddDisabledItem(new GUIContent("Calls/Methods: " + methodsCount.ToString()));
menu.AddSeparator("Calls/");
if (window.compiled == true &&
screen != null) {
methodsCount = 0;
WindowSystem.CollectCallVariations(screen, (types, names) => {
var parameters = new List<string>();
for (int i = 0; i < types.Length; ++i) {
parameters.Add(ME.Utilities.FormatParameter(types[i]) + " " + names[i]);
}
var paramsStr = parameters.Count > 0 ? "(" + string.Join(", ", parameters.ToArray()) + ")" : string.Empty;
menu.AddItem(new GUIContent("Calls/OnParametersPass" + paramsStr), on: false, func: () => {
Selection.activeObject = screen;
});
++methodsCount;
});
if (methodsCount == 0) {
menu.AddDisabledItem(new GUIContent("Calls/No `OnParametersPass` Methods Found"));
}
} else {
menu.AddDisabledItem(new GUIContent("Calls/You need to compile window"));
}
Flow.OnFlowWindowScreenMenuGUI(this, window, menu);
menu.DropDown(this.layoutStateSelectButtonRect);
}
/*
if (GUILayout.Button("Edit", buttonStyle) == true) {
if (window.compiled == false) {
this.ShowNotification(new GUIContent("You need to compile this window to use 'Edit' command"));
} else {
edit = true;
}
}*/
}
if (GUILayout.Button("X", buttonWarningStyle) == true) {
if (EditorUtility.DisplayDialog("Are you sure?", "Current window will be destroyed with all links.", "Yes, destroy", "No") == true) {
this.ShowNotification(new GUIContent(string.Format("The window `{0}` was successfully destroyed", window.title)));
FlowSystem.DestroyWindow(id);
return;
}
}
} else {
// Draw Attach/Detach component link
if (this.currentAttachId == id) {
// Cancel
if (GUILayout.Button("Cancel", buttonStyle) == true) {
this.WaitForAttach(-1);
}
} else {
// If it's other window
if (window.IsSmall() == false ||
window.IsFunction() == true) {
if (FlowSystem.AlreadyAttached(this.currentAttachId, this.currentAttachIndex, id, this.currentAttachComponent) == true) {
if (GUILayout.Button("Detach Here", buttonStyle) == true) {
FlowSystem.Detach(this.currentAttachId, this.currentAttachIndex, id, oneWay: true, component: this.currentAttachComponent);
if (this.onAttach != null) this.onAttach(id, this.currentAttachIndex, false);
if (Event.current.shift == false) this.WaitForAttach(-1);
}
} else {
if (GUILayout.Button("Attach Here", buttonStyle) == true) {
FlowSystem.Attach(this.currentAttachId, this.currentAttachIndex, id, oneWay: true, component: this.currentAttachComponent);
if (this.onAttach != null) this.onAttach(id, this.currentAttachIndex, true);
if (Event.current.shift == false) this.WaitForAttach(-1);
}
}
}
}
GUILayout.FlexibleSpace();
}
GUILayout.EndHorizontal();
/*if (edit == true) {
FlowSceneView.SetControl(this, window, this.OnItemProgress);
}*/
}
private void CreateMultiSceneHeaderContextClick(GenericMenu menu, int contextClickedItemID)
{
Scene sceneByHandle = EditorSceneManager.GetSceneByHandle(contextClickedItemID);
if (!SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByHandle))
{
Debug.LogError((object)"Context clicked item is not a scene");
}
else
{
if (sceneByHandle.isLoaded)
{
menu.AddItem(EditorGUIUtility.TextContent("Set Active Scene"), false, new GenericMenu.MenuFunction2(this.SetSceneActive), (object)contextClickedItemID);
menu.AddSeparator(string.Empty);
}
if (sceneByHandle.isLoaded)
{
if (!EditorApplication.isPlaying)
{
menu.AddItem(EditorGUIUtility.TextContent("Save Scene"), false, new GenericMenu.MenuFunction2(this.SaveSelectedScenes), (object)contextClickedItemID);
menu.AddItem(EditorGUIUtility.TextContent("Save Scene As"), false, new GenericMenu.MenuFunction2(this.SaveSceneAs), (object)contextClickedItemID);
menu.AddItem(EditorGUIUtility.TextContent("Save All"), false, new GenericMenu.MenuFunction2(this.SaveAllScenes), (object)contextClickedItemID);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Save Scene"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Save Scene As"));
menu.AddDisabledItem(EditorGUIUtility.TextContent("Save All"));
}
menu.AddSeparator(string.Empty);
}
bool flag1 = EditorSceneManager.loadedSceneCount != this.GetNumLoadedScenesInSelection();
if (sceneByHandle.isLoaded)
{
if (flag1 && !EditorApplication.isPlaying && !string.IsNullOrEmpty(sceneByHandle.path))
{
menu.AddItem(EditorGUIUtility.TextContent("Unload Scene"), false, new GenericMenu.MenuFunction2(this.UnloadSelectedScenes), (object)contextClickedItemID);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Unload Scene"));
}
}
else if (!EditorApplication.isPlaying)
{
menu.AddItem(EditorGUIUtility.TextContent("Load Scene"), false, new GenericMenu.MenuFunction2(this.LoadSelectedScenes), (object)contextClickedItemID);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Load Scene"));
}
bool flag2 = this.GetSelectedScenes().Count == SceneManager.sceneCount;
if (flag1 && !flag2 && !EditorApplication.isPlaying)
{
menu.AddItem(EditorGUIUtility.TextContent("Remove Scene"), false, new GenericMenu.MenuFunction2(this.RemoveSelectedScenes), (object)contextClickedItemID);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TextContent("Remove Scene"));
}
menu.AddSeparator(string.Empty);
if (!string.IsNullOrEmpty(sceneByHandle.path))
{
menu.AddItem(EditorGUIUtility.TextContent("Select Scene Asset"), false, new GenericMenu.MenuFunction2(this.SelectSceneAsset), (object)contextClickedItemID);
}
else
{
menu.AddDisabledItem(new GUIContent("Select Scene Asset"));
}
if (!sceneByHandle.isLoaded)
{
return;
}
menu.AddSeparator(string.Empty);
this.AddCreateGameObjectItemsToMenu(menu, (UnityEngine.Object[])((IEnumerable <Transform>)Selection.transforms).Select <Transform, GameObject>((Func <Transform, GameObject>)(t => t.gameObject)).ToArray <GameObject>(), false, true, sceneByHandle.handle);
}
}
static void SetupAction(SerializedProperty property, GenericMenu menu, Event evt,
Action <SerializedProperty> copyFunc,
Func <SerializedProperty, bool> canPasteFunc,
Action <SerializedProperty> pasteFunc)
{
var canCopy = !property.hasMultipleDifferentValues;
var canPaste = GUI.enabled && canPasteFunc(property);
if (menu != null)
{
AddSeparator(menu);
var copyContent = overrideCopyContent ?? kCopyContent;
if (canCopy)
{
menu.AddItem(copyContent, false, o => copyFunc((SerializedProperty)o), property);
}
else
{
menu.AddDisabledItem(copyContent);
}
var pasteContent = overridePasteContent ?? kPasteContent;
if (canPaste)
{
menu.AddItem(pasteContent, false,
delegate(object o)
{
var prop = (SerializedProperty)o;
pasteFunc(prop);
prop.serializedObject.ApplyModifiedProperties();
// Constrain proportions scale widget might need extra recalculation, notify if a paste
ConstrainProportionsTransformScale.NotifyPropertyPasted(prop.propertyPath);
}, property);
}
else
{
menu.AddDisabledItem(pasteContent);
}
}
if (evt != null)
{
if (canCopy && evt.commandName == EventCommandNames.Copy)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
copyFunc(property);
evt.Use();
}
}
if (canPaste && evt.commandName == EventCommandNames.Paste)
{
if (evt.type == EventType.ValidateCommand)
{
evt.Use();
}
if (evt.type == EventType.ExecuteCommand)
{
pasteFunc(property);
property.serializedObject.ApplyModifiedProperties();
evt.Use();
}
}
}
}