// ----------------------------------------------------------------------
        public static void DeletePropertiesWizardElement(iCS_EditorObject parent, LibraryObject libraryObject)
        {
#if DEBUG
            Debug.Log("iCanScript: Delete Instance Element => " + libraryObject.displayString);
#endif
            if (parent == null || libraryObject == null)
            {
                return;
            }
            var iStorage = parent.IStorage;
            OpenTransaction(iStorage);
            try {
                SendStartRelayoutOfTree(iStorage);
                iStorage.AnimateGraph(null,
                                      _ => {
                    iStorage.PropertiesWizardDestroy(parent, libraryObject);
                    iStorage.ForcedRelayoutOfTree();
                }
                                      );
                SendEndRelayoutOfTree(iStorage);
            }
            catch (System.Exception) {
                CancelTransaction(iStorage);
                return;
            }
            CloseTransaction(iStorage, "Delete " + libraryObject.nodeName);
        }
        // -------------------------------------------------------------------
        /// Moves the cursor to the next sibling under the same parent.
        ///
        /// @return _true_ if a next sibling exists.  _false_ otherwise.
        ///
        public bool MoveToNextSibling()
        {
            var parent = myCursor.parent;

            if (parent == null)
            {
                return(false);
            }
            var siblings = parent.children;

            if (siblings == null)
            {
                return(false);
            }
            int idx = siblings.IndexOf(myCursor);

            if (idx < 0)
            {
                return(false);
            }
            do
            {
                if (idx >= siblings.Count - 1)
                {
                    return(false);
                }
                myCursor = siblings[idx + 1] as LibraryObject;
                ++idx;
            } while(!ShouldShow(myCursor));
            return(true);
        }
 // ======================================================================
 // Menu context constructors.
 // ----------------------------------------------------------------------
 public iCS_MenuContext(string command, LibraryObject libraryObject = null)
 {
     // All other fields are filled-in on a need bases.
     Command         = command;
     HiddenCommand   = command;
     myLibraryObject = libraryObject;
 }
 // -------------------------------------------------------------------
 /// Advises that a mouse down was performed on the given key.
 ///
 /// @param key The library object on which a mouse down occured.
 /// @param mouseInScreenPoint The position of the mouse.
 /// @param screenArea The screen area used to display the library object.
 ///
 public void MouseDownOn(object key, Vector2 mouseInScreenPoint, Rect screenArea)
 {
     if (key == null)
     {
         return;
     }
     mySelected = key as LibraryObject;
 }
