// ---------------------------------------------------------------------- public static bool DeleteMultiSelectedObjects(iCS_IStorage iStorage) { #if SHOW_DEBUG Debug.Log("iCanScript: Multi-Select Delete"); #endif if (iStorage == null) { return(false); } if (!IsDeletionAllowed()) { return(false); } var selectedObjects = iStorage.GetMultiSelectedObjects(); if (selectedObjects == null || selectedObjects.Length == 0) { return(false); } if (selectedObjects.Length == 1) { DeleteObject(selectedObjects[0]); return(true); } OpenTransaction(iStorage); try { iStorage.AnimateGraph(null, _ => { foreach (var obj in selectedObjects) { if (!obj.CanBeDeleted()) { ShowNotification("Fix port=> \"" + obj.DisplayName + "\" from node=> \"" + obj.ParentNode.FullName + "\" cannot be deleted."); continue; } // Move the selection to the parent node var parent = obj.ParentNode; iStorage.SelectedObject = parent; SystemEvents.AnnounceVisualScriptElementWillBeRemoved(obj); if (obj.IsInstanceNodePort) { iStorage.PropertiesWizardDestroyAllObjectsAssociatedWithPort(obj); } else { iStorage.DestroyInstance(obj.InstanceId); } iStorage.ForcedRelayoutOfTree(); } } ); } catch (System.Exception) { CancelTransaction(iStorage); return(false); } CloseTransaction(iStorage, "Delete Selection"); return(true); }
// ================================================================================= // INITIALIZATION // --------------------------------------------------------------------------------- public static void Init(iCS_IStorage iStorage) { var editor = EditorWindow.CreateInstance <VisualScriptSettingsEditor>(); editor.ShowUtility(); editor.iStorage = iStorage; }
// ---------------------------------------------------------------------- // Returns the port name position in graph coordinate and GUI scale size. Rect GetPortNamePosition(iCS_EditorObject port, iCS_IStorage iStorage) { Vector2 labelSize = GetPortNameSize(port); Vector2 labelPos = GetPortCenter(port); switch (port.Edge) { case iCS_EdgeEnum.Left: labelPos.x += iCS_EditorConfig.PortDiameter; labelPos.y -= 1 + 0.5f * labelSize.y / Scale; break; case iCS_EdgeEnum.Right: labelPos.x -= labelSize.x / Scale + iCS_EditorConfig.PortDiameter; labelPos.y -= 1 + 0.5f * labelSize.y / Scale; break; case iCS_EdgeEnum.Top: labelPos.x -= 1 + 0.5f * labelSize.x / Scale; labelPos.y -= iCS_EditorConfig.PortDiameter + 0.8f * (labelSize.y / Scale); break; case iCS_EdgeEnum.Bottom: labelPos.x -= 1 + 0.5f * labelSize.x / Scale; labelPos.y += iCS_EditorConfig.PortDiameter; break; } return(new Rect(labelPos.x, labelPos.y, labelSize.x, labelSize.y)); }
// ---------------------------------------------------------------------- void FunctionMenu(iCS_EditorObject selectedObject, iCS_IStorage storage) { iCS_MenuContext[] menu; if (!selectedObject.IsIconizedInLayout) { // Base menu items menu = new iCS_MenuContext[0]; int idx = 0; // -- Add Enable & Trigger -- idx = GrowMenuBy(ref menu, 1); menu[idx] = new iCS_MenuContext(EnablePortStr); idx = GrowMenuBy(ref menu, 1); if (storage.HasTriggerPort(selectedObject)) { menu[idx] = new iCS_MenuContext("#" + TriggerPortStr); } else { menu[idx] = new iCS_MenuContext(TriggerPortStr); } idx = GrowMenuBy(ref menu, 1); menu[idx] = new iCS_MenuContext(SeparatorStr); } else { menu = new iCS_MenuContext[0]; } AddWrapInPackageIfAppropriate(ref menu, selectedObject); AddShowInHierarchyMenuItem(ref menu); AddDeleteMenuItem(ref menu); ShowMenu(menu, selectedObject, storage); }
// ---------------------------------------------------------------------- // Assures proper initialization and returns true if editor is ready // to execute. bool IsInitialized() { // Nothing to do if we don't have a Graph to edit... UpdateMgr(); if (IStorage == null) { myBookmark = null; DragType = DragTypeEnum.None; CloseSubEditor(); return(false); } if (IStorage != myPreviousIStorage) { // Avoid using a storage without a root node. if (StorageRoot == null) { return(false); } myPreviousIStorage = IStorage; myBookmark = null; DragType = DragTypeEnum.None; CloseSubEditor(); IStorage.ForceRelayout = true; } // Don't run if graphic sub-system did not initialise. if (iCS_Graphics.IsInitialized == false) { iCS_Graphics.Init(IStorage); } // Update visual script cache. UpdateVisualScriptCache(); return(true); }
// ================================================================================= // Storage & Selected object Update. This update is called by the Editors. // --------------------------------------------------------------------------------- public static void Update() { // -- Use previous game object if new selection does not include a visual script. -- GameObject go = Selection.activeGameObject; var monoBehaviour = go != null?go.GetComponent <iCS_MonoBehaviourImp>() : null; // -- Verify if we should save visual script. -- if (myIStorage != null && myIStorage.iCSMonoBehaviour != monoBehaviour) { var previousMonobehaviour = myIStorage.iCSMonoBehaviour; if (previousMonobehaviour != null) { ImmediateSaveWithUndo(); SaveAndLoad.Save(myIStorage); } } if (monoBehaviour == null) { // Clear if previous game object is not valid. ImmediateSaveWithUndo(); myIStorage = null; myIsPlaying = Application.isPlaying; return; } // Verify for storage change. bool isPlaying = Application.isPlaying; if (myIStorage == null || myIStorage.iCSMonoBehaviour != monoBehaviour || myIsPlaying != isPlaying) { ImmediateSaveWithUndo(); myIsPlaying = isPlaying; myIStorage = new iCS_IStorage(monoBehaviour); return; } }
public static void UndoIfUndoRedoId(int modificationId, iCS_IStorage iStorage) { if (IsCurrentUndoRedoId(modificationId, iStorage)) { Undo.PerformUndo(); } }
public static void MakeVisible(iCS_EditorObject eObj, iCS_IStorage iStorage) { if (eObj == null || iStorage == null) { return; } if (eObj.IsNode) { for (var parent = eObj.Parent; parent != null && parent.InstanceId != 0; parent = parent.Parent) { parent.Unfold(); } return; } if (eObj.IsPort) { var portParent = eObj.ParentNode; if (!portParent.IsVisibleInLayout || portParent.IsIconizedInLayout) { portParent.Fold(); } MakeVisible(portParent, iStorage); return; } }
// ---------------------------------------------------------------------- public static iCS_EditorObject GetNextSibling(iCS_EditorObject node, iCS_IStorage storage) { if (node == null || node.Parent == null) { return(null); } iCS_EditorObject nextSibling = null; iCS_EditorObject firstChild = null; bool nodeFound = false; storage.UntilMatchingChildNode(node.Parent, child => { if (firstChild == null) { firstChild = child; } if (child == node) { nodeFound = true; return(false); } if (nodeFound) { nextSibling = child; return(true); } return(false); } ); if (!nodeFound) { return(node); } return(nextSibling ?? firstChild); }
// ---------------------------------------------------------------------- public static iCS_EditorObject WrapMultiSelectionInPackage(iCS_IStorage iStorage) { if (iStorage == null) { return(null); } if (!IsCreationAllowed()) { return(null); } var selectedObjects = iStorage.FilterMultiSelectionForWrapInPackage(); if (selectedObjects == null || selectedObjects.Length == 0) { return(null); } iCS_EditorObject package = null; OpenTransaction(iStorage); try { iStorage.AnimateGraph(null, _ => { var childrenRects = P.map(n => n.GlobalRect, selectedObjects); package = iStorage.WrapInPackage(selectedObjects); if (package != null) { var r = Math3D.Union(childrenRects); var pos = Math3D.Middle(r); package.SetInitialPosition(Math3D.Middle(r)); iStorage.ForcedRelayoutOfTree(); package.myAnimatedRect.StartValue = BuildRect(pos, Vector2.zero); for (int i = 0; i < selectedObjects.Length; ++i) { selectedObjects[i].SetInitialPosition(iCS_EditorObject.PositionFrom(childrenRects[i])); selectedObjects[i].LocalSize = iCS_EditorObject.SizeFrom(childrenRects[i]); } iStorage.ForcedRelayoutOfTree(); iStorage.ReduceCollisionOffset(); } else { Debug.LogWarning("iCanScript: Unable to create a suitable package."); } } ); } catch (System.Exception) { CancelTransaction(iStorage); return(null); } if (package == null) { CancelTransaction(iStorage); return(null); } CloseTransaction(iStorage, "Wrap Selection"); SystemEvents.AnnounceVisualScriptElementAdded(package); return(package); }
// ====================================================================== // GUI helpers // ---------------------------------------------------------------------- public static int SafeSelectAndMakeVisible(iCS_EditorObject selected, iCS_IStorage iStorage) { iCS_UserCommands.OpenTransaction(iStorage); iCS_UserCommands.Select(selected, iStorage); CenterOn(selected, iStorage); iCS_UserCommands.CloseTransaction(iStorage, "Focus on: " + selected.DisplayName); return(iStorage.UndoRedoId); }
// ---------------------------------------------------------------------- static void SendEndRelayoutOfTree(iCS_IStorage iStorage) { var visualEditor = iCS_EditorController.FindVisualEditor(); if (visualEditor != null && visualEditor.IStorage == iStorage) { visualEditor.OnEndRelayoutOfTree(); } }
// ---------------------------------------------------------------------- static void SendDisplayRootChange(iCS_IStorage iStorage) { var visualEditor = iCS_EditorController.FindVisualEditor(); if (visualEditor != null && visualEditor.IStorage == iStorage) { visualEditor.OnDisplayRootChange(); } }
public static void CenterOn(iCS_EditorObject eObj, iCS_IStorage iStorage) { MakeVisible(eObj, iStorage); var graphEditor = iCS_EditorController.FindVisualEditor(); if (graphEditor != null) { graphEditor.CenterAndScaleOn(eObj); } }
// ---------------------------------------------------------------------- private static void RebuildChildrenLists(iCS_IStorage iStorage) { iStorage.ForEach( obj => { if (obj.IsParentValid) { obj.Parent.AddChild(obj); } } ); }
// ---------------------------------------------------------------------- void SelectedPortMenu(iCS_EditorObject port, iCS_IStorage storage) { iCS_MenuContext[] menu = new iCS_MenuContext[1]; menu[0] = new iCS_MenuContext(ShowHierarchyStr); // Allow to delete a port if its parent is a module. if (port.CanBeDeleted()) { AddDeleteMenuItem(ref menu); } ShowMenu(menu, port, storage); }
// ---------------------------------------------------------------------- static string GetPortPath(iCS_EditorObject port, iCS_IStorage iStorage) { iCS_EditorObject parent = port.Parent; string path = parent.DisplayName; for (parent = parent.Parent; parent != null && parent != iStorage[0]; parent = parent.Parent) { path += "." + parent.DisplayName; } return(path); }
// ====================================================================== // Rebuild from engine database. // ---------------------------------------------------------------------- public iCS_EditorObject(int id, iCS_IStorage iStorage) { myIStorage = iStorage; myId = id; var parent = Parent; if (parent != null) { parent.AddChild(this); } }
public static void SaveWithUndo(iCS_IStorage iStorage, string undoMessage, TransactionType transactionType) { if (mySaveIStorage != null && mySaveIStorage != iStorage) { ImmediateSaveWithUndo(); } mySaveIStorage = iStorage; mySaveUndoMessage = undoMessage; mySaveTransactionType = transactionType; mySaveTimer.Restart(); }
static void PerformSaveWithUndo() { if (mySaveIStorage == null) { return; } var iStorageToSave = mySaveIStorage; mySaveIStorage = null; iStorageToSave.SaveWithUndo(mySaveUndoMessage, mySaveTransactionType); }
// ---------------------------------------------------------------------- // Change the display root to the parent of the selected object. public static void ResetDisplayRoot(iCS_IStorage iStorage) { if (iStorage == null) { return; } OpenTransaction(iStorage); iStorage.ClearNavigationHistory(); SendDisplayRootChange(iStorage); CloseTransaction(iStorage, "Reset Display Root"); }
public static void StartMultiSelectionNodeRelocation(iCS_IStorage iStorage) { OpenTransaction(iStorage); // Keep a copy of the original position. var selectedNodes = iStorage.FilterMultiSelectionForMove(); foreach (var node in selectedNodes) { node.AnimationTargetRect = node.GlobalRect; } }
public static void CancelMultiSelectionNodeRelocation(iCS_IStorage iStorage) { // Animate node back to its original position. iStorage.AnimateGraph(null, _ => { iStorage.CancelMultiSelectionNodeRelocation(); iStorage.ForcedRelayoutOfTree(); } ); CancelTransaction(iStorage); }
// ====================================================================== // Initialization // ---------------------------------------------------------------------- public iCS_PropertyController(iCS_EditorObject target, iCS_IStorage iStorage) { // Update main state variables. myTarget = target; myStorage = iStorage; if (!IsValid) { return; } BuildViews(); }
// --------------------------------------------------------------------------------- /// Creates a visual script node from the given library object. /// /// @param libraryObject The library object from which to create a visual node. /// @param iStorage The storage in which to put the created node. /// @return _true_ if instance was created. _false_ otherwise. /// bool CreateInstance(LibraryObject libraryObject, iCS_IStorage iStorage) { if (libraryObject is LibraryType) { var libraryType = libraryObject as LibraryType; iStorage.CreatePropertyWizardNode(-1, libraryType.type); return(true); } var node = iStorage.CreateNode(-1, libraryObject); return(node != null); }
// --------------------------------------------------------------------------------- public static bool IsSameVisualScript(iCS_MonoBehaviourImp monoBehaviour, iCS_IStorage iStorage) { if (monoBehaviour == null || iStorage == null) { return(false); } if (iStorage.iCSMonoBehaviour == monoBehaviour) { return(true); } return(false); }
// --------------------------------------------------------------------------------- public static bool IsSameVisualScript(iCS_IStorage iStorage, iCS_VisualScriptData storage) { if (iStorage == null || storage == null) { return(false); } if (iStorage.Storage == storage) { return(true); } return(false); }
public static void MenuSanityCheck() { iCS_IStorage storage = iCS_VisualScriptDataController.IStorage; if (storage == null) { return; } Debug.Log("iCanScript: Start Sanity Check on: " + storage.iCSMonoBehaviour.name); storage.SanityCheck(); Debug.Log("iCanScript: Completed Sanity Check on: " + storage.iCSMonoBehaviour.name); }
// ====================================================================== // Undo/Redo is a condition detected by the storage. It simulates // a User Command. static void ReloadEditorData(iCS_IStorage iStorage, Action reloadAction) { var animationStarts = new Rect[iStorage.EditorObjects.Count]; iStorage.ForEach(obj => { animationStarts[obj.InstanceId] = obj.AnimationTargetRect; }); var previousScrollPosition = iStorage.ScrollPosition; var previousScale = iStorage.GuiScale; iStorage.AnimateGraph(null, _ => { // Keep a copy of the animation start Rect. // Rebuild editor data. try { reloadAction(); } catch (System.Exception e) { Debug.LogWarning("iCanScript: Problem found regenerating data: " + e.Message); } // Rebuild layout iStorage.ForcedRelayoutOfTree(); // Put back the animation start Rect. int len = animationStarts.Length; for (int id = 0; id < len; ++id) { if (iStorage.IsValid(id)) { var obj = iStorage.EditorObjects[id]; obj.ResetAnimationRect(animationStarts[id]); } } var visualEditor = iCS_EditorController.FindVisualEditor(); if (visualEditor != null) { var animationTime = PreferencesController.AnimationTime; visualEditor.AnimateScrollPosition(previousScrollPosition, iStorage.ScrollPosition, animationTime); visualEditor.AnimateScale(previousScale, iStorage.GuiScale, animationTime); } } ); // Update central visual script data iCS_VisualScriptDataController.Update(); // Repaint all windows that could have changed. iCS_EditorController.RepaintAllEditors(); // Force redraw of Inspector Window. EditorUtility.SetDirty(iStorage.iCSMonoBehaviour); // Annouce that an undo occured. SystemEvents.AnnouceVisualScriptUndo(iStorage); }
// ---------------------------------------------------------------------- void PortMenu(MenuType menuType, iCS_EditorObject port, iCS_IStorage storage, bool reverseInOut) { switch (menuType) { case MenuType.SelectedObject: SelectedPortMenu(port, storage); break; case MenuType.ReleaseAfterDrag: ReleaseAfterDragPortMenu(port, storage, reverseInOut); break; } }