示例#1
0
 /// <summary>
 /// Registers the entity class.
 /// </summary>
 /// <param name="type">Type of the entity.</param>
 /// <exception cref="RegistrationException">
 /// Unable to register type that is not marked with Entity attribute.
 /// </exception>
 /// <exception cref="EntityException">
 /// One of the properties had its type specified as a file, but it was not a
 /// string.
 /// </exception>
 /// <exception cref="EntityException">
 /// One of the properties had its type specified as a vector, but it was not a
 /// vector type.
 /// </exception>
 /// <exception cref="EntityException">
 /// One of the properties was registered with invalid type.
 /// </exception>
 public static void Register(Type type)
 {
     EntityAttribute attribute;
     if (!type.TryGetAttribute(out  attribute))
     {
     #if DEBUG
         throw new RegistrationException("Unable to register type that is not marked with Entity attribute.");
     #else
         return;
     #endif
     }
     // Register class.
     EntityRegister.Types.Add(attribute.Name, type);
     Native.EntityInterop.RegisterEntityClass
     (
         new EntityRegistrationParams
         {
             name = attribute.Name,
             category = attribute.Category,
             flags = attribute.Flags,
             editorHelper = attribute.EditorHelper,
             editorIcon = attribute.Icon,
             properties = EntityRegister.GetProperties(type)
         }
     );
 }
示例#2
0
        /// <summary>
        /// Creates the native page.
        /// </summary>
        /// <param name="pageType">Type of the page.</param>
        /// <param name="verifyPageValidity">if set to <c>true</c> verify the page validity.</param>
        /// <returns>The created page object.</returns>
        protected override IPage CreateNativePage(Type pageType, bool verifyPageValidity)
        {
            var webDriver = this.driver.Value;

            // Check to see if a frames reference exists, and switch if needed
            PageNavigationAttribute navigationAttribute;
            if (pageType.TryGetAttribute(out navigationAttribute) && !string.IsNullOrWhiteSpace(navigationAttribute.FrameName))
            {
                webDriver.SwitchTo().Frame(navigationAttribute.FrameName);
                this.switchedContext = true;
            }
            else if (this.switchedContext)
            {
                webDriver.SwitchTo().DefaultContent();
                this.switchedContext = false;
            }

            Func<IWebDriver, IBrowser, Action<object>, object> pageBuildMethod;
            if (!this.pageCache.TryGetValue(pageType, out pageBuildMethod))
            {
                pageBuildMethod = pageBuilder.CreatePage(pageType);
                this.pageCache.Add(pageType, pageBuildMethod);
            }

            var nativePage = pageBuildMethod(webDriver, this, null);

            return new SeleniumPage(nativePage)
               {
                   ExecuteWithElementLocateTimeout = this.ExecuteWithElementLocateTimeout,
                   EvaluateWithElementLocateTimeout =  this.EvaluateWithElementLocateTimeout
               };
        }
示例#3
0
        bool TryGetGamemodeParams(ref IScriptRegistrationParams registrationParams, Type type)
        {
            var gamemodeRegistrationParams = new GameRulesRegistrationParams();

            GameRulesAttribute gamemodeAttribute;
            if (type.TryGetAttribute(out gamemodeAttribute))
            {
                if (!string.IsNullOrEmpty(gamemodeAttribute.Name))
                    gamemodeRegistrationParams.name = gamemodeAttribute.Name;

                gamemodeRegistrationParams.defaultGamemode = gamemodeAttribute.Default;
            }

            registrationParams = gamemodeRegistrationParams;

            return true;
        }
