public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
        {
            IOInput io = new IOInput();

            io.CardNo  = (CardNo)propertyValues["CardNo"];
            io.AxisNo  = (int)propertyValues["AxisNo"];
            io.InputNo = (InputNo)propertyValues["InputNo"];
            return(io);
        }
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            //将对象转换为字符串
            if ((destinationType == typeof(string)) && value != null && value != null)
            {
                return(((IOInput)value).ToString());
            }

            //生成设计时的构造器代码
            if (destinationType == typeof(InstanceDescriptor) && value != null)
            {
                IOInput         p    = (IOInput)value;
                ConstructorInfo ctor = typeof(IOInput).GetConstructor(new Type[] { typeof(CardNo), typeof(int), typeof(InputNo) });
                return(new InstanceDescriptor(ctor, new object[] { p.CardNo, p.AxisNo, p.InputNo }));
            }

            return(base.ConvertTo(context, culture, value, destinationType));
        }
Example #3
0
        private IOInput GetInput(string name, string match1 = "", string match2 = "")
        {
            Type    cardType = typeof(CardNo);
            IOInput find     = null;

            foreach (CardNo cardNo in Enum.GetValues(cardType))
            {
                find = IODefine.Instance.Inputs[cardNo].Find((input) =>
                {
                    if (input.Text.Contains(name) && input.Text.Contains(match1) && input.Text.Contains(match2))
                    {
                        return(true);
                    }
                    return(false);
                }) as IOInput;
            }

            return(find);
        }
        public void Init()
        {
            if (Inputs.Keys.Count == 0)
            {
                foreach (CardNo cardNo in Enum.GetValues(typeof(CardNo)))
                {
                    this.Inputs.Add(cardNo, new List <IOInput>());
                    for (int i = 0; i < 4; ++i)
                    {
                        foreach (InputNo input in Enum.GetValues(typeof(InputNo)))
                        {
                            var io = new IOInput();
                            io.CardNo  = cardNo;
                            io.AxisNo  = i;
                            io.InputNo = input;
                            io.Name    = $"{cardNo.ToString()}{i}-{input.ToString()}";
                            this.Inputs[cardNo].Add(io);
                        }
                    }
                }
            }

            if (Outputs.Keys.Count == 0)
            {
                foreach (CardNo cardNo in Enum.GetValues(typeof(CardNo)))
                {
                    this.Outputs.Add(cardNo, new List <IOOutput>());
                    for (int i = 0; i < 4; ++i)
                    {
                        foreach (OutputNo ouput in Enum.GetValues(typeof(OutputNo)))
                        {
                            var io = new IOOutput();
                            io.CardNo       = cardNo;
                            io.AxisNo       = i;
                            io.OuputNo      = ouput;
                            io.DefaultState = false;
                            io.Name         = $"{cardNo.ToString()}{i}-{ouput.ToString()}";
                            this.Outputs[cardNo].Add(io);
                        }
                    }
                }
            }

            if (TrackIO.Count == 0)
            {
                foreach (Track track in Enum.GetValues(typeof(Track)))
                {
                    this.TrackIO.Add(track, new TrackIO());
                }
            }

            if (MachineIO.Count == 0)
            {
                foreach (Module module in Enum.GetValues(typeof(Module)))
                {
                    this.MachineIO.Add(module, new MachineIO());

                    foreach (Nozzle nozzle in Enum.GetValues(typeof(Nozzle)))
                    {
                        this.MachineIO[module].VaccumCheck.Add(new IOInput());
                        this.MachineIO[module].VaccumSuck.Add(new IOOutput());
                        this.MachineIO[module].VaccumPO.Add(new IOOutput());
                    }

                    foreach (Feeder feeder in Enum.GetValues(typeof(Feeder)))
                    {
                        this.MachineIO[module].FeederExit.Add(new IOInput());
                        this.MachineIO[module].LabelReach.Add(new IOInput());
                    }
                }
            }
        }
 public BasicIOControl(IOInput io)
 {
     InitializeComponent();
     this.IOProt  = io;
     this.IsInput = true;
 }