Esempio n. 1
0
        IWorkspace CreateWorkspace()
        {
            var assignableTargets = MakeAssignableEntities(targetObjects, selectedBackendType);

            object[] targetArray = assignableTargets.Any() ?
                                   assignableTargets.ToArray() :
                                   targetObjects != null ?
                                   new object[] { } :
            null;                     // make sure to pass null, NOT an empty array

            var ctorArguments = new object[]
            {
                selectedBackendType,
                targetArray,
                (GetAPI)window.GetAPI,
                (Action)window.Repaint,
                (Action <Action>)window.ExecOnUpdate
            };

            var backendArguments = BackendTypeUtil.GetGenericArguments(selectedBackendType);

            return((IWorkspace)Activator.CreateInstance
                   (
                       typeof(Workspace <,>).MakeGenericType(backendArguments),
                       System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance,
                       null,
                       ctorArguments,
                       null
                   ));
        }
Esempio n. 2
0
        internal Workspace(Type backendType, object[] targets, GetAPI getAPI, Action Repaint, Action <Action> Exec)
        {
            this.Repaint = Repaint;
            this.Exec    = Exec;
            this.api     = getAPI(1) as RelationsInspectorAPI;

            graphBackend = (IGraphBackendInternal <T, P>)BackendTypeUtil.CreateBackendDecorator(backendType);
            graphBackend.Awake(getAPI);

            // create new layout params, they are not comming from the cfg yet
            this.layoutType     = (LayoutType)GUIUtil.GetPrefsInt(GetPrefsKeyLayout(), (int)LayoutType.Tree);
            this.graphPosTweens = new TweenCollection();

            this.builderRNG = new RNG(4);               // chosen by fair dice role. guaranteed to be random.

            expectedTargetType = BackendTypeUtil.BackendAttrType(backendType) ?? typeof(T);

            // when targets is null, show the toolbar only. don't create a graph (and view)
            // when rootEntities is empty, create graph and view anyway, so the user can add entities
            if (targets != null)
            {
                seedEntities = targets.SelectMany(graphBackend.Init).ToHashSet();
                InitGraph();
            }
        }
Esempio n. 3
0
        void UpdateBackend()
        {
            validBackendTypes = GetValidBackendTypes(targetObjects, allBackendTypes).ToList();

            if (!validBackendTypes.Contains(selectedBackendType))
            {
                selectedBackendType = BackendTypeUtil.GetMostSpecificBackendType(validBackendTypes);
            }
        }
Esempio n. 4
0
        // enforce backend selection
        public void SetBackend(Type backendType, bool delayed = true)
        {
            if (!BackendTypeUtil.IsBackendType(backendType))
            {
                throw new ArgumentException(backendType + " is not a valid backend type.");
            }

            targetHistory.RegisterBackendChange(backendType);
            Exec(() => OnSelectBackend(backendType), delayed);
        }
Esempio n. 5
0
        static Texture2D LoadIcon(Type backendType)
        {
            string iconPath = BackendTypeUtil.GetIconPath(backendType);

            if (string.IsNullOrEmpty(iconPath))
            {
                return(null);
            }
            return(Util.LoadAsset <Texture2D>(iconPath));
        }
Esempio n. 6
0
        void DrawTypeRow(Type t)
        {
            // icon
            var iconRect = GUILayoutUtility.GetRect(IconSize, IconSize);
            var icon     = backendIcons[t];

            if (icon != null)
            {
                GUI.DrawTexture(iconRect, icon, ScaleMode.StretchToFill, true);
            }

            // title (if clicked, return the type and close the window)
            string titleText = BackendTypeUtil.GetTitle(t);

            if (t == selectedBackendType)
            {
                string color = EditorGUIUtility.isProSkin ? "white" : "grey";
                titleText = string.Format("<color=\"{0}\">{1}</color>", color, titleText);
            }

            var  titleContent = new GUIContent(titleText, null, BackendTypeUtil.GetDescription(t));
            bool select       = GUILayout.Button(titleContent, backendTitleStyle, GUILayout.Width(TitleWidth));

            if (select)
            {
                OnSelectBackend(t);
                Close();
            }

            // version
            string version = BackendTypeUtil.GetVersion(t);

            if (string.IsNullOrEmpty(version))
            {
                version = string.Empty;
            }

            GUILayout.Label(version, GUILayout.Width(VersionWidth));

            // doc URL (if clicked: open)
            string docURL = BackendTypeUtil.GetDocumentationURL(t);

            GUI.enabled = !string.IsNullOrEmpty(docURL);
            var  docContent = new GUIContent(helpIcon, "Open documentation website");
            bool openDoc    = GUILayout.Button(docContent, GUIStyle.none, GUILayout.ExpandWidth(false));

            if (openDoc)
            {
                Application.OpenURL(docURL);
            }
            GUI.enabled = true;
            GUILayout.FlexibleSpace();
        }
        // return true if a graph of the give backend type should be saved
        private static bool ShouldGraphOfTypeBeSerialized(Type backendType)
        {
            // get first generic type parameter
            Type vertexType = BackendTypeUtil.GetEntityType(backendType);

            // fallback behaviour: return true iff it's a unity object type
            // all other types have no reliable object <-> id mapping
            bool defaultChoice = typeof(UnityEngine.Object).IsAssignableFrom(vertexType);

            // check for LayoutSaving attribute.
            bool?userChoice = BackendTypeUtil.GetLayoutSavingChoice(backendType);

            // respect the explicit attribute choice. fall back to default if there is none
            return(userChoice ?? defaultChoice);
        }