示例#5
0
        // -------------------------------------------------------------------------
        public void PropertiesWizardDestroy(iCS_EditorObject module, LibraryObject libraryObject)
        {
            iCS_EditorObject func = PropertiesWizardFindFunction(module, libraryObject);

            if (func != null)
            {
                DestroyInstance(func);
            }
        }
        // =================================================================================
        // Helpers
        // ---------------------------------------------------------------------------------
        static string GetVariableName(LibraryObject libraryObject)
        {
            var rawName = libraryObject.rawName;

            if (rawName.StartsWith("set_") || rawName.StartsWith("get_"))
            {
                rawName = rawName.Substring(4);
            }
            return(NameUtility.ToDisplayName(rawName));
        }
        static string GetTypeName(LibraryObject libraryObject)
        {
            var type = GetVariableType(libraryObject);

            if (type == null)
            {
                return(null);
            }
            return(NameUtility.ToDisplayName(iCS_Types.TypeName(type)));
        }
        // -------------------------------------------------------------------
        /// Moves the cursor to the parent object.
        ///
        /// @return _true_ if the cursor was moved. _false_ otherwise.
        ///
        public bool MoveToParent()
        {
            var parent = myCursor.parent;

            if (parent == null)
            {
                return(false);
            }
            myCursor = parent as LibraryObject;
            return(true);
        }
        // ---------------------------------------------------------------------------------
        /// 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);
        }
        // =================================================================================
        // Drag events.
        // ---------------------------------------------------------------------------------
        /// Creates a drag and drop object with a node created from the selecct library
        /// object.
        ///
        /// @param libraryObject The user selected library object.
        ///
        void StartDragAndDrop(LibraryObject libraryObject)
        {
            // -- Just return if nothing is selected. --
            if (libraryObject == null)
            {
                return;
            }
            // -- Don't allow to drag & drop for libary root and namespace. --
            if (libraryObject is LibraryRoot)
            {
                return;
            }
            if (libraryObject is LibraryRootNamespace)
            {
                return;
            }
            if (libraryObject is LibraryChildNamespace)
            {
                return;
            }
            // -- Build drag object. --
            GameObject go = new GameObject(libraryObject.nodeName);

            go.hideFlags = HideFlags.HideAndDontSave;
            var          visualScriptRoot = iCS_DynamicCall.AddLibrary(go);
            iCS_IStorage iStorage         = new iCS_IStorage(visualScriptRoot);

            if (iStorage == null)
            {
                Debug.LogWarning("iCanScript: Cannot create iStorage. Contact support.");
            }
            // -- Create node for each known library type. --
            if (CreateInstance(libraryObject, iStorage))
            {
                // -- Commit changes to drag & drop storage. --
                iStorage.SaveStorage();
                // -- Complete the drag information. --
                DragAndDrop.PrepareStartDrag();
                DragAndDrop.objectReferences = new UnityEngine.Object[1] {
                    go
                };
                DragAndDrop.StartDrag(libraryObject.nodeName);
            }
            // -- Release temporary game object in 60 seconds. --
            iCS_AutoReleasePool.AutoRelease(go, 60f);
        }
 // -------------------------------------------------------------------
 /// Determine if the curent library object requires a foldout.
 ///
 /// @return _true_ if current library object requires a foldout.
 ///         _false_ otherwise.
 ///
 bool ShouldUseFoldout(LibraryObject libraryObject)
 {
     if (libraryObject == null)
     {
         return(false);
     }
     if (libraryObject is LibraryRootNamespace)
     {
         return(true);
     }
     if (libraryObject is LibraryChildNamespace)
     {
         return(true);
     }
     if (libraryObject is LibraryType)
     {
         return(true);
     }
     return(false);
 }
        // -------------------------------------------------------------------
        /// Moves the cursor to the first child.
        ///
        /// @return _true_ if the cursor was moved. _false_ otherwise.
        ///
        public bool MoveToFirstChild()
        {
            var siblings = myCursor.children;

            if (siblings == null || siblings.Count == 0)
            {
                return(false);
            }
            int idx = 0;

            do
            {
                if (idx >= siblings.Count)
                {
                    return(false);
                }
                myCursor = siblings[idx] as LibraryObject;
                ++idx;
            } while(!ShouldShow(myCursor));
            return(true);
        }
        static Type GetVariableType(LibraryObject libraryObject)
        {
            var libraryField = libraryObject as LibraryField;

            if (libraryField != null)
            {
                return(libraryField.fieldType);
            }
            var libraryGetProperty = libraryObject as LibraryPropertyGetter;

            if (libraryGetProperty != null)
            {
                return(libraryGetProperty.returnType);
            }
            var librarySetProperty = libraryObject as LibraryPropertySetter;

            if (librarySetProperty != null)
            {
                return(librarySetProperty.parameters[0].ParameterType);
            }
            return(null);
        }
示例#14
0
        public static string GetHelpTitle(LibraryObject libraryObject)
        {
            string title     = "<iCS_highlight>" + libraryObject.nodeName + "</iCS_highlight>";
            string typeName  = null;
            string className = null;

            if (libraryObject is LibraryMemberInfo)
            {
                var memberInfo = libraryObject as LibraryMemberInfo;
                className = iCS_Types.TypeName(memberInfo.declaringType);
            }

            if (libraryObject is LibraryField)
            {
                typeName = "Property of " + className;
            }
            else if (libraryObject is LibraryProperty)
            {
                typeName = "Property of " + className;
            }
            else if (libraryObject is LibraryConstructor)
            {
                typeName = "Variable Builder";
            }
            else if (libraryObject is LibraryFunction)
            {
                typeName = "Function of " + className;
            }
            else if (libraryObject is LibraryEventHandler)
            {
                typeName = "Event Handler for " + className;
            }
            else if (libraryObject is LibraryType)
            {
                typeName = "Class Instance";
            }

            return("<b>" + typeName + " " + title + "</b>");
        }
 // ----------------------------------------------------------------------
 /// Extracts all functions of a given type.
 ///
 /// @param type The type from which to extract.
 ///
 static void ExtractFunctions(LibraryType parentType, Type type)
 {
     foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
     {
         ++myNbOfFunctions;
         var           methodName    = method.Name;
         var           parameters    = method.GetParameters();
         LibraryObject libraryObject = null;
         if (methodName.StartsWith("get_") && parameters.Length == 0)
         {
             libraryObject = new LibraryPropertyGetter(method);
         }
         else if (methodName.StartsWith("set_") && parameters.Length == 1)
         {
             libraryObject = new LibraryPropertySetter(method);
         }
         else
         {
             libraryObject = new LibraryFunction(method);
         }
         parentType.AddChild(libraryObject);
     }
 }
