private static int AutoWidth(Field field)
{
var name = field.Name;
switch (field.Type)
{
case FieldType.String:
if (field.Size != 0 && field.Size <= 25)
return Math.Max(field.Size * 6, 150);
else if (field.Size == 0)
return 250;
else
return 150;
case FieldType.Boolean:
return 40;
case FieldType.DateTime:
return 85;
case FieldType.Time:
return 70;
case FieldType.Int16:
return 55;
case FieldType.Int32:
return 65;
case FieldType.Single:
case FieldType.Double:
case FieldType.Decimal:
return 85;
default:
return 80;
}
}
private static string AutoDetermineIdField(Field basedOnField)
{
if (ReferenceEquals(null, basedOnField))
return null;
Field idField;
if (basedOnField.Join == null && (basedOnField.ReferencedAliases == null || basedOnField.ReferencedAliases.Count != 1))
return null;
if (basedOnField.Join == null)
{
idField = basedOnField.Fields.FirstOrDefault(x => x.ForeignJoinAlias != null &&
(x.TextualField == basedOnField.PropertyName ||
x.TextualField == basedOnField.Name));
}
else
{
var joinName = basedOnField.Join != null ? basedOnField.Join.Name : basedOnField.ReferencedAliases.Single();
idField = basedOnField.Fields.FirstOrDefault(x => x.ForeignJoinAlias != null &&
x.ForeignJoinAlias.Name == joinName);
}
return ReferenceEquals(null, idField) ? null : (idField.PropertyName ?? idField.Name);
}
internal void RaisePropertyChanged(Field field)
{
if (fields.propertyChangedEventArgs == null)
{
var args = new PropertyChangedEventArgs[fields.Count + 1];
for (var i = 0; i < fields.Count; i++)
{
var f = fields[i];
args[i] = new PropertyChangedEventArgs(f.propertyName ?? f.Name);
}
args[fields.Count] = new PropertyChangedEventArgs("__ROW__");
fields.propertyChangedEventArgs = args;
}
if (ReferenceEquals(null, field))
propertyChanged(this, fields.propertyChangedEventArgs[fields.Count]);
else
propertyChanged(this, fields.propertyChangedEventArgs[field.Index]);
}
public void ClearAssignment(Field field)
{
if (assignedFields == null)
return;
assignedFields[field.index] = false;
for (var i = 0; i < assignedFields.Length; i++)
if (assignedFields[i])
return;
assignedFields = null;
}
public bool IsAssigned(Field field)
{
if (assignedFields == null)
return false;
return assignedFields[field.index];
}
internal void FieldAssignedValue(Field field)
{
if (assignedFields == null)
assignedFields = new bool[fields.Count];
assignedFields[field.index] = true;
if (validationErrors != null)
RemoveValidationError(field.PropertyName ?? field.Name);
if (propertyChanged != null)
{
if (field.IndexCompare(previousValues, this) != 0)
{
RaisePropertyChanged(field);
field.Copy(this, previousValues);
}
}
}
public bool IsFieldChanged(Field field)
{
return (originalValues != null &&
field.IndexCompare(originalValues, this) != 0);
}
public static PropertyItem GetCustomFieldPropertyItem(ICustomFieldDefinition definition, Field basedOnField)
{
var pi = new PropertyItem();
pi.Name = !ReferenceEquals(null, basedOnField) ? (basedOnField.PropertyName ?? basedOnField.Name) : definition.Name;
pi.Category = definition.Category.TrimToNull();
pi.ReadOnly = false;
pi.Title = !ReferenceEquals(null, basedOnField) ? basedOnField.Title : definition.Title;
pi.DefaultValue = definition.DefaultValue;
pi.Insertable = ReferenceEquals(null, basedOnField) || ((basedOnField.Flags & FieldFlags.Insertable) == FieldFlags.Insertable);
pi.Updatable = ReferenceEquals(null, basedOnField) || ((basedOnField.Flags & FieldFlags.Updatable) == FieldFlags.Updatable);
pi.Localizable = definition.IsLocalizable;
Type enumType = null;
if (!ReferenceEquals(null, basedOnField) && basedOnField is IEnumTypeField)
{
enumType = (basedOnField as IEnumTypeField).EnumType;
if (enumType != null && !enumType.IsEnum)
enumType = null;
}
if (!definition.EditorType.IsTrimmedEmpty())
{
pi.EditorType = definition.EditorType.TrimToNull();
}
else
{
if (enumType != null)
pi.EditorType = "Enum";
else if (definition.FieldType == CustomFieldType.Date ||
definition.FieldType == CustomFieldType.DateTime)
pi.EditorType = "Date";
else if (definition.FieldType == CustomFieldType.Boolean)
pi.EditorType = "Boolean";
else if (definition.FieldType == CustomFieldType.Decimal)
pi.EditorType = "Decimal";
else if (definition.FieldType == CustomFieldType.Int32 || definition.FieldType == CustomFieldType.Int64)
pi.EditorType = "Integer";
else
pi.EditorType = "String";
}
if (enumType != null)
{
pi.EditorParams["enumKey"] = EnumMapper.GetEnumTypeKey(enumType);
}
if (!ReferenceEquals(null, basedOnField))
{
if (basedOnField is StringField &&
basedOnField.Size > 0)
{
pi.EditorParams["maxLength"] = basedOnField.Size;
pi.MaxLength = basedOnField.Size;
}
if ((basedOnField.Flags & FieldFlags.NotNull) == FieldFlags.NotNull)
pi.Required = true;
}
if (definition.IsRequired)
pi.Required = true;
if (definition.Size != 0 &&
definition.FieldType == CustomFieldType.String)
{
pi.MaxLength = definition.Size;
pi.EditorParams["maxLength"] = definition.Size;
}
var editorOptionsJson = definition.EditorOptions.TrimToNull();
if (editorOptionsJson != null &&
editorOptionsJson.StartsWith("{"))
{
var editorOptions = JsonConvert.DeserializeObject<Dictionary<string, object>>(editorOptionsJson, JsonSettings.Tolerant);
foreach (var option in editorOptions)
pi.EditorParams[option.Key] = option.Value;
}
return pi;
}
public static Type GetEnumType(Field field)
{
var fint32 = field as IEnumTypeField;
if (fint32 != null &&
fint32.EnumType != null &&
fint32.EnumType.IsEnum)
{
return fint32.EnumType;
}
return null;
}
internal FieldDescriptor(Field field)
: base(field.PropertyName ?? field.Name, null)
{
_field = field;
}