public void Bind <TDataModel>(CreateBindingPageDelegate pageCreator,
CreateBindingControlDelegate ctrlCreator, CreateDynamicControlsDelegate dynCtrlDescCreator,
IContextProvider contextProvider,
out IEnumerable <IBinding> bindings, out IRawDependencyGroup dependencies, out IMetadata[] metadata)
{
var type = typeof(TDataModel);
var bindingsList = new List <IBinding>();
bindings = bindingsList;
var pageAttSet = GetAttributeSet(type, -1);
OnGetPageAttributeSet(type, ref pageAttSet);
var page = pageCreator.Invoke(pageAttSet);
var firstCtrlId = 0;
dependencies = new RawDependencyGroup();
var metadataMap = new Dictionary <object, PropertyInfoMetadata>();
CollectMetadata(type, metadataMap, new PropertyInfo[0], new List <Type>(), contextProvider);
TraverseType <TDataModel>(type, new List <IControlDescriptor>(),
ctrlCreator, dynCtrlDescCreator, page, metadataMap, bindingsList, dependencies, contextProvider, ref firstCtrlId);
metadata = metadataMap.Values.ToArray();
OnBeforeControlsDataLoad(bindings);
}
public void Bind <TDataModel>(TDataModel model, CreateBindingPageDelegate pageCreator,
CreateBindingControlDelegate ctrlCreator,
out IEnumerable <IBinding> bindings, out IRawDependencyGroup dependencies)
{
var type = model.GetType();
var bindingsList = new List <IBinding>();
bindings = bindingsList;
var pageAttSet = GetAttributeSet(type, -1);
OnGetPageAttributeSet(type, ref pageAttSet);
var page = pageCreator.Invoke(pageAttSet);
var firstCtrlId = 0;
dependencies = new RawDependencyGroup();
TraverseType(model.GetType(), model, new List <PropertyInfo>(),
ctrlCreator, page, bindingsList, dependencies, ref firstCtrlId);
OnBeforeControlsDataLoad(bindings);
LoadControlsData(bindings);
}
public void Init(IXApplication app, IRawDependencyGroup depGroup)
{
m_App = app;
m_ControlDependencies = new Dictionary <IBinding, List <ControlUpdateStateData> >();
m_MetadataDependencies = new Dictionary <IMetadata, List <MetadataUpdateStateData> >();
foreach (var data in depGroup.DependenciesTags)
{
var srcBnd = data.Key;
var dependOnTags = data.Value.Item1;
var handler = data.Value.Item2;
var dependOnBindings = new IBinding[dependOnTags.Length];
for (int i = 0; i < dependOnTags.Length; i++)
{
var dependOnTag = dependOnTags[i];
IBinding dependOnBinding;
if (!depGroup.TaggedBindings.TryGetValue(dependOnTag, out dependOnBinding))
{
throw new Exception("Dependent on binding is not found for tag");
}
dependOnBindings[i] = dependOnBinding;
}
foreach (var dependOnBinding in dependOnBindings)
{
List <ControlUpdateStateData> updates;
if (!m_ControlDependencies.TryGetValue(dependOnBinding, out updates))
{
dependOnBinding.ModelUpdated += OnModelUpdated;
updates = new List <ControlUpdateStateData>();
m_ControlDependencies.Add(dependOnBinding, updates);
}
updates.Add(new ControlUpdateStateData(m_App, srcBnd, dependOnBindings, handler));
}
}
foreach (var data in depGroup.MetadataDependencies)
{
var state = new MetadataUpdateStateData(m_App, data.Key, data.Value.Item1, data.Value.Item2);
foreach (var md in data.Value.Item1)
{
if (!m_MetadataDependencies.TryGetValue(md, out List <MetadataUpdateStateData> states))
{
md.Changed += OnMetadataChanged;
states = new List <MetadataUpdateStateData>();
m_MetadataDependencies.Add(md, states);
}
states.Add(state);
}
}
}
public void Load(IXApplication app, IEnumerable <IBinding> bindings,
IRawDependencyGroup dependencies, IMetadata[] metadata)
{
Bindings = bindings;
Dependency = new DependencyManager();
Metadata = metadata;
Dependency.Init(app, dependencies);
}
public void Init(IRawDependencyGroup depGroup)
{
m_Dependencies = new Dictionary <IBinding, List <UpdateStateData> >();
var handlersCache = new Dictionary <Type, IDependencyHandler>();
foreach (var data in depGroup.DependenciesTags)
{
var srcBnd = data.Key;
var dependOnTags = data.Value.Item1;
var depHandlerType = data.Value.Item2;
var dependOnBindings = new IBinding[dependOnTags.Length];
for (int i = 0; i < dependOnTags.Length; i++)
{
var dependOnTag = dependOnTags[i];
IBinding dependOnBinding;
if (!depGroup.TaggedBindings.TryGetValue(dependOnTag, out dependOnBinding))
{
throw new Exception("Dependent on binding is not fond for tag");
}
dependOnBindings[i] = dependOnBinding;
}
IDependencyHandler handler;
if (!handlersCache.TryGetValue(depHandlerType, out handler))
{
handler = Activator.CreateInstance(depHandlerType) as IDependencyHandler;
handlersCache.Add(depHandlerType, handler);
}
foreach (var dependOnBinding in dependOnBindings)
{
List <UpdateStateData> updates;
if (!m_Dependencies.TryGetValue(dependOnBinding, out updates))
{
dependOnBinding.ModelUpdated += OnModelUpdated;
updates = new List <UpdateStateData>();
m_Dependencies.Add(dependOnBinding, updates);
}
updates.Add(new UpdateStateData(srcBnd, dependOnBindings, handler));
}
}
}
private void TraverseType <TDataModel>(Type type, List <IControlDescriptor> parents,
CreateBindingControlDelegate ctrlCreator, CreateDynamicControlsDelegate dynCtrlDescCreator,
IGroup parentCtrl, IReadOnlyDictionary <object, PropertyInfoMetadata> metadata,
List <IBinding> bindings, IRawDependencyGroup dependencies, IContextProvider contextProvider, ref int nextCtrlId)
{
foreach (var prp in type.GetProperties().OrderBy(p =>
{
var orderAtt = p.GetCustomAttribute <OrderAttribute>();
if (orderAtt != null)
{
return(orderAtt.Order);
}
else
{
return(0);
}
}))
{
IControlDescriptor[] ctrlDescriptors;
var dynCtrlAtt = prp.GetCustomAttribute <DynamicControlsAttribute>();
if (dynCtrlAtt != null)
{
if (dynCtrlDescCreator != null)
{
ctrlDescriptors = dynCtrlDescCreator.Invoke(dynCtrlAtt.Tag) ?? new IControlDescriptor[0];
}
else
{
throw new DynamicControlHandlerMissingException(prp);
}
ctrlDescriptors = ctrlDescriptors.Select(d => new ControlDescriptorWrapper(d, prp)).ToArray();
}
else
{
ctrlDescriptors = new IControlDescriptor[]
{
new PropertyInfoControlDescriptor(prp)
};
}
foreach (var ctrlDesc in ctrlDescriptors)
{
var prpType = ctrlDesc.DataType;
var atts = GetAttributeSet(ctrlDesc, nextCtrlId);
if (!atts.Has <IIgnoreBindingAttribute>() && !atts.Has <IMetadataAttribute>())
{
var prpMetadata = new List <PropertyInfoMetadata>();
if (atts.Has <IHasMetadataAttribute>())
{
var metadataTagsAtts = atts.GetAll <IHasMetadataAttribute>();
foreach (var metadataTagAtts in metadataTagsAtts)
{
if (metadataTagAtts.HasMetadata)
{
var metadataTag = metadataTagAtts.MetadataTag;
if (metadataTag == null)
{
throw new NullReferenceException($"Metadata tag is not set for {ctrlDesc.Name}");
}
if (metadata.TryGetValue(metadataTag, out PropertyInfoMetadata md))
{
prpMetadata.Add(md);
}
else
{
throw new MissingMetadataException(metadataTag, ctrlDesc);
}
}
}
}
var prpMetadataArr = prpMetadata.ToArray();
int numberOfUsedIds;
var ctrl = ctrlCreator.Invoke(prpType, atts, parentCtrl, prpMetadataArr, out numberOfUsedIds);
nextCtrlId += numberOfUsedIds;
var binding = new PropertyInfoBinding <TDataModel>(ctrl, ctrlDesc, parents, prpMetadataArr, contextProvider);
bindings.Add(binding);
if (atts.Has <IControlTagAttribute>())
{
var tag = atts.Get <IControlTagAttribute>().Tag;
dependencies.RegisterBindingTag(binding, tag);
}
if (atts.Has <IDependentOnAttribute>())
{
foreach (var depAtt in atts.GetAll <IDependentOnAttribute>())
{
if (depAtt.Dependencies?.Any() == true)
{
dependencies.RegisterDependency(binding,
depAtt.Dependencies, depAtt.DependencyHandler);
}
}
}
if (atts.Has <IDependentOnMetadataAttribute>())
{
var depAtt = atts.Get <IDependentOnMetadataAttribute>();
var depMds = depAtt.Dependencies.Select(t =>
{
if (!metadata.TryGetValue(t, out PropertyInfoMetadata md))
{
throw new MissingMetadataException(t, ctrlDesc);
}
return(md);
}).ToArray();
dependencies.RegisterMetadataDependency(ctrl, depMds, depAtt.DependencyHandler);
}
var isGroup = ctrl is IGroup;
if (isGroup)
{
var grpParents = new List <IControlDescriptor>(parents);
grpParents.Add(ctrlDesc);
TraverseType <TDataModel>(prpType, grpParents, ctrlCreator, dynCtrlDescCreator,
ctrl as IGroup, metadata, bindings, dependencies, contextProvider, ref nextCtrlId);
}
}
}
}
}
private void TraverseType <TDataModel>(Type type, TDataModel model, List <PropertyInfo> parents,
CreateBindingControlDelegate ctrlCreator,
IGroup parentCtrl, List <IBinding> bindings, IRawDependencyGroup dependencies, ref int nextCtrlId)
{
foreach (var prp in type.GetProperties())
{
var prpType = prp.PropertyType;
var atts = GetAttributeSet(prp, nextCtrlId);
if (!atts.Has <IIgnoreBindingAttribute>())
{
int idRange;
var ctrl = ctrlCreator.Invoke(prpType, atts, parentCtrl, out idRange);
nextCtrlId += idRange;
var binding = new PropertyInfoBinding <TDataModel>(model, ctrl, prp, parents);
bindings.Add(binding);
if (atts.Has <IControlTagAttribute>())
{
var tag = atts.Get <IControlTagAttribute>().Tag;
dependencies.RegisterBindingTag(binding, tag);
}
if (atts.Has <IDependentOnAttribute>())
{
var depAtt = atts.Get <IDependentOnAttribute>();
dependencies.RegisterDependency(binding,
depAtt.Dependencies, depAtt.DependencyHandler);
}
var isGroup = ctrl is IGroup;
if (isGroup)
{
var grpParents = new List <PropertyInfo>(parents);
grpParents.Add(prp);
TraverseType(prpType, model, grpParents, ctrlCreator,
ctrl as IGroup, bindings, dependencies, ref nextCtrlId);
}
}
}
}
public void Load(IEnumerable <IBinding> bindings, IRawDependencyGroup dependencies)
{
Bindings = bindings;
Dependency = new DependencyManager();
Dependency.Init(dependencies);
}
