Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

DotNet 4.8.1 build of DotNetBar

Browse Source
This commit is contained in:
John Jenko
2025-02-07 10:35:23 -05:00
parent 33439b63a0
commit 6b0a5d60f4
2609 changed files with 989814 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

504
PROMS/DotNetBar Source Code/BindingDef.cs Normal file
View File

@@ -0,0 +1,504 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Windows.Forms;
using System.Globalization;
using System.Drawing;
using System.Security;
using System.Reflection;
using System.Collections;
using System.ComponentModel.Design.Serialization;
namespace DevComponents.DotNetBar
{
/// <summary>
/// Defines class which described single binding.
/// </summary>
[TypeConverter(typeof(BindingDefConverer)), DesignTimeVisible(false), ToolboxItem(false)]
public class BindingDef : INotifyPropertyChanged
{
#region Dependency Properties & Events
public event DataConvertEventHandler Format;
/// <summary>
/// Raises Format event.
/// </summary>
/// <param name="e">Provides event arguments.</param>
protected virtual void OnFormat(DataConvertEventArgs e)
{
DataConvertEventHandler handler = Format;
if (handler != null)
handler(this, e);
}
#endregion
#region Constructor
/// <summary>
/// Initializes a new instance of the BindingDef class.
/// </summary>
public BindingDef()
{
}
/// <summary>
/// Initializes a new instance of the BindingDef class.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="dataMember"></param>
public BindingDef(string propertyName, string dataMember)
{
_PropertyName = propertyName;
_PropertyPath = propertyName.Split('.');
_DataMember = dataMember;
_BindingMemberInfo = new BindingMemberInfo(dataMember);
}
#endregion
#region Implementation
/// <summary>
/// Updates specified item PropertyName with the data from data object property specified by DataMember.
/// </summary>
/// <param name="item">Item to set PropertyName on.</param>
/// <param name="data">Data to retrieve DataMember value from.</param>
public void Update(object item, object data)
{
Update(null, item, data);
}
/// <summary>
/// Updates specified item PropertyName with the data from data object property specified by DataMember.
/// </summary>
/// <param name="dataManager">CurrencyManager to use</param>
/// <param name="item">Item to set PropertyName on.</param>
/// <param name="data">Data to retrieve DataMember value from.</param>
public void Update(ItemVisualGenerator generator, object item, object data)
{
string propertyName = _PropertyName;
if (item is BaseItem && _PropertyPath.Length > 1)
{
// Dig into child items
BaseItem parent = (BaseItem)item;
for (int i = 0; i < _PropertyPath.Length - 1; i++)
{
parent = parent.SubItems[_PropertyPath[i]];
}
item = parent;
propertyName = _PropertyPath[_PropertyPath.Length - 1];
}
PropertyInfo targetProp = item.GetType().GetProperty(propertyName);
if (targetProp.PropertyType == typeof(string))
targetProp.SetValue(item, GetDataText(generator, data, _DataMember), null);
else
targetProp.SetValue(item, GetDataValue(generator, data, _DataMember, GetPropertyValue(generator, data, _DataMember)), null);
}
private static TypeConverter stringTypeConverter;
private string GetDataText(ItemVisualGenerator generator, object data, string fieldName)
{
object propertyValue = GetPropertyValue(generator, data, fieldName);
return GetDataText(generator, data, fieldName, propertyValue);
}
private string GetDataText(ItemVisualGenerator generator, object data, string fieldName, object propertyValue)
{
if (!_FormattingEnabled)
{
if (data == null)
{
return string.Empty;
}
if (propertyValue == null)
{
return "";
}
return Convert.ToString(propertyValue, CultureInfo.CurrentCulture);
}
DataConvertEventArgs e = new DataConvertEventArgs(propertyValue, typeof(string), data, fieldName);
this.OnFormat(e);
if ((e.Value != data) && (e.Value is string))
{
return (string)e.Value;
}
if (stringTypeConverter == null)
{
stringTypeConverter = TypeDescriptor.GetConverter(typeof(string));
}
try
{
return (string)FormatHelper.FormatObject(propertyValue, typeof(string), generator.GetFieldConverter(fieldName), stringTypeConverter, _FormatString, _FormatInfo, null, DBNull.Value);
}
catch (Exception ex)
{
if (ex is SecurityException || IsCriticalException(ex))
{
throw;
}
return ((propertyValue != null) ? Convert.ToString(data, CultureInfo.CurrentCulture) : "");
}
}
private object GetDataValue(ItemVisualGenerator generator, object data, string fieldName, object propertyValue)
{
if (!_FormattingEnabled)
{
return propertyValue;
}
DataConvertEventArgs e = new DataConvertEventArgs(propertyValue, typeof(object), data, fieldName);
this.OnFormat(e);
return e.Value;
}
private static bool IsCriticalException(Exception ex)
{
return (((((ex is NullReferenceException) || (ex is StackOverflowException)) || ((ex is OutOfMemoryException) || (ex is System.Threading.ThreadAbortException))) || ((ex is ExecutionEngineException) || (ex is IndexOutOfRangeException))) || (ex is AccessViolationException));
}
private object GetPropertyValue(ItemVisualGenerator generator, object data, string fieldName)
{
if ((data != null) && (fieldName.Length > 0))
{
try
{
PropertyDescriptor descriptor = null;
if (generator.DataManager != null)
{
descriptor = generator.DataManager.GetItemProperties().Find(fieldName, true);
}
if(descriptor == null)
{
descriptor = TypeDescriptor.GetProperties(data).Find(fieldName, true);
}
if (descriptor != null)
{
data = descriptor.GetValue(data);
}
}
catch
{
}
}
if (data == DBNull.Value && _NullValue != null)
return _NullValue;
return data;
}
#endregion
#region Properties
private string[] _PropertyPath = new string[0];
private string _PropertyName = "";
/// <summary>
/// Gets or sets the property name binding is attached to.
/// </summary>
[DefaultValue(""), Category("Data"), Description("Indicates property name binding is attached to.")]
public string PropertyName
{
get { return _PropertyName; }
set
{
if (value != _PropertyName)
{
string oldValue = _PropertyName;
_PropertyName = value;
OnPropertyNameChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when PropertyName property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnPropertyNameChanged(string oldValue, string newValue)
{
_PropertyPath = newValue.Split('.');
OnPropertyChanged(new PropertyChangedEventArgs("PropertyName"));
}
/// <summary>
/// Gets the reference to BindingMemberInfo created based on DataMember.
/// </summary>
[Browsable(false)]
public BindingMemberInfo BindingMemberInfo
{
get
{
return _BindingMemberInfo;
}
}
private BindingMemberInfo _BindingMemberInfo;
private string _DataMember = "";
/// <summary>
/// Gets or sets the data member name which holds data that PropertyName is populated with.
/// </summary>
[DefaultValue(""), Category("Data"), Description("Indicates data member name which holds data that PropertyName is populated with.")]
public string DataMember
{
get { return _DataMember; }
set
{
if (value == null) value = "";
if (value != _DataMember)
{
string oldValue = _DataMember;
_DataMember = value;
OnDataMemberChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when DataMember property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnDataMemberChanged(string oldValue, string newValue)
{
if (!string.IsNullOrEmpty(newValue))
_BindingMemberInfo = new BindingMemberInfo(newValue);
else
_BindingMemberInfo = new BindingMemberInfo();
OnPropertyChanged(new PropertyChangedEventArgs("DataMember"));
}
private bool _FormattingEnabled = false;
/// <summary>
/// Gets or sets whether type conversion and formatting is applied to the property data.
/// </summary>
[DefaultValue(false), Category("Data"), Description("Indicates whether type conversion and formatting is applied to the property data.")]
public bool FormattingEnabled
{
get { return _FormattingEnabled; }
set
{
if (value != _FormattingEnabled)
{
bool oldValue = _FormattingEnabled;
_FormattingEnabled = value;
OnFormattingEnabledChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when FormattingEnabled property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnFormattingEnabledChanged(bool oldValue, bool newValue)
{
OnPropertyChanged(new PropertyChangedEventArgs("FormattingEnabled"));
}
private string _FormatString = "";
/// <summary>
/// Gets or sets format specifier characters that indicate how a value is to be displayed.
/// For more information, see Formatting Overview: http://msdn.microsoft.com/en-us/library/26etazsy%28v=vs.71%29.aspx
/// </summary>
[DefaultValue(""), Category("Data"), Description("Indicates format specifier characters that indicate how a value is to be displayed.")]
public string FormatString
{
get { return _FormatString; }
set
{
if (value != _FormatString)
{
string oldValue = _FormatString;
_FormatString = value;
OnFormatStringChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when FormatString property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnFormatStringChanged(string oldValue, string newValue)
{
OnPropertyChanged(new PropertyChangedEventArgs("FormatString"));
}
private IFormatProvider _FormatInfo = null;
/// <summary>
/// Gets or sets the IFormatProvider that provides custom formatting behavior.
/// </summary>
[DefaultValue(null), Category("Data"), Description("Indicates IFormatProvider that provides custom formatting behavior.")]
public IFormatProvider FormatInfo
{
get { return _FormatInfo; }
set
{
if (value != _FormatInfo)
{
IFormatProvider oldValue = _FormatInfo;
_FormatInfo = value;
OnFormatInfoChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when FormatInfo property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnFormatInfoChanged(IFormatProvider oldValue, IFormatProvider newValue)
{
OnPropertyChanged(new PropertyChangedEventArgs("FormatInfo"));
}
private object _NullValue = null;
/// <summary>
/// Gets or sets the Object to be set as the target property when the data source contains a DBNull value.
/// The data source must contain DBNull for the NullValue property to be correctly applied.
/// If the data source type is a type such as a string or integer the value of the NullValue property will be ignored.
/// Also, the NullValue property is ignored if it is set to null.
/// </summary>
[DefaultValue(null), Category("Data"), Description("Indicates Object to be set as the control property when the data source contains a DBNull value. ")]
[System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter))]
public object NullValue
{
get { return _NullValue; }
set
{
if (value != _NullValue)
{
object oldValue = _NullValue;
_NullValue = value;
OnNullValueChanged(oldValue, value);
}
}
}
/// <summary>
/// Called when NullValue property has changed.
/// </summary>
/// <param name="oldValue">Old property value</param>
/// <param name="newValue">New property value</param>
protected virtual void OnNullValueChanged(object oldValue, object newValue)
{
OnPropertyChanged(new PropertyChangedEventArgs("NullValue"));
}
#endregion
#region INotifyPropertyChanged Members
/// <summary>
/// Raises the PropertyChanged event.
/// </summary>
/// <param name="e">Provides event arguments.</param>
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null) handler(this, e);
}
/// <summary>
/// Occurs when property on BindingDef object has changed.
/// </summary>
[Description("Occurs when property on BindingDef object has changed.Occurs when property on BindingDef object has changed.")]
public event PropertyChangedEventHandler PropertyChanged;
#endregion
}
/// <summary>
/// Represents the method that will handle converting for bindings.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public delegate void DataConvertEventHandler(object sender, DataConvertEventArgs e);
public class DataConvertEventArgs : ConvertEventArgs
{
// Fields
private object _DataItem;
// Methods
public DataConvertEventArgs(object value, Type desiredType, object dataItem, string fieldName)
: base(value, desiredType)
{
_DataItem = dataItem;
_FieldName = fieldName;
}
/// <summary>
/// Gets the reference to the item being converted.
/// </summary>
public object DataItem
{
get
{
return _DataItem;
}
}
private string _FieldName = "";
/// <summary>
/// Get the reference to the name of the field or property on the item that needs conversion.
/// </summary>
public string FieldName
{
get { return _FieldName; }
}
}
/// <summary>
/// Represents BindingDefConverer converter.
/// </summary>
public class BindingDefConverer : TypeConverter
{
/// <summary>
/// Creates new instance of the class.
/// </summary>
public BindingDefConverer() { }
/// <summary>
/// Checks whether conversion can be made to specified type.
/// </summary>
/// <param name="context">Context Information.</param>
/// <param name="destinationType">Destination type.</param>
/// <returns></returns>
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
return true;
return base.CanConvertTo(context, destinationType);
}
/// <summary>
/// Converts object to specified type.
/// </summary>
/// <param name="context">Context information.</param>
/// <param name="culture">Culture information.</param>
/// <param name="value">Object to convert.</param>
/// <param name="destinationType">Destination type.</param>
/// <returns>Object converted to destination type.</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
throw new ArgumentNullException("destinationType");
if ((destinationType == typeof(InstanceDescriptor)) && (value is BindingDef))
{
BindingDef info = (BindingDef)value;
Type[] constructorParams = null;
MemberInfo constructorMemberInfo = null;
object[] constructorValues = null;
constructorParams = new Type[] { typeof(string), typeof(string) };
constructorMemberInfo = typeof(BindingDef).GetConstructor(constructorParams);
constructorValues = new object[] { info.PropertyName, info.DataMember };
if (constructorMemberInfo != null)
{
return new InstanceDescriptor(constructorMemberInfo, constructorValues);
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
}