コード例 #1
0
        /// <summary>
        /// Search the supplied objects type chain for a drawer that can be used
        /// </summary>
        /// <param name="type">The type object that will be unwinded to look for a processor</param>
        /// <returns>Returns a Parameter Drawer Attribute object that corresponds to a usable drawer</returns>
        private static CustomParameterDrawerAttribute CheckTypeChain(Type type)
        {
            //Create the exact descriptor required for this type
            CustomParameterDrawerAttribute buffer = new CustomParameterDrawerAttribute(type, false);

            //Check if the exact type exists that can be used
            if (parameterDrawers.ContainsKey(buffer))
            {
                return(buffer);
            }

            //Otherwise, traverse the hierarchy chain
            while (type != null)
            {
                //Create the type that is being searched for
                buffer = new CustomParameterDrawerAttribute(type, true);

                //If there is an instance for the descriptor, retrieve it
                if (parameterDrawers.ContainsKey(buffer))
                {
                    return(buffer);
                }

                //Advance a step up the hierarchy
                type = type.BaseType;
            }

            //If gotten this far, nothing to find
            return(null);
        }
コード例 #2
0
        /*----------Functions----------*/
        //PRIVATE

        /// <summary>
        /// Initialise the object with the available object definitions
        /// </summary>
        static ParameterDrawers()
        {
            //Create the lookup dictionaries
            CustomParameterDrawerComparer comp = new CustomParameterDrawerComparer();

            parameterDrawers = new Dictionary <CustomParameterDrawerAttribute, Type>(comp);
            cachedDrawers    = new Dictionary <CustomParameterDrawerAttribute, AParameterDrawer>(comp);
            typeMapping      = new Dictionary <Type, AParameterDrawer>();

            //Find all of the usable drawers within the project
            foreach (Type type in AssemblyTypeScanner.GetTypesWithinAssembly <AParameterDrawer>())
            {
                //Look for the custom drawer processor attribute of the object
                CustomParameterDrawerAttribute descriptor = type.GetFirstCustomAttributeOf <CustomParameterDrawerAttribute>();

                //If there is no attribute can't use it
                if (descriptor == null)
                {
                    continue;
                }

                //Check if the type has already been used
                if (parameterDrawers.ContainsKey(descriptor))
                {
                    Debug.LogWarningFormat("Class '{0}' is being used to Draw for Types '{1}' (Include Children: {2}) and will override the processor '{3}'", type.FullName, descriptor.DrawerType.FullName, descriptor.HandleChildren, parameterDrawers[descriptor].FullName);
                }

                //Save the drawer for later use
                parameterDrawers[descriptor] = type;
            }
        }
コード例 #3
0
        /// <summary>
        /// Retrieve a drawer that can be used to render the supplied type
        /// </summary>
        /// <param name="type">The type of the object that is to be displayed</param>
        /// <param name="attribute">The optional attribute that is attached to the type for consideration</param>
        /// <returns>Returns a Parameter Drawer that will be used to display the value</returns>
        public static AParameterDrawer GetDrawer(Type type, ParameterAttribute attribute)
        {
            //Store a reference to the drawer that will be used to display the current value
            AParameterDrawer drawer = null;

            //Get the type of the attribute
            Type attributeType = (attribute != null ? attribute.GetType() : null);

            //Ensure that if there is an attribute, its drawer state is cached
            if (attributeType != null && !typeMapping.ContainsKey(attributeType))
            {
                //Retrieve the descriptor for the attribute type
                CustomParameterDrawerAttribute buffer = CheckTypeChain(attributeType);

                //Cache the drawer that has been found for the attribute type
                typeMapping[attributeType] = (buffer != null ?
                                              GetDrawer(buffer) :
                                              null
                                              );
            }

            //If there is an attribute drawer now, use that over the type
            if (attribute != null && typeMapping[attributeType] != null)
            {
                drawer = typeMapping[attributeType];
            }

            //Otherwise, a drawer for the type is needed
            else if (!typeMapping.ContainsKey(type))
            {
                //Retrieve the descriptor for the attribute type
                CustomParameterDrawerAttribute buffer = CheckTypeChain(type);

                //Store the processor in type mapping based on its existence
                drawer = typeMapping[type] = (buffer != null ?
                                              GetDrawer(buffer) :
                                              new ErrorParameterDrawer(EErrorType.DrawerMissing)
                                              );
            }

            //Otherwise, just use the type drawer
            else
            {
                drawer = typeMapping[type];
            }

            //Assign the base values to the drawer
            drawer.Processing = type;
            drawer.Attribute  = attribute;

            //Return the stored drawer
            return(drawer);
        }
コード例 #4
0
        /// <summary>
        /// Retrieve a cached processor that can be used for the drawing of parameters
        /// </summary>
        /// <param name="descriptor">The descriptor defining the drawer to be retrieved</param>
        /// <returns>Retrieves an instance of the drawer that can be used or null if unable</returns>
        private static AParameterDrawer GetDrawer(CustomParameterDrawerAttribute descriptor)
        {
            //Make sure there is a cached instance for this descriptor
            if (!cachedDrawers.ContainsKey(descriptor))
            {
                //Try to create an instance with the identified object
                try { cachedDrawers[descriptor] = (AParameterDrawer)Activator.CreateInstance(parameterDrawers[descriptor]); }
                catch (Exception exec) {
                    Debug.LogErrorFormat("Failed to create an instance of the Parameter Drawer object '{0}'. Error: {1}", parameterDrawers[descriptor], exec.Message);
                    cachedDrawers[descriptor] = new ErrorParameterDrawer(EErrorType.DrawerInstanceFailed, string.Format("Drawer Type '{0}' failed to instantiate. Error: {1}", parameterDrawers[descriptor], exec.Message));
                }
            }

            //Returned the cached instance
            return(cachedDrawers[descriptor]);
        }