示例#4
0
        bool TryGetEntityParams(ref IScriptRegistrationParams registrationParams, Type type)
        {
            var entityRegistrationParams = new EntityRegistrationParams();

            //LoadFlowNode(ref script, true);

            BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
            var folders = type.GetNestedTypes(flags).Where(x => x.ContainsAttribute<EditorPropertyFolderAttribute>());
            var members = type.GetMembers(flags);
            var entityProperties = new List<object>();

            EntityProperty property;
            members.ForEach(member =>
                {
                    if (TryGetProperty(member, out property))
                        entityProperties.Add(property);
                });

            folders.ForEach(folder =>
                {
                    folder.GetMembers().ForEach(member =>
                        {
                            if (TryGetProperty(member, out property))
                            {
                                property.folder = folder.Name;
                                entityProperties.Add(property);
                            }
                        });
                });

            entityRegistrationParams.properties = entityProperties.ToArray();

            EntityAttribute entAttribute;
            if (type.TryGetAttribute(out entAttribute))
            {
                entityRegistrationParams.name = entAttribute.Name;

                var curType = type;

                var entType = typeof(Entity);
                while (curType != entType)
                {
                    if (type.TryGetAttribute(out entAttribute))
                    {
                        // don't override if the type before this (or earlier) changed it.
                        if(entityRegistrationParams.category == null)
                            entityRegistrationParams.category = entAttribute.Category;
                        if(entityRegistrationParams.editorHelper == null)
                            entityRegistrationParams.editorHelper = entAttribute.EditorHelper;
                        if(entityRegistrationParams.editorIcon  == null)
                            entityRegistrationParams.editorIcon = entAttribute.Icon;
                        if(entityRegistrationParams.flags == EntityClassFlags.Default)
                            entityRegistrationParams.flags = entAttribute.Flags;
                    }

                    curType = curType.BaseType;

                }
            }

            registrationParams = entityRegistrationParams;

            return true;
        }
示例#5
0
        bool TryGetFlowNodeParams(ref IScriptRegistrationParams registrationParams, Type type)
        {
            if (!type.GetMembers().Any(member => member.ContainsAttribute<PortAttribute>()))
                return false;

            var nodeRegistrationParams = new FlowNodeRegistrationParams();

            FlowNodeAttribute nodeInfo;
            if (type.TryGetAttribute(out nodeInfo))
            {
                if (!string.IsNullOrEmpty(nodeInfo.UICategory))
                    nodeRegistrationParams.category = nodeInfo.UICategory;

                if (!string.IsNullOrEmpty(nodeInfo.Name))
                    nodeRegistrationParams.name = nodeInfo.Name;
            }

            registrationParams = nodeRegistrationParams;

            return true;
        }
示例#6
0
        /// <summary>
        /// Gets the page URL via the page attributes.
        /// </summary>
        /// <param name="browser">The browser.</param>
        /// <param name="pageType">Type of the page.</param>
        /// <returns>
        /// The URL stricture from the page.
        /// </returns>
        /// <exception cref="PageNavigationException">No PageAttribute or PageNavigationAttribute exists on type: {0}</exception>
        /// <exception cref="PageNavigationException">Thrown if the page is not able to navigate to.</exception>
        private static UriStructure GetPageUriInternal(IBrowser browser, Type pageType)
        {
            PageNavigationAttribute pageNavigationAttribute;
            if (pageType.TryGetAttribute(out pageNavigationAttribute))
            {
                return new UriStructure(pageNavigationAttribute.Url, 
                                        pageNavigationAttribute.IsAbsoluteUrl,
                                        pageNavigationAttribute.UrlTemplate);
            }

            var browserUri = browser.GetUriForPageType(pageType);
            if (!string.IsNullOrWhiteSpace(browserUri))
            {
                return new UriStructure(browserUri, false);
            }

            throw new PageNavigationException("No PageNavigationAttribute exists on type: {0}", pageType.Name);
        }
