示例#1
0
        /// <summary>
        /// Initializes a new instance of the class.
        /// </summary>
        public MapTo(string to, string changeHandlerName = null, Type valueConverterType = null, bool triggerChangeHandlerImmediately = false)
        {
            MapFieldData    = new MapViewFieldData();
            MapFieldData.To = to;
            MapFieldData.TriggerChangeHandlerImmediately = triggerChangeHandlerImmediately;
            if (valueConverterType != null)
            {
                MapFieldData.ValueConverterType    = valueConverterType.Name;
                MapFieldData.ValueConverterTypeSet = true;
            }

            if (changeHandlerName != null)
            {
                MapFieldData.ChangeHandlerName    = changeHandlerName;
                MapFieldData.ChangeHandlerNameSet = true;
            }
        }
示例#2
0
        /// <summary>
        /// Loads XUML to view database.
        /// </summary>
        private static void LoadViewXuml(XElement xumlElement, string xuml)
        {
            var viewPresenter = ViewPresenter.Instance;

            viewPresenter.ViewTypeDataList.RemoveAll(x => String.Equals(x.ViewTypeName, xumlElement.Name.LocalName, StringComparison.OrdinalIgnoreCase));

            var viewTypeData = new ViewTypeData();

            viewPresenter.ViewTypeDataList.Add(viewTypeData);

            viewTypeData.Xuml         = xuml;
            viewTypeData.XumlElement  = xumlElement;
            viewTypeData.ViewTypeName = xumlElement.Name.LocalName;
            viewTypeData.ViewNameAliases.Add(viewTypeData.ViewTypeName);

            // set dependency names
            foreach (var descendant in xumlElement.Descendants())
            {
                if (!viewTypeData.DependencyNames.Contains(descendant.Name.LocalName, StringComparer.OrdinalIgnoreCase))
                {
                    viewTypeData.DependencyNames.Add(descendant.Name.LocalName);
                }
            }

            // set view type
            var type = GetViewType(viewTypeData.ViewTypeName);

            if (type == null)
            {
                type = typeof(View);
            }

            // set if view is internal
            viewTypeData.HideInPresenter = type.GetCustomAttributes(typeof(HideInPresenter), false).Any();

            // set view action fields
            var viewActionType = typeof(ViewAction);
            var actionFields   = type.GetFields().Where(x => x.FieldType == viewActionType).Select(y => y.Name);

            viewTypeData.ViewActionFields.AddRange(actionFields);

            // set dependency fields
            var viewFieldBaseType = typeof(ViewFieldBase);
            var dependencyFields  = type.GetFields().Where(x => viewFieldBaseType.IsAssignableFrom(x.FieldType)).Select(y => y.Name);

            viewTypeData.DependencyFields.AddRange(dependencyFields);

            // set component fields
            var componentType   = typeof(Component);
            var baseViewType    = typeof(View);
            var componentFields = type.GetFields().Where(x => componentType.IsAssignableFrom(x.FieldType) &&
                                                         !baseViewType.IsAssignableFrom(x.FieldType)).Select(y => y.Name);

            viewTypeData.ComponentFields.AddRange(componentFields);

            // set reference fields
            var referenceFields = type.GetFields().Where(x => baseViewType.IsAssignableFrom(x.FieldType) &&
                                                         x.Name != "Parent" && x.Name != "LayoutParent").Select(y => y.Name);

            viewTypeData.ReferenceFields.AddRange(referenceFields);
            viewTypeData.ReferenceFields.Add("GameObject");

            // set excluded component fields
            var excludedComponentFields = type.GetCustomAttributes(typeof(ExcludeComponent), true);

            viewTypeData.ExcludedComponentFields.AddRange(excludedComponentFields.Select(x => (x as ExcludeComponent).ComponentFieldName));

            // set view-model to view mappings
            var viewNameAliases = type.GetCustomAttributes(typeof(ViewNameAlias), false);

            viewTypeData.ViewNameAliases.AddRange(viewNameAliases.Select(x => (x as ViewNameAlias).ViewAlias));

            // set view-model replacements
            var replacesViewModel = type.GetCustomAttributes(typeof(ReplacesViewModel), false).FirstOrDefault();

            if (replacesViewModel != null)
            {
                viewTypeData.ReplacesViewModel = (replacesViewModel as ReplacesViewModel).ViewTypeName;
            }

            // set mapped fields and their converters and change handlers
            var mapFields      = type.GetFields().SelectMany(x => x.GetCustomAttributes(typeof(MapViewField), true));
            var mapClassFields = type.GetCustomAttributes(typeof(MapViewField), true);

            viewTypeData.MapViewFields.AddRange(mapFields.Select(x => (x as MapViewField).MapFieldData));
            viewTypeData.MapViewFields.AddRange(mapClassFields.Select(x => (x as MapViewField).MapFieldData));

            // .. add mapped dependency fields
            foreach (var field in type.GetFields())
            {
                var mapTo = field.GetCustomAttributes(typeof(MapTo), true).FirstOrDefault() as MapTo;
                if (mapTo == null)
                {
                    continue;
                }

                mapTo.MapFieldData.From = field.Name;
                viewTypeData.MapViewFields.Add(mapTo.MapFieldData);
            }

            // ... see if any dependency fields are remapped
            var remappedViewFields = type.GetCustomAttributes(typeof(RemappedField), true).Cast <RemappedField>();

            foreach (var remappedViewField in remappedViewFields)
            {
                // add or update mapping of old dependency field so it points to the new one
                var mappedDependencyFieldData = viewTypeData.MapViewFields.FirstOrDefault(x => String.Equals(x.From, remappedViewField.MapFieldData.From, StringComparison.OrdinalIgnoreCase));
                if (mappedDependencyFieldData != null)
                {
                    // update so it maps to the new dependency field
                    mappedDependencyFieldData.To = remappedViewField.MapFieldData.To;
                    mappedDependencyFieldData.ValueConverterType              = remappedViewField.MapFieldData.ValueConverterType;
                    mappedDependencyFieldData.ValueConverterTypeSet           = remappedViewField.MapFieldData.ValueConverterTypeSet;
                    mappedDependencyFieldData.ChangeHandlerName               = remappedViewField.MapFieldData.ChangeHandlerName;
                    mappedDependencyFieldData.ChangeHandlerNameSet            = remappedViewField.MapFieldData.ChangeHandlerNameSet;
                    mappedDependencyFieldData.TriggerChangeHandlerImmediately = remappedViewField.MapFieldData.TriggerChangeHandlerImmediately;
                }
                else
                {
                    // add new mapped value
                    viewTypeData.MapViewFields.Add(remappedViewField.MapFieldData);
                }
            }

            //  .. init change handlers and value converters
            foreach (var mapField in viewTypeData.MapViewFields)
            {
                if (mapField.ValueConverterTypeSet)
                {
                    viewTypeData.ViewFieldConverters.Add(new ViewFieldConverterData {
                        ValueConverterType = mapField.ValueConverterType, ViewField = mapField.To
                    });
                }

                if (mapField.ChangeHandlerNameSet)
                {
                    viewTypeData.ViewFieldChangeHandlers.Add(new ViewFieldChangeHandler
                    {
                        ChangeHandlerName  = mapField.ChangeHandlerName,
                        ViewField          = mapField.To,
                        TriggerImmediately = mapField.TriggerChangeHandlerImmediately
                    });
                }
            }

            // set view field converters and change handlers
            foreach (var field in type.GetFields())
            {
                var valueConverter = field.GetCustomAttributes(typeof(ValueConverter), true).FirstOrDefault();
                if (valueConverter != null)
                {
                    viewTypeData.ViewFieldConverters.Add(new ViewFieldConverterData {
                        ViewField = field.Name, ValueConverterType = valueConverter.GetType().Name
                    });
                }

                var changeHandler = field.GetCustomAttributes(typeof(ChangeHandler), true).FirstOrDefault() as ChangeHandler;
                if (changeHandler != null)
                {
                    viewTypeData.ViewFieldChangeHandlers.Add(new ViewFieldChangeHandler {
                        ViewField = field.Name, ChangeHandlerName = changeHandler.Name, TriggerImmediately = changeHandler.TriggerImmediately
                    });
                }

                var notNotSetFromXuml = field.GetCustomAttributes(typeof(NotSetFromXuml), true).FirstOrDefault() as NotSetFromXuml;
                if (notNotSetFromXuml != null)
                {
                    viewTypeData.FieldsNotSetFromXuml.Add(field.Name);
                }

                var genericViewField = field.GetCustomAttributes(typeof(GenericViewField), true).FirstOrDefault();
                if (genericViewField != null)
                {
                    viewTypeData.GenericViewFields.Add(field.Name);
                }

                // see if any component fields are replaced
                var replacedComponentField = field.GetCustomAttributes(typeof(ReplacesComponentField), true).FirstOrDefault() as ReplacesComponentField;
                if (replacedComponentField != null)
                {
                    // when a component field is replaced we need to update the mappings of other fields so they point to the new component
                    foreach (var mappedField in viewTypeData.MapViewFields)
                    {
                        int indexOf = mappedField.To.IndexOf(replacedComponentField.ReplacedComponentField);
                        if (indexOf != 0)
                        {
                            continue;
                        }

                        mappedField.To = mappedField.To.ReplaceFirst(replacedComponentField.ReplacedComponentField, field.Name);
                    }
                }

                // see if any dependency fields are replaced
                var replacedViewField = field.GetCustomAttributes(typeof(ReplacesDependencyField), true).FirstOrDefault() as ReplacesDependencyField;
                if (replacedViewField != null)
                {
                    // add or update mapping of old dependency field so it points to the new one
                    var mappedDependencyFieldData = viewTypeData.MapViewFields.FirstOrDefault(x => String.Equals(x.From, field.Name, StringComparison.OrdinalIgnoreCase));
                    if (mappedDependencyFieldData != null)
                    {
                        var oldMappedDependencyFieldData = viewTypeData.MapViewFields.FirstOrDefault(x => String.Equals(x.From, replacedViewField.ReplacedDependencyField, StringComparison.OrdinalIgnoreCase));
                        if (oldMappedDependencyFieldData != null)
                        {
                            // update so it maps to the new dependency field
                            oldMappedDependencyFieldData.To = mappedDependencyFieldData.To;
                            oldMappedDependencyFieldData.ValueConverterType              = mappedDependencyFieldData.ValueConverterType;
                            oldMappedDependencyFieldData.ValueConverterTypeSet           = mappedDependencyFieldData.ValueConverterTypeSet;
                            oldMappedDependencyFieldData.ChangeHandlerName               = mappedDependencyFieldData.ChangeHandlerName;
                            oldMappedDependencyFieldData.ChangeHandlerNameSet            = mappedDependencyFieldData.ChangeHandlerNameSet;
                            oldMappedDependencyFieldData.TriggerChangeHandlerImmediately = mappedDependencyFieldData.TriggerChangeHandlerImmediately;
                        }
                        else
                        {
                            // add new mapped value
                            var mapViewField = new MapViewFieldData();
                            mapViewField.From = replacedViewField.ReplacedDependencyField;
                            mapViewField.To   = mappedDependencyFieldData.To;
                            mapViewField.ValueConverterType              = mappedDependencyFieldData.ValueConverterType;
                            mapViewField.ValueConverterTypeSet           = mappedDependencyFieldData.ValueConverterTypeSet;
                            mapViewField.ChangeHandlerName               = mappedDependencyFieldData.ChangeHandlerName;
                            mapViewField.ChangeHandlerNameSet            = mappedDependencyFieldData.ChangeHandlerNameSet;
                            mapViewField.TriggerChangeHandlerImmediately = mappedDependencyFieldData.TriggerChangeHandlerImmediately;
                            viewTypeData.MapViewFields.Add(mapViewField);
                        }
                    }
                }
            }

            // get the normal fields that aren't mapped
            var fields = type.GetFields().Where(x =>
                                                !viewTypeData.FieldsNotSetFromXuml.Contains(x.Name) &&
                                                !viewTypeData.ReferenceFields.Contains(x.Name) &&
                                                !viewTypeData.ComponentFields.Contains(x.Name) &&
                                                !viewTypeData.ViewActionFields.Contains(x.Name) &&
                                                !viewTypeData.DependencyFields.Contains(x.Name) &&
                                                !x.IsStatic
                                                ).Select(y => y.Name);
            var properties = type.GetProperties().Where(x =>
                                                        !viewTypeData.FieldsNotSetFromXuml.Contains(x.Name) &&
                                                        !viewTypeData.ReferenceFields.Contains(x.Name) &&
                                                        !viewTypeData.ComponentFields.Contains(x.Name) &&
                                                        !viewTypeData.ViewActionFields.Contains(x.Name) &&
                                                        !viewTypeData.DependencyFields.Contains(x.Name) &&
#if !UNITY_WINRT || UNITY_WINRT_10_0 || UNITY_EDITOR
                                                        x.GetSetMethod() != null &&
                                                        x.GetGetMethod() != null &&
#endif
                                                        x.Name != "enabled" &&
                                                        x.Name != "useGUILayout" &&
                                                        x.Name != "tag" &&
                                                        x.Name != "hideFlags" &&
                                                        x.Name != "name"
                                                        ).Select(y => y.Name);

            viewTypeData.ViewFields.AddRange(fields);
            viewTypeData.ViewFields.AddRange(properties);
        }