示例#16
0
        // ----------------------------------------------------------------------
        // OK
        public static iCS_EditorObject CreateFunctionCallNode(iCS_EditorObject parent, Vector2 globalPos, LibraryObject libraryObject)
        {
#if SHOW_DEBUG
            Debug.Log("iCanScript: Create Function => " + libraryObject.displayString);
#endif
            if (parent == null || libraryObject == null)
            {
                return(null);
            }
            if (!IsCreationAllowed())
            {
                return(null);
            }
            var iStorage = parent.IStorage;
            OpenTransaction(iStorage);
            iCS_EditorObject function = null;
            try {
                iStorage.AnimateGraph(null,
                                      _ => {
                    function = iStorage.CreateNode(parent.InstanceId, libraryObject);
                    function.SetInitialPosition(globalPos);
                    iStorage.ForcedRelayoutOfTree();
                    iStorage.ReduceCollisionOffset();
                }
                                      );
            }
            catch (System.Exception) {
                CancelTransaction(iStorage);
                return(null);
            }
            if (function == null)
            {
                CancelTransaction(iStorage);
                return(null);
            }
            var name = libraryObject.nodeName;
            CloseTransaction(iStorage, "Create " + name);
            SystemEvents.AnnounceVisualScriptElementAdded(function);
            return(function);
        }
 // ===================================================================
 // Tree View Data Source Extensions
 // -------------------------------------------------------------------
 /// Initializes the cursor position.
 public void Reset()
 {
     myCursor = database;
 }
示例#18
0
        // ----------------------------------------------------------------------
        public iCS_EditorObject PropertiesWizardFindFunction(iCS_EditorObject module, LibraryObject libraryObject)
        {
            iCS_EditorObject foundNode = null;

            module.ForEachChildNode(
                n => {
                if (n.DisplayName == libraryObject.nodeName)
                {
                    foundNode = n;
                }
            }
                );
            return(foundNode);
        }