示例#7
0
        /// <summary>
        /// Creates the native page.
        /// </summary>
        /// <param name="pageType">Type of the page.</param>
        /// <returns>The internal document.</returns>
        private HtmlDocument CreateNativePage(Type pageType)
        {
            Func<UITestControl, IBrowser, Action<HtmlControl>, HtmlDocument> function;
            if (!this.pageCache.TryGetValue(pageType, out function))
            {
                function = PageBuilder<UITestControl, HtmlDocument>.CreateElement(pageType);
                this.pageCache.Add(pageType, function);
            }

            UITestControl parentElement = this.window.Value;

            // Check to see if a frames reference exists
            var isFrameDocument = false;
            PageNavigationAttribute navigationAttribute;
            if (pageType.TryGetAttribute(out navigationAttribute)
                && !string.IsNullOrWhiteSpace(navigationAttribute.FrameName))
            {
                Func<UITestControl, HtmlFrame> frameFunction;
                if (!this.frameCache.Value.TryGetValue(navigationAttribute.FrameName, out frameFunction))
                {
                    throw new PageNavigationException(
                        "Cannot locate frame with ID '{0}' for page '{1}'",
                        navigationAttribute.FrameName,
                        pageType.Name);
                }

                parentElement = frameFunction(parentElement);
                isFrameDocument = true;

                if (parentElement == null)
                {
                    throw new PageNavigationException(
                        "Cannot load frame with ID '{0}' for page '{1}'. The property that matched the frame did not return a parent document.",
                        navigationAttribute.FrameName,
                        pageType.Name);
                }
            }

            var documentElement = function(parentElement, this, null);

            if (isFrameDocument)
            {
                // Set properties that are relevant to the frame.
                documentElement.SearchProperties[HtmlDocument.PropertyNames.FrameDocument] = "True";
                documentElement.SearchProperties[HtmlDocument.PropertyNames.RedirectingPage] = "False";
            }

            return documentElement;
        }
            /// <summary>
            /// Creates a new <see cref="HistorianAdapter"/>.
            /// </summary>
            /// <param name="type"><see cref="Type"/> of historian adapter.</param>
            public HistorianAdapter(Type type)
            {
                m_type = type;

                DescriptionAttribute descriptionAttribute;

                if (m_type.TryGetAttribute(out descriptionAttribute))
                    m_description = descriptionAttribute.Description;
                else
                    m_description = m_type.FullName;
            }
示例#9
0
文件: Table.cs 项目: Acraciel/Gale
        private void build(Type tableType, String prefix)
        {
            //GET the Table Attribute
            var attr = tableType.TryGetAttribute<System.Data.Linq.Mapping.TableAttribute>();
            if (attr == null)
            {
                throw new Gale.Exception.GaleException("API007", tableType.Name);
            }

            //Set Table metadata
            this._type = tableType;
            this._name = tableType.Name;
            this._key = attr.Name;
            this._prefix = prefix;
        }
        /// <summary>
        /// Gets a description of the given type. This method will search for a
        /// <see cref="DescriptionAttribute"/> using reflection. If none is found,
        /// it will default to the <see cref="Type.FullName"/> of the type.
        /// </summary>
        /// <param name="type">The type for which a description is found.</param>
        /// <returns>
        /// Either the description as defined by a <see cref="DescriptionAttribute"/>
        /// or else the <see cref="Type.FullName"/> of the parameter - then <c>true</c>
        /// if the description attribute existed (and was defined); else <c>false</c>.
        /// </returns>
        private static Tuple<string, bool> GetDescription(Type type)
        {
            DescriptionAttribute descriptionAttribute;

            if (type.TryGetAttribute(out descriptionAttribute))
            {
                // Treat null or empty string like there was no description
                if (string.IsNullOrWhiteSpace(descriptionAttribute.Description))
                    return Tuple.Create(type.FullName, false);

                return Tuple.Create(descriptionAttribute.Description, true);
            }

            return Tuple.Create(type.FullName, false);
        }
        // Static Methods

        /// <summary>
        /// Gets the editor browsable state of the given type. This method will
        /// search for a <see cref="EditorBrowsableAttribute"/> using reflection.
        /// If none is found, it will default to <see cref="EditorBrowsableState.Always"/>.
        /// </summary>
        /// <param name="type">The type for which an editor browsable state is found.</param>
        /// <returns>
        /// Either the editor browsable state as defined by an <see cref="EditorBrowsableAttribute"/>
        /// or else <see cref="EditorBrowsableState.Always"/>.
        /// </returns>
        private static EditorBrowsableState GetEditorBrowsableState(Type type)
        {
            EditorBrowsableAttribute editorBrowsableAttribute;

            if (type.TryGetAttribute(out editorBrowsableAttribute))
                return editorBrowsableAttribute.State;

            return EditorBrowsableState.Always;
        }
示例#12
0
        internal EntityRegisterParams GetRegistrationConfig(Type type)
        {
            EntityAttribute entityAttribute = null;
            if(type.TryGetAttribute<EntityAttribute>(out entityAttribute))
            {
                return new EntityRegisterParams(type.Name, entityAttribute.Category, entityAttribute.EditorHelper,
                    entityAttribute.Icon, entityAttribute.Flags);
            }

            return new EntityRegisterParams(type.Name, "Default", "", "", EntityClassFlags.Default);
        }