internal bool Remove(NProperty key)
{
var last = default(NPropertyEntry);
for (var i = Head; i != null; i = i.Next)
{
if (ReferenceEquals(i.Key, key))
{
if (last == null)
{
Head = i.Next;
}
else
{
last.Next = i.Next;
}
i.Next = null;
return(true);
}
last = i;
}
return(false);
}
NPropPatchEntry Add(NProperty key)
{
var setter = key[_type];
if (setter == null)
{
Debug.WriteLine($"Warning: Property {_type.Name}.{key.Name} is not supported (2)");
}
var result = new NPropPatchEntry {
Key = key, Setter = setter
};
if (_tail != null)
{
_tail.Next = result;
}
else
{
_head = result;
}
_tail = result;
return(result);
}
void Remove(NProperty key, object value)
{
var e = Add(key);
e.Finalizer = value;
e.Value = NUnset.Instance;
}
public NEventAdapter this[NProperty key]
{
get
{
for (var i = _first; i != null; i = i.Next)
{
if (ReferenceEquals(i.Property, key))
{
return(i);
}
}
return(null);
}
set
{
if (_first == null)
{
_first = _last = value;
}
else
{
_last.Next = value;
_last = value;
}
}
}
internal NPropertyEntry GetEntry(NProperty key)
{
for (var i = Head; i != null; i = i.Next)
{
if (ReferenceEquals(i.Key, key))
{
return(i);
}
}
return(null);
}
static bool Unset(ref NPropertyBag head, NProperty key)
{
var e = head.GetEntry(key);
if (e == null)
{
return(false); // value not changed -> do nothing
}
head = head.Clone();
head.Remove(key);
return(true);
}
static bool Set(ref NPropertyBag head, NProperty key, object value)
{
var e = head.GetEntry(key);
if (e != null && Equals(e._value, value))
{
return(false); // value not changed -> do nothing
}
head = head.Clone();
head.Set(key, value);
return(true);
}
internal override void UnsetProp(NProperty key, bool silent)
{
if (_xaml != null && !_dirty)
{
if (Unset(ref _props, key))
{
Update(silent);
}
}
else
{
_props.Remove(key);
}
}
/// <summary>
/// State setter method
/// </summary>
/// <param name="key">Property key</param>
/// <param name="value">Property value</param>
protected void SetState(NProperty key, object value)
{
if (_xaml != null && !_dirty)
{
if (Set(ref _state, key, value))
{
Update(false);
}
}
else
{
_state.Set(key, value);
}
}
internal override void SetProp(NProperty key, object value, bool silent)
{
if (_xaml != null && !_dirty)
{
if (Set(ref _props, key, value))
{
Update(silent);
}
}
else
{
_props.Set(key, value);
}
}
internal bool Set(NProperty key, object value)
{
var e = GetEntry(key);
if (e == null)
{
Head = new NPropertyEntry(key, value, Head);
return(true);
}
if (Equals(e._value, value))
{
return(false);
}
e._value = value;
return(true);
}
public static void AssignEvent(NProperty prop, object action, DependencyObject target, RoutedEvent routedEvent, Func <NEventAdapter, Delegate> extractor)
{
var handled = NEventAdapter.UnpackHandler(ref action);
var agg = (NEventAggregator)target.GetValue(AggregatorProperty);
if (agg == null)
{
target.SetValue(AggregatorProperty, agg = new NEventAggregator());
}
var adapter = agg[prop];
if (adapter == null)
{
agg[prop] = adapter = new NEventAdapter(prop)
{
Action = action
};
var handler = extractor(adapter);
var e = target as UIElement;
if (e != null)
{
e.AddHandler(routedEvent, handler, handled);
}
#if WPF
else
{
var ce = target as ContentElement;
if (ce != null)
{
ce.AddHandler(routedEvent, handler, true);
}
}
#endif
}
else
{
adapter.Action = action;
}
}
internal NPropertyEntry(NPropertyEntry source)
{
Key = source.Key;
_value = source._value;
}
/// <summary>
/// Property getter
/// </summary>
/// <typeparam name="T">Type of the property</typeparam>
/// <param name="key">Property key</param>
/// <param name="default">Default value in case the property is not set</param>
/// <returns>Property value of @default in case the property is not set</returns>
public T Get <T>(NProperty key, T @default)
{
return(_props.Get(key, @default));
}
internal virtual void UnsetProp(NProperty key, bool silent = false)
{
_props.Remove(key);
}
internal virtual void SetProp(NProperty key, object value, bool silent = false)
{
_props.Set(key, value);
}
/// <summary>
/// Property cleaner
/// </summary>
/// <param name="prop">Property key</param>
/// <returns>This instance for setter chaining</returns>
public NElement Unset(NProperty prop)
{
UnsetProp(prop);
return(this);
}
internal NPropertyEntry(NProperty key, object value, NPropertyEntry next)
{
Key = key;
_value = value;
Next = next;
}
bool Update(NProperty key, object newValue, object oldValue)
{
#region NElement property
{
var oldE = oldValue as NElement;
var newE = newValue as NElement;
if (oldE != null || newE != null)
{
var s = newE;
var p = Diff(oldE, ref newE);
if (p == null)
{
return(newE != s);
}
var e = Add(key);
if (p == NPatch.AssignNewValue)
{
e.Value = newE;
e.Finalizer = oldValue;
}
else
{
e.Value = p;
}
return(false);
}
}
#endregion
#region NElement[] property
{
var oldE = oldValue as NElement[];
var newE = newValue as NElement[];
if (oldE != null || newE != null)
{
var p = NListDiffer.Diff(oldE, newE);
if (p == null)
{
return(false);
}
var e = Add(key);
if (p == NPatch.AssignNewValue)
{
e.Value = newE;
e.Finalizer = oldValue;
}
else
{
e.Value = p;
}
return(false);
}
}
#endregion
{
var e = Add(key);
e.Value = newValue;
e.Finalizer = oldValue;
}
return(false);
}
/// <summary>
/// Retrieves value of specified property
/// </summary>
/// <param name="key">Property key</param>
/// <returns>Property value or NUndefined.Instance if it is not set</returns>
public object Get(NProperty key)
{
var e = GetEntry(key);
return(e != null ? e._value : NUndefined.Instance);
}
/// <summary>
/// Retrieves value of specified property
/// </summary>
/// <param name="key">Property key</param>
/// <param name="default">Default value</param>
/// <returns>Property value or @default if property is not set</returns>
public T Get <T>(NProperty key, T @default)
{
var e = GetEntry(key);
return(e != null ? (T)e._value : @default);
}
/// <summary>
/// State getter method
/// </summary>
/// <typeparam name="T">Type of the property</typeparam>
/// <param name="key">Property key</param>
/// <param name="default">Default value in case property is not set</param>
/// <returns>Value of the property or @default if property is not set</returns>
protected T GetState <T>(NProperty key, T @default)
{
return(_state.Get(key, @default));
}
public NContentProperty Content <T>(NProperty content)
{
return(Content(typeof(T), content));
}
public NEventAdapter(NProperty prop)
{
Property = prop;
}
/// <summary>
/// Property setter
/// </summary>
/// <param name="prop">Property key</param>
/// <param name="value">Property value</param>
/// <returns>This instance for setter chaining</returns>
public NElement Set(NProperty prop, object value)
{
SetProp(prop, value);
return(this);
}
public static void AssignEvent <T>(NProperty prop, object action, T target, Action <T, NEventAdapter> subscribe) where T : class
{
var handled = NEventAdapter.UnpackHandler(ref action);
if (handled)
{
throw new InvalidOperationException($"No support for handled events of {prop.Name}");
}
#if XAML
var dep = target as DependencyObject;
if (dep != null)
{
var agg = (NEventAggregator)dep.GetValue(AggregatorProperty);
if (agg == null)
{
dep.SetValue(AggregatorProperty, agg = new NEventAggregator());
}
var adapter = agg[prop];
if (adapter == null)
{
agg[prop] = adapter = new NEventAdapter(prop)
{
Action = action
};
subscribe(target, adapter);
}
else
{
adapter.Action = action;
}
}
else
#elif XFORMS
var dep = target as BindableObject;
if (dep != null)
{
var agg = (NEventAggregator)dep.GetValue(AggregatorProperty);
if (agg == null)
{
dep.SetValue(AggregatorProperty, agg = new NEventAggregator());
}
var adapter = agg[prop];
if (adapter == null)
{
agg[prop] = adapter = new NEventAdapter(prop)
{
Action = action
};
subscribe(target, adapter);
}
else
{
adapter.Action = action;
}
}
else
#endif
{
subscribe(target, new NEventAdapter(prop)
{
Action = action
});
}
}
public NContentProperty Content(Type type, NProperty content)
{
_items[type] = content;
return(this);
}
void Insert(NProperty key, object value)
{
Add(key).Value = value;
}
/// <summary>
/// Indicates whether specified property is set
/// </summary>
/// <param name="key">Property key</param>
/// <returns>True is property is set, false otherwise</returns>
public bool HasKey(NProperty key)
{
return(GetEntry(key) != null);
}