示例#19
0
        // ======================================================================
        public iCS_EditorObject PropertiesWizardCreate(iCS_EditorObject module, LibraryObject libraryObject)
        {
            if (PropertiesWizardFindFunction(module, libraryObject) != null)
            {
                return(null);
            }
            Rect             moduleRect = module.GlobalRect;
            iCS_EditorObject func       = CreateNode(module.InstanceId, libraryObject);

            func.SetInitialPosition(new Vector2(0.5f * (moduleRect.x + moduleRect.xMax), moduleRect.yMax));
            ForEachChildDataPort(func,
                                 port => {
                string modulePortName = port.DisplayName;
                if (!port.IsTargetOrSelfPort)
                {
                    modulePortName = libraryObject.nodeName;
                }
                if (port.IsInputPort)
                {
                    // Special case for "instance".
                    if (port.IsTargetPort)
                    {
                        iCS_EditorObject classPort = PropertiesWizardGetInputThisPort(module);
                        if (classPort != null)
                        {
                            SetSource(port, classPort);
                        }
                        else
                        {
                            Debug.LogWarning("iCanScript: Unable to find 'this' input port in class module: " + module.DisplayName);
                        }
                    }
                    else
                    {
                        iCS_EditorObject classPort = PropertiesWizardGetPort(module, modulePortName, VSObjectType.InDynamicDataPort);
                        if (classPort == null)
                        {
                            classPort = CreatePort(modulePortName, module.InstanceId, port.RuntimeType, VSObjectType.InDynamicDataPort);
                            SetSource(port, classPort);
                        }
                        else
                        {
                            SetSource(port, classPort);
                        }
                    }
                }
                else
                {
                    // Special case for "instance".
                    if (port.IsTargetOrSelfPort)
                    {
                    }
                    else
                    {
                        iCS_EditorObject classPort = PropertiesWizardGetPort(module, modulePortName, VSObjectType.OutDynamicDataPort);
                        if (classPort == null)
                        {
                            classPort = CreatePort(modulePortName, module.InstanceId, port.RuntimeType, VSObjectType.OutDynamicDataPort);
                            SetSource(classPort, port);
                        }
                        else
                        {
                            SetSource(classPort, port);
                        }
                    }
                }
            }
                                 );
            func.Iconize();
            return(func);
        }
 public VariablePair(LibraryObject inputComponent, bool inputActive, LibraryObject outputComponent, bool outputActive)
 {
     InputControlPair  = new ControlPair(inputComponent, inputActive);
     OutputControlPair = new ControlPair(outputComponent, outputActive);
 }
 public ControlPair(LibraryObject libraryObject, bool isActive = false)
 {
     Component = libraryObject;
     IsActive  = isActive;
 }
 // -------------------------------------------------------------------
 /// Determines if type member should be shown.
 ///
 /// @param libraryObject Library object to test.
 /// @return _true_ if it should be shown. _false_ otherwise.
 ///
 bool ShouldShow(LibraryObject libraryObject)
 {
     return(libraryObject.isVisible);
 }
        // ----------------------------------------------------------------------
        // OK
        public static iCS_EditorObject CreatePropertiesWizardElement(iCS_EditorObject parent, LibraryObject libraryObject)
        {
#if DEBUG
            Debug.Log("iCanScript: Create Instance Element => " + libraryObject.displayString);
#endif
            if (parent == null)
            {
                return(null);
            }
            var iStorage = parent.IStorage;

            iCS_EditorObject instance = null;
            OpenTransaction(iStorage);
            try {
                SendStartRelayoutOfTree(iStorage);
                iStorage.AnimateGraph(null,
                                      _ => {
                    instance = iStorage.PropertiesWizardCreate(parent, libraryObject);
                    instance.SetInitialPosition(parent.GlobalPosition);
                    instance.Iconize();
                    iStorage.ForcedRelayoutOfTree();
                }
                                      );
                SendEndRelayoutOfTree(iStorage);
            }
            catch (System.Exception) {
                instance = null;
            }
            if (instance == null)
            {
                CancelTransaction(iStorage);
                return(null);
            }
            CloseTransaction(iStorage, "Create " + libraryObject.nodeName);
            return(instance);
        }
        // ----------------------------------------------------------------------
        static iCS_EditorObject CreateAttachedMethod(iCS_EditorObject port, iCS_IStorage iStorage, Vector2 globalPos, LibraryObject libraryObject)
        {
            iCS_EditorObject newNodeParent = iStorage.GetNodeAt(globalPos);

            if (newNodeParent == null)
            {
                return(null);
            }
            if (!newNodeParent.IsKindOfPackage || newNodeParent.IsBehaviour)
            {
                return(null);
            }
            // FIXME: Animation & force layout sometime conflict.
            // Open a transaction for multi-operations
            iCS_UserCommands.OpenTransaction(iStorage);
            iCS_EditorObject method = null;

            iStorage.AnimateGraph(null,
                                  _ => {
                if (newNodeParent.IsInstanceNode)
                {
                    method = iCS_UserCommands.CreatePropertiesWizardElement(newNodeParent, libraryObject);
                }
                else
                {
                    method = iCS_UserCommands.CreateFunctionCallNode(newNodeParent, globalPos, libraryObject);
                }

                // Inverse effective data flow if new node is inside port parent.
                bool isConsumerPort = port.IsInputPort;
                var portParent      = port.ParentNode;
                if (portParent.IsParentOf(method))
                {
                    isConsumerPort = !isConsumerPort;
                }
                iCS_EditorObject attachedPort = null;
                iCS_EditorObject providerPort = null;
                iCS_EditorObject consumerPort = null;
                if (isConsumerPort)
                {
                    iCS_EditorObject[] outputPorts = Prelude.filter(x => iCS_Types.IsA(port.RuntimeType, x.RuntimeType), iStorage.GetChildOutputDataPorts(method));
                    // Connect if only one possibility.
                    if (outputPorts.Length == 1)
                    {
                        attachedPort = outputPorts[0];
                        consumerPort = port;
                        providerPort = attachedPort;
                    }
                    else
                    {
                        var bestPort = GetClosestMatch(port, outputPorts);
                        if (bestPort != null)
                        {
                            attachedPort = bestPort;
                            consumerPort = port;
                            providerPort = bestPort;
                        }
                    }
                }
                else
                {
                    iCS_EditorObject[] inputPorts = Prelude.filter(x => iCS_Types.IsA(x.RuntimeType, port.RuntimeType), iStorage.GetChildInputDataPorts(method));
                    // Connect if only one posiibility
                    if (inputPorts.Length == 1)
                    {
                        attachedPort = inputPorts[0];
                        consumerPort = attachedPort;
                        providerPort = port;
                    }
                    // Multiple choices exist so try the one with the closest name.
                    else
                    {
                        var bestPort = GetClosestMatch(port, inputPorts);
                        if (bestPort != null)
                        {
                            attachedPort = bestPort;
                            consumerPort = bestPort;
                            providerPort = port;
                        }
                    }
                }
                // Position attached port and layout binding.
                if (attachedPort != null && consumerPort != null && providerPort != null)
                {
                    iStorage.AutoLayoutPort(attachedPort, port.GlobalPosition, attachedPort.ParentNode.GlobalPosition);
                    iStorage.SetAndAutoLayoutNewDataConnection(consumerPort, providerPort);
                }
                iStorage.ForcedRelayoutOfTree();
            }
                                  );
            iCS_UserCommands.CloseTransaction(iStorage, "Create => " + libraryObject.nodeName);
            return(method);
        }