Esempio n. 8
0
        public void ResetTargets(object[] targets, Type backendType, bool delayed = true)
        {
            if (!UserAcceptsTargetCount(targets.Length))
            {
                return;
            }

            if (backendType != null && !BackendTypeUtil.IsBackendType(backendType))
            {
                throw new ArgumentException(backendType + " is not a valid backend type.");
            }

            targetHistory.RegisterState(targets, backendType);
            Exec(() => SetTargetObjects(targets, backendType), delayed);
        }
Esempio n. 9
0
        static IEnumerable <Type> GetValidBackendTypes(IEnumerable <object> targetEntities, IEnumerable <Type> backendTypes)
        {
            if (targetEntities == null || !targetEntities.Any())
            {
                return(backendTypes);
            }

            var entityTypes = TypeUtil.GetValidEntityTypes(targetEntities);

            var autoBackendTypes = BackendTypeUtil.CreateAutoBackendTypes(entityTypes);

            var matchingBackendTypes = backendTypes
                                       .Where(t => !t.IsGenericType)
                                       .Where(backendType =>
                                              BackendTypeUtil.IsEntityTypeAssignableFromAny(backendType, entityTypes) ||
                                              BackendTypeUtil.BackendAttributeFitsAny(backendType, entityTypes));

            return(autoBackendTypes.Concat(matchingBackendTypes));
        }
Esempio n. 10
0
        static IEnumerable <object> MakeAssignableEntities(IEnumerable <object> objs, Type backendType)
        {
            if (objs == null)
            {
                yield break;
            }

            Type acceptedType = BackendTypeUtil.BackendAttrType(backendType);
            Type entityType   = BackendTypeUtil.GetGenericArguments(backendType)[0];

            foreach (var obj in objs)
            {
                if (acceptedType != null && acceptedType.IsAssignableFrom(obj.GetType()))
                {
                    yield return(obj);
                }
                else
                {
                    yield return(TypeUtil.MakeAssignable(obj, entityType));
                }
            }
        }
Esempio n. 11
0
        internal void DrawToolbar()
        {
            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);

            // target history navigation
            targetHistory.OnGUI(LoadHistoryState);

            // clear
            GUI.enabled = targetObjects != null;
            if (GUILayout.Button(clearButtonContent, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
            {
                Exec(() => SetTargetObjects(null));
            }
            GUI.enabled = true;

            // re-create the workspace from targets
            GUI.enabled = targetObjects != null && targetObjects.Any();
            if (GUILayout.Button(rebuildButtonContent, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
            {
                InitWorkspace();
            }
            GUI.enabled = true;

            GUILayout.FlexibleSpace();

            // backend selector
            string backendSelectText = (selectedBackendType != null) ?
                                       BackendTypeUtil.GetTitle(selectedBackendType) :
                                       "Select graph type";

            var backendSelectContent    = new GUIContent(backendSelectText, null, "Select graph type");
            var backendSelectButtonRect = GUILayoutUtility.GetRect(backendSelectContent, EditorStyles.toolbarDropDown, GUILayout.ExpandWidth(false));

            if (GUI.Button(backendSelectButtonRect, backendSelectContent, EditorStyles.toolbarDropDown))
            {
                var window = EditorWindow.CreateInstance <BackendSelectWindow>();
                window.backendTypes        = validBackendTypes.ToArray();
                window.selectedBackendType = selectedBackendType;
                window.OnSelectBackend     = (newSelection) =>
                {
                    // don't save constructed types (because we can't deserialize them yet)
                    if (!newSelection.GetGenericArguments().Any())
                    {
                        GUIUtil.SetPrefsBackendType(PrefsKeyDefaultBackend, newSelection);
                    }
                    SetBackend(newSelection);
                };

                var size = new Vector2(340, 150);
                window.minSize = window.maxSize = size;
                window.ShowAsDropDown(GUIUtil.GUIToScreenRect(backendSelectButtonRect), size);
            }

            GUILayout.FlexibleSpace();

            // workspace toolbar
            if (workspace != null)
            {
                workspace.OnToolbarGUI();
            }

            GUILayout.FlexibleSpace();

            // setttings menu
            if (GUILayout.Button(new GUIContent(SkinManager.GetSkin().settingsIcon, "Settings"), EditorStyles.toolbarButton, GUILayout.Width(25)))
            {
                SettingsMenu.Create();
            }

            EditorGUILayout.EndHorizontal();
        }
Esempio n. 12
0
        internal RIInternal(Action <Action> ExecDelayed, Action <GUIContent> ShowNotification, RelationsInspectorWindow window)
        {
            this.ExecDelayed      = ExecDelayed;
            this.ShowNotification = ShowNotification;
            this.window           = window;

            // all closed backend types are eligible
            validBackendTypes = allBackendTypes = BackendTypeUtil.backendTypes.Where(t => !t.IsOpen() && !BackendTypeUtil.DoHide(t)).ToList();

            targetHistory = new RIStateHistory();

            var firstPassEditorDll = TypeUtil.GetAssemblyByName("Assembly-CSharp-Editor-firstpass");

            Type fallbackBackendType = (firstPassEditorDll != null) ?
                                       firstPassEditorDll.GetType(ProjectSettings.DefaultBackendClassName, false, true)
                                :
                                       null;

            if (fallbackBackendType == null)
            {
                fallbackBackendType = validBackendTypes.FirstOrDefault();
            }

            selectedBackendType = GUIUtil.GetPrefsBackendType(PrefsKeyDefaultBackend) ?? fallbackBackendType;

            if (!allBackendTypes.Any())
            {
                ShowNotification(new GUIContent("Could not find any backend."));
                return;
            }
            else if (selectedBackendType == null)
            {
                ShowNotification(new GUIContent("Could not find default backend."));
                return;
            }
        }