public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value.AsString().IsEmpty() || value.AsString() == DefaultValue.AsString())
return;
result.Attributes[Attribute.ToString().ToLower()] = value.AsString();
}
internal ControlPropertyChangedEventArgs(HtmlObject target, ControlProperty property, Object currentvalue, Object newValue)
{
this.Target = target;
this.Property = property;
this.OldValue = currentvalue;
this.NewValue = newValue;
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
var boolValue = ConversionHelper.ToBoolean(value);
if (boolValue == DefaultValue)
return;
result.Attributes[Attribute] = boolValue ? ValueIfTrue : ValueIfFalse;
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value.AsString().IsEmpty() || value.AsString() == DefaultValue.AsString())
{
return;
}
result.Attributes[Attribute.ToString().ToLower()] = value.AsString();
}
/// <summary>
/// Aplica a propriedade à saída de um controle.
/// </summary>
/// <param name="target">Controle alvo</param>
/// <param name="property">Propriedade sendo aplicada</param>
/// <param name="value">Valor da propriedade sendo aplicada</param>
/// <param name="result">Resultado da saida da renderização atual.</param>
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value != null && value.AsString() != DefaultValue.AsString())
{
var strValue = (value ?? "").ToString();
if (strValue.HasValue())
result.Styles[CssProperty] = strValue.ToLowerInvariant();
}
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
var boolValue = ConversionHelper.ToBoolean(value);
if (boolValue == DefaultValue)
{
return;
}
result.Attributes[Attribute] = boolValue ? ValueIfTrue : ValueIfFalse;
}
/// <summary>
/// Aplica a propriedade à saída de um controle.
/// </summary>
/// <param name="target">Controle alvo</param>
/// <param name="property">Propriedade sendo aplicada</param>
/// <param name="value">Valor da propriedade sendo aplicada</param>
/// <param name="result">Resultado da saida da renderização atual.</param>
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value != null && value.AsString() != DefaultValue.AsString())
{
var strValue = (value ?? "").ToString();
if (strValue.HasValue())
{
result.Styles[CssProperty] = strValue.ToLowerInvariant();
}
}
}
private ControlPropertySlot GetSlot(ControlProperty property, bool createIfNotExists)
{
ControlPropertySlot result = null;
if (!_slots.TryGetValue(property, out result) && createIfNotExists)
{
result = new ControlPropertySlot(this, property);
_slots[property] = result;
}
return(result);
}
/// <summary>
/// Atribui um valor para uma propriedade.
/// </summary>
/// <param name="property">Propriedade que terá seu valor alterado</param>
/// <param name="value">Novo valor da propriedade</param>
public void SetValue(ControlProperty property, Object value)
{
var slot = GetSlot(property, true);
if (slot.StoredValue == value)
{
return;
}
var oldValue = slot.StoredValue;
slot.StoredValue = value;
property.NotifyPropertyChanged(this, oldValue, slot.StoredValue);
}
/// <summary>
/// Register a property for a Control.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="propertyType"></param>
/// <param name="ownerType"></param>
/// <param name="propertyMetadata"></param>
/// <returns></returns>
public static ControlProperty Register(String propertyName, Type propertyType, Type ownerType, ControlPropertyMetadata propertyMetadata = null)
{
Assert.EmptyString(propertyName, "propertyName");
Assert.NullArgument(propertyType, "propertyType");
Assert.NullArgument(ownerType, "ownerType");
lock (_lockObject)
{
if (!typeof(HtmlObject).IsAssignableFrom(ownerType))
{
throw new Exception(String.Format("The type {0} must inherit from HtmlObject in order to own a ControlProperty", ownerType.FullName));
}
var result = new ControlProperty()
{
Name = propertyName,
OwnerType = ownerType,
PropertyType = propertyType,
Metadata = propertyMetadata
};
if (result.Metadata != null)
{
result.PropertyChangedCallback = result.Metadata.PropertyChangedCallback;
result.Applier = result.Metadata.Applier;
result.IsReadOnly = result.Metadata.ReadOnly;
if (result.Metadata.DefaultValue != null)
{
result.DefaultValue = result.Metadata.DefaultValue;
}
else
{
result.DefaultValue = ConversionHelper.Default(propertyType);
}
}
if (propertyType.GetInterfaces().Contains(typeof(INotifyPropertyChanged)))
{
result.TrackingPropertyChangedEvent = true;
}
_properties.Add(result);
_properties = _properties.OrderBy(p => p.Name).ToList();
_typePropertiesCache.Clear();
_templatePropertiesCache.Clear();
_typePropertiesWithAppliersCache.Clear();
return(result);
}
}
/// <summary>
/// Registra uma vinculação de dados a uma propriedade do controle.
/// </summary>
/// <param name="targetProperty">Propriedade alvo da vinculação de dados. É a propriedade que receberá o valor resolvido.</param>
/// <param name="binding">Informações sobre a vinculação de dados.</param>
public void PropertyBinding(ControlProperty targetProperty, Binding binding)
{
var slot = GetSlot(targetProperty, true);
slot.Binding = binding;
if (binding == null && _bindings != null)
{
_bindings.Remove(slot);
}
else
{
_bindings = _bindings ?? new List <ControlPropertySlot>();
_bindings.AddIfNotExists(slot);
}
}
/// <summary>
/// Atribui um valor para uma propriedade somente-leitura.
/// </summary>
/// <param name="property">Propriedade que terá seu valor alterado.</param>
/// <param name="value">Novo valor da propriedade</param>
protected void SetReadOnlyValue(ControlProperty property, Object value)
{
if (!property.IsReadOnly)
{
throw new InvalidOperationException(String.Format("The property {0}.{1} is not a readonly property.", property.OwnerTypeName, property.PropertyTypeName));
}
var slot = GetSlot(property, true);
if (slot.StoredValue == value)
{
return;
}
var oldValue = slot.StoredValue;
slot.SetReadOnlyValue(value);
property.NotifyPropertyChanged(this, oldValue, slot.StoredValue);
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
Object getParams = null;
var urlStr = value.AsString();
var uri = new Uri(urlStr, UriKind.RelativeOrAbsolute);
//url.
if (GetParamsProperty != null)
getParams = target.GetValue(GetParamsProperty);
if (getParams != null)
{
IDictionary<String, Object> dict = null;
if (!(getParams is IDictionary<String, Object>))
dict = ReflectionHelper.AnonymousToDictionary(getParams);
else
dict = (IDictionary<String, Object>)getParams;
if (uri.Query.HasValue())
urlStr += urlStr + "&" + Utils.EncodeGetParams(dict);
else
urlStr += uri.ToString() + "?" + Utils.EncodeGetParams(dict);
}
if (urlStr != null)
result.Attributes[HtmlAttr.Href] = urlStr;
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
Object getParams = null;
var urlStr = value.AsString();
var uri = new Uri(urlStr, UriKind.RelativeOrAbsolute);
//url.
if (GetParamsProperty != null)
{
getParams = target.GetValue(GetParamsProperty);
}
if (getParams != null)
{
IDictionary <String, Object> dict = null;
if (!(getParams is IDictionary <String, Object>))
{
dict = ReflectionHelper.AnonymousToDictionary(getParams);
}
else
{
dict = (IDictionary <String, Object>)getParams;
}
if (uri.Query.HasValue())
{
urlStr += urlStr + "&" + Utils.EncodeGetParams(dict);
}
else
{
urlStr += uri.ToString() + "?" + Utils.EncodeGetParams(dict);
}
}
if (urlStr != null)
{
result.Attributes[HtmlAttr.Href] = urlStr;
}
}
/// <summary>
/// Altera o aplicador de uma propriedade para a instancia do controle.
/// Apenas a instancia atual é afetada.
/// </summary>
/// <param name="property">Propriedade que terá seu aplicador alterado.</param>
/// <param name="applier">Aplicador customizado.</param>
void IControlInstanceAdapter.SetCustomApplier(ControlProperty property, IControlPropertyApplier applier)
{
var slot = GetSlot(property, true);
slot.CustomApplier = applier;
}
/// <summary>
/// Registra uma vinculação de propriedades 'template'.
/// </summary>
/// <param name="targetProperty">Propriedade alvo. É a propriedade que irá receber o valor resolvido do binding.</param>
/// <param name="sourceProperty">Propriedade fonte. É a propriedade no controle que detém a propriedade 'template'. O valor dessa propriedadade
/// é repassada para <paramref name="targetProperty"/> e ela não é renderizada no controle fonte.</param>
public void TemplateBinding(ControlProperty targetProperty, ControlProperty sourceProperty)
{
_templateBindings = _templateBindings ?? new List <ControlPropertyTemplateBinding>();
_templateBindings.Add(new ControlPropertyTemplateBinding(targetProperty, sourceProperty));
}
/// <summary>
/// Register a property for a Control.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="propertyType"></param>
/// <param name="ownerType"></param>
/// <param name="propertyMetadata"></param>
/// <returns></returns>
public static ControlProperty Register(String propertyName, Type propertyType, Type ownerType, ControlPropertyMetadata propertyMetadata = null)
{
Assert.EmptyString(propertyName, "propertyName");
Assert.NullArgument(propertyType, "propertyType");
Assert.NullArgument(ownerType, "ownerType");
lock (_lockObject)
{
if (!typeof(HtmlObject).IsAssignableFrom(ownerType))
throw new Exception(String.Format("The type {0} must inherit from HtmlObject in order to own a ControlProperty", ownerType.FullName));
var result = new ControlProperty()
{
Name = propertyName,
OwnerType = ownerType,
PropertyType = propertyType,
Metadata = propertyMetadata
};
if (result.Metadata != null)
{
result.PropertyChangedCallback = result.Metadata.PropertyChangedCallback;
result.Applier = result.Metadata.Applier;
result.IsReadOnly = result.Metadata.ReadOnly;
if (result.Metadata.DefaultValue != null)
result.DefaultValue = result.Metadata.DefaultValue;
else
result.DefaultValue = ConversionHelper.Default(propertyType);
}
if (propertyType.GetInterfaces().Contains(typeof(INotifyPropertyChanged)))
result.TrackingPropertyChangedEvent = true;
_properties.Add(result);
_properties = _properties.OrderBy(p => p.Name).ToList();
_typePropertiesCache.Clear();
_templatePropertiesCache.Clear();
_typePropertiesWithAppliersCache.Clear();
return result;
}
}
/// <summary>
/// Retorna o valor de uma propriedade.
/// </summary>
/// <typeparam name="T">Tipo esperado da propriedade. Se o tipo especificado for diferente do tipo armazenado, uma exceção será levantada.</typeparam>
/// <param name="property">Propriedade requisitada.</param>
/// <returns>Retorna o valor corrente da propriedade ou seu valor default definido no momento do registro.</returns>
/// <exception cref="System.InvalidCastException">Caso o tipo especificado em "T" não seja compatível com o tipo do dado armazenado.</exception>
public T GetValue <T>(ControlProperty property)
{
return((T)GetValue(property));
}
/// <summary>
/// Retorna o valor de uma propriedade.
/// </summary>
/// <param name="property">Propriedade requisitada.</param>
/// <returns>Retorna o valor corrente da propriedade ou seu valor default definido no momento do registro.</returns>
public Object GetValue(ControlProperty property)
{
var slot = GetSlot(property, false);
return(slot == null ? property.DefaultValue : slot.CurrentValue);
}
internal void Resolve(HtmlObject instance, ControlProperty targetProperty)
{
Object value = null;
if (ValueProvider != null)
{
value = ValueProvider.GetValue(instance.DataItem);
}
else if (_pathParts != null || _resolvePending)
{
if (_resolvePending)
{
CompilePropertyPath();
}
var data = instance.DataItem;
for (var i = 0; i < _pathParts.Length; i++)
{
var key = _pathParts[i];
try
{
switch (_resolveMethods[i])
{
case ResolveMethod.PropertyValue:
data = ReflectionHelper.ReadProperty(data, key); break;
case ResolveMethod.ViewDataEntry:
data = instance.CurrentContext[key]; break;
case ResolveMethod.MethodCall:
data = ReflectionHelper.InvokeInstanceMethod(data, key); break;
case ResolveMethod.CurrentDataItem:
data = instance.DataItem; break;
case ResolveMethod.VisualTreeObject:
throw new NotImplementedException();
}
if (data == null)
{
break;
}
}
catch (Exception ex)
{
throw new BindingException(String.Format("Error on resolve property path {0} to property {1}.{2}", PropertyPath, instance.GetType().Name, targetProperty.Name), ex);
}
}
value = data;
}
else
{
value = instance.DataItem;
}
if (Formatter != null)
{
value = Formatter.Format(value);
if (Formatter.Align != TextAlignment.Default)
{
instance.SetValue(HtmlControl.TextAlignProperty, Formatter.Align);
}
}
if (!String.IsNullOrEmpty(FormatString))
{
value = String.Format(FormatString, value);
}
instance.SetValue(targetProperty, value);
}
private void ApplyProperties()
{
_renderResult.Begin();
var propertyList = ControlProperty.GetPropertiesWithAppliersForType(this.GetType());
foreach (var property in propertyList)
{
var slot = GetSlot(property, false);
if (slot == null &&
property.Applier != null)
{
property.Applier.ApplyProperty(this, property, property.DefaultValue, _renderResult);
}
else if (slot != null &&
slot.CurrentApplier != null &&
slot.LastTemplateBindingSessionId != CurrentContext.RenderSessionId)
{
slot.CurrentApplier.ApplyProperty(this, property, slot.CurrentValue, _renderResult);
}
}
if (_styles != null)
{
foreach (var item in _styles)
{
_renderResult.Styles[item.Style] = item.Value;
}
}
if (_attributes != null)
{
foreach (var item in _attributes)
{
_renderResult.Attributes[item.Name] = item.Value;
}
}
if (_cssClasses != null)
{
var cssClass = _renderResult.Attributes[HtmlAttr.Class];
if (cssClass.HasValue())
{
var current = cssClass.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
foreach (var cssItem in _cssClasses)
{
current.AddIfNotExists(cssItem);
}
cssClass = "";
foreach (var cssItem in current)
{
cssClass += cssItem + " ";
}
_renderResult.Attributes[HtmlAttr.Class] = cssClass.Trim();
}
else
{
foreach (var cssItem in _cssClasses)
{
cssClass += cssItem + " ";
}
_renderResult.Attributes[HtmlAttr.Class] = cssClass.Trim();
}
}
if (_renderResult.Styles.Count > 0)
{
_renderResult.Attributes[HtmlAttr.Style] = _renderResult.Styles.ToStyleString();
}
}
/// <summary>
/// Aplica a propriedade à saída de um controle.
/// </summary>
/// <param name="target">Controle alvo</param>
/// <param name="property">Propriedade sendo aplicada</param>
/// <param name="value">Valor da propriedade sendo aplicada</param>
/// <param name="result">Resultado da saida da renderização atual.</param>
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value != null && value.AsString() != DefaultValue.AsString())
result.Styles[CssProperty] = CssConfig.GetItemNameFromEnum(property.PropertyType, value);
}
public static T SetProperty <T>(this T control, ControlProperty property, Object value) where T : HtmlObject
{
control.SetValue(property, value);
return(control);
}
public static T SetTemplateBinding <T>(this T control, ControlProperty targetProperty, ControlProperty sourceProperty) where T : HtmlObject
{
control.TemplateBinding(targetProperty, sourceProperty);
return(control);
}
protected override void ApplyValueProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
result.InnerText.Append(value.AsString());
}
public HyperLinkHrefPropertyApplier(ControlProperty getParamsProperty = null)
{
this.GetParamsProperty = getParamsProperty;
}
public HyperLinkHrefPropertyApplier(ControlProperty getParamsProperty = null)
{
this.GetParamsProperty = getParamsProperty;
}
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
}
internal void Resolve(HtmlObject instance, ControlProperty targetProperty)
{
Object value = null;
if (ValueProvider != null)
value = ValueProvider.GetValue(instance.DataItem);
else if (_pathParts != null || _resolvePending)
{
if (_resolvePending)
CompilePropertyPath();
var data = instance.DataItem;
for (var i = 0; i < _pathParts.Length; i++)
{
var key = _pathParts[i];
try
{
switch (_resolveMethods[i])
{
case ResolveMethod.PropertyValue:
data = ReflectionHelper.ReadProperty(data, key); break;
case ResolveMethod.ViewDataEntry:
data = instance.CurrentContext[key]; break;
case ResolveMethod.MethodCall:
data = ReflectionHelper.InvokeInstanceMethod(data, key); break;
case ResolveMethod.CurrentDataItem:
data = instance.DataItem; break;
case ResolveMethod.VisualTreeObject:
throw new NotImplementedException();
}
if (data == null)
break;
}
catch (Exception ex)
{
throw new BindingException(String.Format("Error on resolve property path {0} to property {1}.{2}", PropertyPath, instance.GetType().Name, targetProperty.Name), ex);
}
}
value = data;
}
else
value = instance.DataItem;
if (Formatter != null)
{
value = Formatter.Format(value);
if (Formatter.Align != TextAlignment.Default)
instance.SetValue(HtmlControl.TextAlignProperty, Formatter.Align);
}
if (!String.IsNullOrEmpty(FormatString))
value = String.Format(FormatString, value);
instance.SetValue(targetProperty, value);
}
/// <summary>
/// Aplica a propriedade à saída de um controle.
/// </summary>
/// <param name="target">Controle alvo</param>
/// <param name="property">Propriedade sendo aplicada</param>
/// <param name="value">Valor da propriedade sendo aplicada</param>
/// <param name="result">Resultado da saida da renderização atual.</param>
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
Callback.Invoke(target, property, value, result);
}
protected override void ApplyValueProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
if (value.AsString().HasValue())
result.Attributes[HtmlAttr.Value] = value.AsString();
}
internal ControlPropertySlot(HtmlObject owner, ControlProperty property)
{
_owner = new WeakReference(owner);
this.Property = property;
}
protected override void ApplyValueProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
result.InnerText.Append(value.AsString());
}
/// <summary>
/// Aplica a propriedade à saída de um controle.
/// </summary>
/// <param name="target">Controle alvo</param>
/// <param name="property">Propriedade sendo aplicada</param>
/// <param name="value">Valor da propriedade sendo aplicada</param>
/// <param name="result">Resultado da saida da renderização atual.</param>
public void ApplyProperty(HtmlObject target, ControlProperty property, object value, ControlPropertyApplyResult result)
{
Callback.Invoke(target, property, value, result);
}
public static T SetBinding <T>(this T control, ControlProperty property, String propertyPath, String formatString) where T : HtmlObject
{
control.PropertyBinding(property, new Binding(propertyPath, null, formatString));
return(control);
}
internal ControlPropertySlot(HtmlObject owner, ControlProperty property)
{
_owner = new WeakReference(owner);
this.Property = property;
}
public static T SetBinding <T>(this T control, ControlProperty property, IValueProvider valueProvider, String formatString) where T : HtmlObject
{
control.PropertyBinding(property, new Binding(valueProvider, null, formatString));
return(control);
}