コード例 #1
0
ファイル: CommandSerializer.cs プロジェクト: mff-uk/exolutio
        public static CommandBase CreateCommand(Controller controller, CommandDescriptor commandDescriptor)
        {
            CommandBase commandObject = CreateCommandObject(commandDescriptor.CommandName);

            if (commandObject is StackedCommand)
            {
                ((StackedCommand)commandObject).Controller = controller;
            }

            FillParameters(commandObject, commandDescriptor);

            return(commandObject);
        }
コード例 #2
0
ファイル: CommandSerializer.cs プロジェクト: mff-uk/exolutio
 public static void FillParameters(CommandBase commandObject, CommandDescriptor parametersDescriptors)
 {
     foreach (ParameterDescriptor parameter in parametersDescriptors.Parameters)
     {
         PropertyInfo propertyInfo = parameter.ParameterPropertyInfo;
         object       value        = parameter.ParameterValue;
         if (value == null && parameter.CreateControlInEdtors == false)
         {
             continue;
         }
         propertyInfo.SetValue(commandObject, value, null);
     }
 }
コード例 #3
0
ファイル: CommandSerializer.cs プロジェクト: mff-uk/exolutio
        public static CommandBase DeserializeCommand(XElement commandElement)
        {
            XElement    fullNameElement = commandElement.Element(SERIALIZATION_NS + "FullName");
            CommandBase commandObject   = CreateCommandObject(fullNameElement.Value);

            CommandDescriptor commandParametersDescriptors = PublicCommandsHelper.GetCommandDescriptor(commandObject.GetType());

            foreach (XElement parameterElement in commandElement.Element(SERIALIZATION_NS + "Parameters").Elements(SERIALIZATION_NS + "Parameter"))
            {
                string propertyName              = parameterElement.Element(SERIALIZATION_NS + "PropertyName").Value;
                ParameterDescriptor parameter    = commandParametersDescriptors.GetParameterByPropertyName(propertyName);
                PropertyInfo        propertyInfo = parameter.ParameterPropertyInfo;
                string stringValue = parameterElement.Element(SERIALIZATION_NS + "Value").Value;
                object value       = DeserializePropertyValue(propertyInfo, stringValue);
                parameter.ParameterValue = value;
            }

            FillParameters(commandObject, commandParametersDescriptors);

            return(commandObject);
        }
コード例 #4
0
        private static void LoadCommandsTypes()
        {
            if (publicCommandsTypes == null)
            {
                Assembly assembly = typeof(CommandBase).Assembly;
                publicCommandsTypes   = assembly.GetTypesWithAttribute <PublicCommandAttribute>();
                publicCommandsByScope = new Dictionary <ScopeAttribute.EScope, List <CommandDescriptor> >();
                publicCommandsByType  = new Dictionary <Type, CommandDescriptor>();

                foreach (ScopeAttribute.EScope scope in Enum.GetValues(typeof(ScopeAttribute.EScope)))
                {
                    publicCommandsByScope.CreateSubCollectionIfNeeded(scope);
                }

                foreach (Type commandType in publicCommandsTypes)
                {
                    PublicCommandAttribute a;
                    commandType.TryGetAttribute(out a);

                    CommandDescriptor commandDescriptor = new CommandDescriptor();
                    commandDescriptor.CommandName        = commandType.FullName;
                    commandDescriptor.CommandDescription = a.Name;
                    commandDescriptor.CommandType        = commandType;
                    commandDescriptor.Parameters         = GetCommandParameters(commandType);

                    publicCommandsByType.Add(commandType, commandDescriptor);

                    foreach (PropertyInfo propertyInfo in commandType.GetProperties())
                    {
                        PublicArgumentAttribute publicArgumentAttribute;
                        if (propertyInfo.TryGetAttribute(out publicArgumentAttribute))
                        {
                            if (propertyInfo.PropertyType.IsAmong(typeof(Guid), typeof(List <Guid>)))
                            {
                                if (publicArgumentAttribute.ComponentType == null)
                                {
                                    throw new ExolutioCommandException(
                                              "When MandatoryArgument is applied on a property of type System.Guid, property ComponentType must be defined for the attribute.");
                                }
                            }
                            else if (publicArgumentAttribute.ComponentType != null)
                            {
                                throw new ExolutioCommandException(
                                          "When MandatoryArgument is applied on a property of type other than System.Guid, property ComponentType must not be defined for the attribute.");
                            }
                        }

                        ScopeAttribute scopeAttribute;
                        if (propertyInfo.TryGetAttribute(out scopeAttribute))
                        {
                            commandDescriptor.ScopeProperty = propertyInfo;
                            commandDescriptor.Scope         = scopeAttribute.Scope;
                            ParameterDescriptor scopeParameter = commandDescriptor.Parameters.First(p => p.ParameterPropertyInfo == commandDescriptor.ScopeProperty);
                            scopeParameter.IsScopeParamater = true;
#if SILVERLIGHT
                            foreach (ScopeAttribute.EScope scope in EnumHelper.GetValues(typeof(ScopeAttribute.EScope)))
#else
                            foreach (ScopeAttribute.EScope scope in Enum.GetValues(typeof(ScopeAttribute.EScope)))
#endif
                            {
                                if (scope == ScopeAttribute.EScope.None)
                                {
                                    continue;
                                }
                                if (scopeAttribute.Scope.HasFlag(scope))
                                {
                                    publicCommandsByScope.CreateSubCollectionIfNeeded(scope);
                                    publicCommandsByScope[scope].Add(commandDescriptor);
                                }
                            }
                        }
                    }
                    if (commandDescriptor.ScopeProperty == null)
                    {
                        publicCommandsByScope.CreateSubCollectionIfNeeded(ScopeAttribute.EScope.None);
                        publicCommandsByScope[ScopeAttribute.EScope.None].Add(commandDescriptor);
                    }

                    if (commandDescriptor.ScopeProperty != null)
                    {
                        foreach (ParameterDescriptor parameterDescriptor in commandDescriptor.Parameters)
                        {
                            if (parameterDescriptor.ModifiedComponentPropertyName != null)
                            {
                                Type componentType = commandDescriptor.Parameters.First(p => p.IsScopeParamater).ComponentType;
                                parameterDescriptor.ModifiedComponentProperty = componentType.GetProperty(parameterDescriptor.ModifiedComponentPropertyName);
                            }
                        }
                    }
                }
                publicCommandsTypes.Sort(CommandTypeComparer);
            }
        }
