public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { base.SetupField(attr, fieldinfo); //mxd. We don't want to store this type index = (int)UniversalType.Float; }
// When set up for a universal field public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { base.SetupField(attr, fieldinfo); // Create enum list reference list = CreateEnumList(); }
// When set up for an argument public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { base.SetupArgument(attr, arginfo); // Keep enum list reference list = arginfo.Enum; }
public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { base.SetupArgument(attr, arginfo); //mxd. We don't want to store this type index = (int)UniversalType.Float; }
// When set up for a universal field public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { base.SetupField(attr, fieldinfo); // Keep enum list reference list = (fieldinfo != null ? fieldinfo.Enum : new EnumList()); }
// When set up for an argument public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { base.SetupArgument(attr, arginfo); // Keep flags list reference flags = arginfo.Flags; }
// Constructor public TypesManager() { // Initialize handlertypes = new Dictionary <int, TypeHandlerAttribute>(); // Go for all types in this assembly Type[] types = General.ThisAssembly.GetTypes(); foreach (Type tp in types) { // Check if this type is a class if (tp.IsClass && !tp.IsAbstract && !tp.IsArray) { // Check if class has an TypeHandler attribute if (Attribute.IsDefined(tp, typeof(TypeHandlerAttribute), false)) { // Add the type to the list object[] attribs = tp.GetCustomAttributes(typeof(TypeHandlerAttribute), false); TypeHandlerAttribute attr = (attribs[0] as TypeHandlerAttribute); attr.Type = tp; handlertypes.Add(attr.Index, attr); } } } // We have no destructor GC.SuppressFinalize(this); }
// When set up for an argument public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { defaultvalue = new EnumItem(arginfo.DefaultValue.ToString(), arginfo.DefaultValue.ToString()); //mxd base.SetupArgument(attr, arginfo); // Keep enum list reference list = arginfo.Enum; }
// When set up for a universal field public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { defaultvalue = (fieldinfo != null ? new EnumItem(fieldinfo.Default.ToString(), fieldinfo.Default.ToString()) : new EnumItem("0", "0")); //mxd base.SetupField(attr, fieldinfo); // Create enum list reference list = CreateEnumList(); }
// When set up for an argument public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { defaultvalue = (int)arginfo.DefaultValue;//mxd base.SetupArgument(attr, arginfo); // Keep enum list reference list = arginfo.Enum; }
public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { defaultvalue = (int)arginfo.DefaultValue; base.SetupArgument(attr, arginfo); //mxd. We don't want to store this type index = (int)UniversalType.Integer; }
public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { defaultvalue = (fieldinfo != null ? (int)fieldinfo.Default : 0); //mxd base.SetupField(attr, fieldinfo); //mxd. We don't want to store this type index = (int)UniversalType.Integer; }
// When set up for an argument public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { defaultvalue = new EnumItem("0", "0"); base.SetupArgument(attr, arginfo); // Create enum list reference list = CreateEnumList(); // Add default value list.Insert(0, defaultvalue); }
// When set up for a universal field public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { base.SetupField(attr, fieldinfo); // Keep enum list reference if (fieldinfo != null) { list = fieldinfo.Enum; } else { list = new EnumList(); } }
// This returns the type handler for the given argument public TypeHandler GetArgumentHandler(ArgumentInfo arginfo) { Type t = typeof(NullHandler); TypeHandlerAttribute ta = null; // Do we have a handler type for this? if (handlertypes.ContainsKey(arginfo.Type)) { ta = handlertypes[arginfo.Type]; t = ta.Type; } // Create instance TypeHandler th = (TypeHandler)General.ThisAssembly.CreateInstance(t.FullName); th.SetupArgument(ta, arginfo); return(th); }
// This returns the type handler for a custom universal field public TypeHandler GetFieldHandler(int type, object defaultsetting) { Type t = typeof(NullHandler); TypeHandlerAttribute ta = null; // Do we have a handler type for this? if (handlertypes.ContainsKey(type)) { ta = handlertypes[type]; t = ta.Type; } // Create instance TypeHandler th = (TypeHandler)General.ThisAssembly.CreateInstance(t.FullName); th.SetupField(ta, null); th.SetValue(defaultsetting); return(th); }
// This returns the type handler for a given universal field public TypeHandler GetFieldHandler(UniversalFieldInfo fieldinfo) { Type t = typeof(NullHandler); TypeHandlerAttribute ta = null; // Do we have a handler type for this? if (handlertypes.ContainsKey(fieldinfo.Type)) { ta = handlertypes[fieldinfo.Type]; t = ta.Type; } // Create instance TypeHandler th = (TypeHandler)General.ThisAssembly.CreateInstance(t.FullName); th.SetupField(ta, fieldinfo); th.SetValue(fieldinfo.Default); return(th); }
// This sets up the handler for arguments public virtual void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo) { // Setup this.forargument = false; if (attr != null) { // Set attributes this.attribute = attr; this.index = attr.Index; this.typename = attr.Name; this.customusable = attr.IsCustomUsable; } else { // Indexless this.attribute = null; this.index = -1; this.typename = "Unknown"; this.customusable = false; } }
// This sets up the handler for arguments public virtual void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { // Setup this.forargument = true; this.arginfo = arginfo; if (attr != null) { // Set attributes this.attribute = attr; this.index = attr.Index; this.typename = attr.Name; this.customusable = attr.IsCustomUsable; } else { // Indexless this.attribute = null; this.index = -1; this.typename = "Unknown"; this.customusable = false; } }
private int defaultvalue; //mxd #endregion #region ================== Properties #endregion #region ================== Methods //mxd public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo) { defaultvalue = (int)arginfo.DefaultValue; base.SetupArgument(attr, arginfo); }