/// <summary>
/// Bind to a command when the TargetProperty is known
/// </summary>
/// <param name="control"></param>
/// <param name="bindingOptions"></param>
/// <param name="targetPropertyName"></param>
public void ExecuteCommandBind(IBindingTarget control, Options bindingOptions, string targetPropertyName)
{
BindingDef binding = new BindingDef(control, targetPropertyName, bindingOptions, controlService);
CommandStorage.Add(binding);
ExecuteCommandBind(control, binding);
}
public bool TryGetTargetPropertyName(IBindingTarget target, Options options, out string targetPropertyName)
{
targetPropertyName = string.Empty;
try
{
//get method body
StackFrame frame = GetBindingFrame();
string methodName = frame.GetMethod().Name;
if (!this.SequenceManager.Sequences.Keys.Contains(methodName))
{
this.SequenceManager.Sequences.Add(methodName, new BindingSequnce()
{
Instructions = GetBindingInstructionSets(frame)
});
}
else
{
this.SequenceManager.Sequences[methodName].MoveNext();
}
targetPropertyName = this.SequenceManager.Sequences[methodName].CurrentInstruction.GetAssignedProperty();
}
catch (Exception exp)
{
Logger.Trace(exp);
}
return(!string.IsNullOrEmpty(targetPropertyName));
}
public static void To <T, TP>(this IBindingTarget target, T model, Expression <Func <T, TP> > action)
where T : class
{
var expr = (MemberExpression)action.Body;
target.Control.DataBindings.Add(target.PropertyName, model, expr.Member.Name);
}
public void Connect(Gtk.Widget widget, Object source, IBindingTarget target)
{
if (source == null)
{
mSource = BindingEngine.GetViewModel(widget);
if (mSource == null)
{
Console.WriteLine("Binding.Connect: ViewModel not set for this widget");
return;
}
}
else
{
mSource = source;
}
mTarget = target;
var propertyChanged = mSource as IPropertyChanged;
if (propertyChanged != null)
{
propertyChanged.PropertyChanged += (object sender, PropertyChangedEventArgs e) => mTarget.Update(this, GetSourceValue());
}
}
/// <summary>
/// Sets the current target.
/// </summary>
/// <remarks>
/// This will clear current hierarchy and regenerate a new one.
/// </remarks>
/// <param name="target">The target to set.</param>
/// <typeparam name="T">The type of the target.</typeparam>
public void SetTarget <T>(T target)
{
if (TryGetTarget(out T current) && current.Equals(target))
{
// Nothing to do..
return;
}
if (null != m_BindingTarget)
{
var type = typeof(T);
if (typeof(T).IsClass && null != target)
{
type = target.GetType();
}
if (type == m_BindingTarget.TargetType)
{
(m_BindingTarget as BindingTarget <T>).Target = target;
return;
}
}
m_BindingTarget?.Release();
if (typeof(T).IsClass && null == target)
{
m_BindingTarget = null;
return;
}
m_BindingTarget = new BindingTarget <T>(this, target);
name = target.GetType().Name;
m_BindingTarget.GenerateHierarchy();
}
private bool DetermineIfCollection(IBindingTarget control, object value)
{
if (value is IEnumerable && !(value is string))
{
return(true);
}
return(false);
}
/// <summary>
/// Used to create a command binding
/// </summary>
/// <param name="sourceExpression"></param>
/// <param name="targetExpression"></param>
/// <param name="containerID"></param>
public BindingDef(IBindingTarget targetControl, string targetPropertyName, Options bindingOptions, IControlService controlService)
{
this.controlService = controlService;
this.sourceExpression = new BindingPath(bindingOptions.Path);
string targetExpression = string.Format("{0}.{1}", targetControl.UniqueID, targetPropertyName);
this.targetExpression = new BindingPath(targetExpression);
}
/// <summary>
/// Bind to a command with auto resolution of the TargetProperty
/// </summary>
/// <param name="sourceExpression"></param>
/// <param name="targetExpression"></param>
public void ExecuteCommandBind(IBindingTarget control, Options bindingOptions)
{
string propertyName = string.Empty;
if (controlService.TryGetTargetPropertyName(control, bindingOptions, out propertyName))
{
ExecuteCommandBind(control, bindingOptions, propertyName);
}
}
private object AttemptConvert(BindingDef binding, object value, IBindingTarget container)
{
if (binding.HasValueConverter)
{
IValueConverter converter = binding.GetValueConverterInstance();
value = converter.Convert(value, binding.ResolveAsTarget(container).Descriptor.PropertyType, binding, CultureInfo.CurrentCulture);
}
return(value);
}
public IEnumerable GetChildren(IBindingTarget parent)
{
Control ctrl = Resolve(parent);
if (ctrl == null)
{
throw new ArgumentException("parent must be of type System.Web.UI.Control in order for its children to be resolved by this service", "parent");
}
return(ctrl.Controls);
}
public IBindingTarget GetParent(IBindingTarget child)
{
Control ctrl = Resolve(child);
if (ctrl == null)
{
throw new ArgumentException("child must be of type System.Web.UI.Control in order for its parent to be resolved by this service", "child");
}
return(new WebformControl(ctrl.Parent));
}
internal Component(Type type,
ILiftTimeScope liftTimeScope,
string name,
IBindingTarget bingingTarget
)
{
this.target = type;
this.name = name;
this.bingingTarget = bingingTarget;
this.liftTimeScope = liftTimeScope;
}
/// <summary>
/// Execute a bind in the context of a collection container.
/// </summary>
/// <remarks>
/// This method will attempt to auto resolve the property of the target control to which to
/// bind. The implementation of this resolution can be control via IControlService.TryGetTargetPropertyName.
/// </remarks>
/// <param name="control">The target control</param>
/// <param name="collectionItemContainer">
/// The collection item container. E.g. In the case of a repeater a RepeaterItem.
/// This is available from the ItemTemplate control via (IDataItemContainer)container.NamingContainer.
/// </param>
/// <param name="bindingOptions"></param>
/// <returns>The result (value) of the bind</returns>
public object ExecuteBind(IBindingTarget control, IBindingTarget <IDataItemContainer> collectionItemContainer, Options bindingOptions)
{
string propertyName = string.Empty;
object value = null;
if (controlService.TryGetTargetPropertyName(control, bindingOptions, out propertyName))
{
value = ExecuteBind(control, collectionItemContainer, bindingOptions, propertyName);
}
return(value);
}
/// <summary>
/// Used to create a data binding
/// </summary>
/// <param name="targetControl">The control to which to bind</param>
/// <param name="targetPropertyName">The property of the control to which to bind</param>
/// <param name="bindingOptions">Options to control the binding</param>
/// <param name="isSourceEnumerable">Is the datasource to which you are binidng a collection</param>
/// <param name="controlService">Service required for binding</param>
public BindingDef(IBindingTarget targetControl, string targetPropertyName, Options bindingOptions, bool isSourceEnumerable, IControlService controlService)
{
this.controlService = controlService;
this.Container = targetControl;
this.sourceExpression = new BindingPath(bindingOptions.Path);
string targetExpression = string.Format("{0}.{1}", targetControl.UniqueID, targetPropertyName);
this.targetExpression = new BindingPath(targetExpression);
this.bindingOptions = bindingOptions;
this.IsSourceEnumerable = isSourceEnumerable;
}
public TargetEvent ResolveAsTargetEvent(IBindingTarget container, IControlService controlService)
{
string[] targetExpressionSplit = this.Raw.Split('.');
IBindingTarget control = controlService.FindControlUnique(container, targetExpressionSplit[0]);
object rawControl = controlService.Unwrap(control);
EventInfo info = rawControl.GetType().GetEvent(targetExpressionSplit[1]);
return(new TargetEvent {
OwningControl = rawControl, Descriptor = info
});
}
public static Binding GetOrCreateBinding(Gtk.Widget widget, Object source, IBindingTarget target, BindingInfo info)
{
Binding result = null;
if (!mBindings.TryGetValue(target, out result))
{
result = new Binding();
result.Info = info;
result.Connect(widget, source, target);
mBindings[target] = result;
}
return(result);
}
private BindingMode DetermineBindingDirection(IBindingTarget control, object value)
{
if (control == null)
{
return(BindingMode.Unsupported);
}
//String are IEnumerable!
if (DetermineIfCollection(control, value))
{
return(BindingMode.OneWay);
}
return(BindingMode.TwoWay);
}
private Control Resolve(IBindingTarget iTarget)
{
Control target = iTarget as Control;
if (target == null)
{
WebformControl webformControl = iTarget as WebformControl;
if (webformControl != null)
{
target = webformControl.Control;
}
}
return(target);
}
/// <summary>
/// Used to create a nested data binding
/// </summary>
/// <param name="targetControl">The control to which to bind</param>
/// <param name="targetPropertyName">The property of the control to which to bind</param>
/// <param name="dataItemIndex">If the parent binding is a collection, the index is the data item for this binding. Else zerp</param>
/// <param name="owningCollection">The collection of current bindings</param>
/// <param name="bindingOptions">Options to control the binding</param>
/// <param name="isSourceEnumerable">Is the datasource to which you are binidng a collection</param>
/// <param name="controlService">Service required for binding</param>
public BindingDef(IBindingTarget targetControl, string targetPropertyName, int dataItemIndex, BindingCollection owningCollection, Options bindingOptions, bool isSourceEnumerable, IControlService controlService)
{
this.controlService = controlService;
this.Container = targetControl;
this.TrySetParent(owningCollection);
this.sourceExpression = new BindingPath(bindingOptions.Path, dataItemIndex, GetParentExpression(), bindingOptions.PathMode);
string targetExpression = string.Format("{0}.{1}", targetControl.UniqueID, targetPropertyName);
this.targetExpression = new BindingPath(targetExpression);
this.DataItemIndex = dataItemIndex;
this.bindingOptions = bindingOptions;
this.IsSourceEnumerable = isSourceEnumerable;
}
/// <inheritdoc />
public async Task Apply(IBindingTarget target)
{
if (!bindingInfo.IsObsolete)
{
switch (bindingInfo.BindingTargetMode)
{
case BindingTargetMode.Default:
if (bindingInfo.QueueInfo.QueueType == QueueType.Dynamic)
{
QueueName = await target.BindDynamic(bindingInfo.MessageClass, bindingInfo.QueueInfo.Name);
}
else
{
await target.BindDurable(bindingInfo.MessageClass, bindingInfo.QueueInfo.Name);
QueueName = bindingInfo.QueueInfo.Name;
}
break;
case BindingTargetMode.Direct:
if (bindingInfo.QueueInfo.QueueType == QueueType.Dynamic)
{
QueueName = await target.BindDynamicDirect(bindingInfo.MessageClass, bindingInfo.QueueInfo.Name);
}
else
{
await target.BindDurableDirect(bindingInfo.QueueInfo.Name);
QueueName = bindingInfo.QueueInfo.Name;
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(bindingInfo.BindingTargetMode), bindingInfo.BindingTargetMode, "Invalid BindingTargetMode");
}
}
else if (bindingInfo.QueueInfo.QueueType == QueueType.Durable)
{
await target.BindDurableObsolete(bindingInfo.QueueInfo.Name);
QueueName = bindingInfo.QueueInfo.Name;
}
}
private bool TrySetParent(BindingDef lastBinding)
{
if (lastBinding != null)
{
//test if the current binding is a child of the previous datacontainer
IBindingTarget child = controlService.FindControlUnique(lastBinding.Container, this.Container.UniqueID);
if (child != null)
{
this.Parent = lastBinding;
}
else if (lastBinding.Parent != null)
{
TrySetParent(lastBinding.Parent);
}
}
return(this.Parent != null);
}
public void Connect(Gtk.Widget widget, Object source, IBindingTarget target)
{
if (source == null) {
mSource = BindingEngine.GetViewModel(widget);
if (mSource == null) {
Console.WriteLine("Binding.Connect: ViewModel not set for this widget");
return;
}
} else {
mSource = source;
}
mTarget = target;
var propertyChanged = mSource as IPropertyChanged;
if (propertyChanged != null) {
propertyChanged.PropertyChanged += (object sender, PropertyChangedEventArgs e) => mTarget.Update(this, GetSourceValue());
}
}
public IBindingTarget FindControlUnique(IBindingTarget root, string unique)
{
if (root.UniqueID == unique)
{
return(root);
}
foreach (Control ctl in this.GetChildren(root))
{
IBindingTarget webFormControl = new WebformControl(ctl);
IBindingTarget foundCtl = FindControlUnique(webFormControl, unique);
if (foundCtl != null)
{
return(foundCtl);
}
}
return(null);
}
public IBindingTarget FindControlRecursive(IBindingTarget root, string id)
{
if (root.ID == id)
{
return(root);
}
foreach (Control ctl in this.GetChildren(root))
{
IBindingTarget webFormControl = new WebformControl(ctl);
IBindingTarget foundCtl = FindControlRecursive(webFormControl, id);
if (foundCtl != null)
{
return(foundCtl);
}
}
return(null);
}
public TargetProperty ResolveAsTarget(IBindingTarget container, IControlService controlService)
{
string[] targetExpressionSplit = this.Raw.Split('.');
IBindingTarget control = controlService.FindControlUnique(container, targetExpressionSplit[0]);
object rawControl = controlService.Unwrap(control);
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(rawControl).Find(targetExpressionSplit[1], true);
object value = null;
if (descriptor != null)
{
value = descriptor.GetValue(rawControl);
}
return(new TargetProperty {
Descriptor = descriptor, OwningControlRaw = rawControl, OwningControl = control, Value = value
});
}
protected override void OnInit(EventArgs e)
{
IBindingTarget page = this.Page as IBindingTarget;
if (page == null)
{
throw new InvalidOperationException("This control can only be used on pages that implement IBindingTarget");
}
WebformsControlService controlService = new WebformsControlService();
IBindingTarget ctrl = controlService.FindControlRecursive(page, this.GetType());
if (ctrl != null && ctrl.UniqueID != this.UniqueID)
{
throw new InvalidOperationException("Only one control of type BindingOptions can appear of each page");
}
base.OnInit(e);
}
private void ExecuteCommandBind(IBindingTarget control, BindingDef binding)
{
//Get the ICommandObject from the source
SourceProperty commandInstance = binding.SourceExpression.ResolveAsSource(this.DataContext);
object commandObject = commandInstance.Value;
ICommand iCommand = commandObject as ICommand;
//Get the property setter for the event to which we will bind
TargetEvent evt = binding.ResolveAsTargetEvent(this.bindingContainer);
//bind
Type eventDelegateType = evt.Descriptor.EventHandlerType;
Delegate handler = new EventHandler((s, e) => iCommand.Execute(this));
evt.Descriptor.GetAddMethod().Invoke(evt.OwningControl, new object[] { handler });
control.Visible = iCommand.CanExecute(this);
//listen to canExecuteChanged
iCommand.CanExecuteChanged += new EventHandler((s, e) => control.Visible = iCommand.CanExecute(this));
}
public IBindingTarget FindControlRecursive(IBindingTarget root, Type type)
{
Control resolvedRoot = Resolve(root);
if (resolvedRoot.GetType() == type)
{
return(root);
}
foreach (Control ctl in this.GetChildren(root))
{
IBindingTarget webFormControl = new WebformControl(ctl);
IBindingTarget foundCtl = FindControlRecursive(webFormControl, type);
if (foundCtl != null)
{
return(foundCtl);
}
}
return(null);
}
public object Unwrap(IBindingTarget bindingTarget)
{
if (bindingTarget == null)
{
throw new ArgumentException("Cannot unwrap null object", "bindingTarget");
}
WebformControl webControl = bindingTarget as WebformControl;
if (webControl == null)
{
throw new ArgumentException(string.Format("Unable to unwrap objects of type {0}", bindingTarget.GetType().FullName), "bindingTarget");
}
if (webControl.Control == null)
{
throw new ArgumentException("Unwrapped object is null", "bindingTarget");
}
return(webControl.Control);
}
/// <summary>
/// Execute a bind in the context of a collection container.
/// </summary>
/// <remarks>
/// Specficy the target control directly.
/// </remarks>
/// <param name="control">The target control</param>
/// <param name="collectionItemContainer">
/// The collection item container. E.g. In the case of a repeater a RepeaterItem.
/// This is available from the ItemTemplate control via (IDataItemContainer)container.NamingContainer.
/// </param>
///<param name="targetPropertyName">The property on the targetcontrol.</param>
/// <param name="bindingOptions"></param>
/// <returns>The result (value) of the bind</returns>
public object ExecuteBind(IBindingTarget control, IBindingTarget <IDataItemContainer> collectionItemContainer, Options bindingOptions, string targetPropertyName)
{
if (control == null || bindingContainer == null || bindingOptions == null || string.IsNullOrEmpty(bindingOptions.Path))
{
return(null);
}
object dataValue = null;
BindingDef binding = null;
IBindingTarget genericContainer = null;
object baseContext = this.DataContext;
if (bindingOptions.PathMode == PathMode.Relative && collectionItemContainer != null)
{
IDataItemContainer containerControl = collectionItemContainer.TargetInstance;
dataValue = DataBinder.Eval(containerControl.DataItem, bindingOptions.Path);
bool isCollectionBinding = DetermineIfCollection(control, dataValue);
binding = new BindingDef(control, targetPropertyName, containerControl.DataItemIndex, DataStorage, bindingOptions, isCollectionBinding, controlService);
genericContainer = collectionItemContainer;
}
else
{
dataValue = DataBinder.Eval(baseContext, bindingOptions.Path);
bool isCollectionBinding = DetermineIfCollection(control, dataValue);
binding = new BindingDef(control, targetPropertyName, bindingOptions, isCollectionBinding, controlService);
genericContainer = controlService.GetParent(control);
}
//determine binding direction is not explicitly set based on the value and contorl
if (bindingOptions.Mode == BindingMode.Unset)
{
bindingOptions.Mode = DetermineBindingDirection(control, dataValue);
}
//store the binding
DataStorage.Add(binding);
return(AttemptConvert(binding, dataValue, genericContainer));
}
/// <summary>
/// Sets the current target.
/// </summary>
/// <remarks>
/// This will clear current hierarchy and regenerate a new one.
/// </remarks>
/// <param name="target">The target to set.</param>
/// <typeparam name="T">The type of the target.</typeparam>
public void SetTarget <T>(T target)
{
if (TryGetTarget(out T current) && EqualityComparer <T> .Default.Equals(target, current))
{
// Nothing to do..
return;
}
if (null != m_BindingTarget)
{
var declaredType = typeof(T);
var targetType = declaredType;
if (typeof(T).IsClass && EqualityComparer <T> .Default.Equals(target, default))
{
targetType = target.GetType();
}
if (declaredType == m_BindingTarget.DeclaredType && targetType == m_BindingTarget.TargetType)
{
((BindingTarget <T>)m_BindingTarget).Target = target;
return;
}
}
m_BindingTarget?.Release();
if (RuntimeTypeInfoCache <T> .CanBeNull && EqualityComparer <T> .Default.Equals(target, default))
{
m_BindingTarget = null;
return;
}
m_BindingTarget = new BindingTarget <T>(this, target);
name = TypeUtility.GetTypeDisplayName(target.GetType());
m_BindingTarget.GenerateHierarchy();
}
public static Binding GetOrCreateBinding(Gtk.Widget widget, Object source, IBindingTarget target, BindingInfo info)
{
Binding result = null;
if (!mBindings.TryGetValue(target, out result)) {
result = new Binding();
result.Info = info;
result.Connect(widget, source, target);
mBindings[target] = result;
}
return result;
}