コード例 #5
0
ファイル: CommandSerializer.cs プロジェクト: mff-uk/exolutio
        private static XElement SerializeRec(CommandBase command, bool isInitial, bool isUndo, bool isRedo)
        {
            Type commandType = command.GetType();

            XElement commandElement;

            commandElement = new XElement(SERIALIZATION_NS + "Command");
            if (isInitial)
            {
                commandElement.Add(new XAttribute("initial", "true"));
            }
            if (isUndo)
            {
                commandElement.Add(new XAttribute("undo", "true"));
            }
            if (isRedo)
            {
                commandElement.Add(new XAttribute("redo", "true"));
            }

            if (command is PropagationMacroCommand)
            {
                commandElement.Add(new XAttribute("propagation", "true"));
            }

            XAttribute nameAttribute = new XAttribute("Name", commandType.Name);

            commandElement.Add(nameAttribute);

            XElement fullNameElement = new XElement(SERIALIZATION_NS + "FullName");

            fullNameElement.Add(new XText(commandType.FullName));
            commandElement.Add(fullNameElement);

            if (command.Report != null && !string.IsNullOrEmpty(command.Report.Contents))
            {
                XElement report = new XElement(SERIALIZATION_NS + "Report");
                report.Add(new XText(command.Report.Contents));
                commandElement.Add(report);
            }

            #region operation parameters
            if (PublicCommandsHelper.IsPublicCommand(commandType))
            {
                CommandDescriptor commandParametersDescriptors = PublicCommandsHelper.GetCommandDescriptor(commandType);
                if (commandParametersDescriptors.Parameters.Count > 0)
                {
                    XElement parametersElement = new XElement(SERIALIZATION_NS + "Parameters");
                    commandElement.Add(parametersElement);
                    foreach (ParameterDescriptor parameter in commandParametersDescriptors.Parameters)
                    {
                        XElement parameterElement = new XElement(SERIALIZATION_NS + "Parameter");
                        parameterElement.Add(new XElement(SERIALIZATION_NS + "Name", parameter.ParameterName));
                        parameterElement.Add(new XElement(SERIALIZATION_NS + "PropertyName", parameter.ParameterPropertyName));

                        object value = parameter.ParameterPropertyInfo.GetValue(command, new object[0]);
                        if (value is Guid)
                        {
                            string idText = value.ToString();
                            parameterElement.Add(new XElement(SERIALIZATION_NS + "Value", idText));
                            if (command is StackedCommand)
                            {
                                Project        p = ((StackedCommand)command).Controller.Project;
                                ExolutioObject component;
                                if (p.TryTranslateObject((Guid)value, out component))
                                {
                                    parameterElement.Add(new XElement(SERIALIZATION_NS + "ValueText", component.ToString()));
                                }
                            }
                        }
                        else if (value is ExolutioObject)
                        {
                            string idText = ((ExolutioObject)value).ID.ToString();
                            parameterElement.Add(new XElement(SERIALIZATION_NS + "ValueID", idText));
                            parameterElement.Add(new XElement(SERIALIZATION_NS + "ValueText", idText));
                        }
                        else
                        {
                            string valueText = value.ToString();
                            parameterElement.Add(new XElement(SERIALIZATION_NS + "Value", valueText));
                        }
                        parametersElement.Add(parameterElement);
                    }
                }
            }

            #endregion

            if (command is MacroCommand && ((MacroCommand)command).Commands.Count > 0)
            {
                XElement subCommandsElement = new XElement(SERIALIZATION_NS + "SubCommands");
                subCommandsElement.Add(new XAttribute("count", ((MacroCommand)command).Commands.Count));
                commandElement.Add(subCommandsElement);
                foreach (CommandBase subCommand in ((MacroCommand)command).Commands)
                {
                    SerializeRec(subCommand, false, isUndo, isRedo);
                }
            }

            return(commandElement);
        }