/// <summary>
/// Populates the display list with the provided data elements.
/// </summary>
///
/// <param name="data">The data to use when populating the list.</param>
///
/// <remarks>
/// Any existing view elements will be removed from the list before populating
/// the list with <paramref name="data"/>. One display element is added for each
/// element in <paramref name="data"/>, and the display element is automatically
/// populated with the corresponding data element. Any existing display elements
/// will be reused in order to reduce object instantiation costs.
/// </remarks>
public void Populate(List <D> data)
{
_data = data ?? throw new ArgumentNullException();
// "Remove" all active elements.
foreach (var element in this)
{
OnElementRemoved(element);
ElementRemoved?.Invoke(element);
}
// Add a display element for every data element in the list.
for (int index = 0; index < _data.Count; index += 1)
{
var element = GetOrAddElement(index);
element.Populate(_data[index]);
OnElementAdded(element);
ElementAdded?.Invoke(element);
}
// Disable any leftover display elements that were previously active in the
// list but are no longer needed.
for (int index = _data.Count; index < _elements.Count; index += 1)
{
_elements[index].gameObject.SetActive(false);
}
OnPopulated();
}
internal bool AddElement(GraphElement element)
{
Ensure.Argument.NotNull(element, nameof(element));
var owner = element.Owner;
if (owner != null)
{
if (owner == this)
{
return(false);
}
throw new InvalidOperationException(
"Attempt to add element which belongs to another graph to current graph.");
}
bool added = _elements.Add(element);
Debug.Assert(added);
element._OnAddedToGraph(this);
OnElementAdded(element);
ElementAdded?.Invoke(this, element);
return(true);
}
public void AddingRecursively(Node <T> node, T data)
{
switch (ComparerT.Compare(node.Data, data) <= 0)
{
case true:
if (node.Right == null)
{
node.Right = new Node <T>(data);
Count++;
TreeEventArgs <T> args = new TreeEventArgs <T>(data, $"Element {data} was added into the tree");
ElementAdded?.Invoke(this, args);
}
else
{
AddingRecursively(node.Right, data);
}
break;
case false:
if (node.Left == null)
{
node.Left = new Node <T>(data);
Count++;
TreeEventArgs <T> args = new TreeEventArgs <T>(data, $"Element {data} was added into the tree");
ElementAdded?.Invoke(this, args);
}
else
{
AddingRecursively(node.Left, data);
}
break;
}
}
private void OnElementAdded(System.Drawing.PointF pointF)
{
if (ElementAdded != null)
{
ElementAdded.Invoke(this, pointF);
}
}
public void AddNew(TModel modelObject)
{
var modelObjectKeyValue = KeyAttribute.GetKeyValue(modelObject);
AssertKeyNotExists(modelObjectKeyValue);
UpdateCollection(modelObjectKeyValue, modelObject);
ElementAdded?.Invoke(modelObject);
}
/// <summary>
/// Adds element to the tree according to comparer
/// </summary>
/// <param name="item">Object that should be added in tree</param>
/// <exception cref="ArgumentNullException">Thrown if parameter was null</exception>
public void Add(T item)
{
if (item is null)
{
throw new ArgumentNullException(nameof(item));
}
var newNode = new TreeNode <T>(_comparer)
{
Value = item
};
TreeNode <T> before = null;
var after = _head;
while (after != null)
{
before = after;
if (_comparer.Compare(after.Value, item) > 0)
{
after = after.Left;
}
else if (_comparer.Compare(after.Value, item) < 0)
{
after = after.Right;
}
else if (_comparer.Compare(item, after.Value) == 0)
{
while (!(after is null))
{
if (after.Right is null)
{
after.Right = newNode;
Count++;
ElementAdded?.Invoke(this, new TreeEventArgs <T>(item, "Aded"));
return;
}
after = after.Right;
}
}
}
if (_head == null)
{
_head = newNode;
}
else
{
if (before.CompareTo(item) > 0)
{
before.Left = newNode;
}
else
{
before.Right = newNode;
}
}
ElementAdded?.Invoke(this, new TreeEventArgs <T>(item, "Aded"));
Count++;
}
public void Add(T element)
{
if (content.Contains(element))
{
throw new Exception($"Container already contains {element}");
}
content.Add(element);
ElementAdded?.Invoke(this, new ElementEventArgs <T>(element));
}
/// <summary>
/// Adds an element to the hash set.
/// </summary>
public void Add(T element)
{
var contains = hashSet.Contains(element);
((ICollection <T>)hashSet).Add(element);
if (!contains)
{
ElementAdded?.Invoke(this, new ElementAddedEventArgs <T>(element));
}
}
UIElement AddElementRaw(Panel panel, UIElement prefab, IAccessor accessor)
{
var newElement = GameObject.Instantiate(prefab, elementContainer);
newElement.Panel = panel;
newElement.FieldAccesorRaw = accessor;
currentElements.Add(newElement);
ElementAdded?.Invoke(newElement);
return(newElement);
}
private void OnElementAdded(ElementAdded e)
{
var element = GetElement(e.Item.Element);
if (element != null)
{
element.Update();
}
else
{
Add(e.Item);
}
}
public virtual void Add(Set <T> elem)
{
if (elems.Contains(elem))
{
return;
}
if (BeforeElementAdded != null && !BeforeElementAdded.Invoke(elem))
{
return;
}
elems.Add(elem);
ElemCount = elems.OfType <SetElement <T> >().Count();
ElementAdded?.Invoke(elem);
}
public Type Add(Type element)
{
var returnVal = default(Type);
lock (buffer)
{
buffer.AddFirst(element);
if (buffer.Count > MaxSize)
{
returnVal = buffer.Last.Value;
buffer.RemoveLast();
}
}
ElementAdded.Fire(element);
return(returnVal);
}
/// <summary>
/// Adds element to the tree according to comparer
/// </summary>
/// <param name="item">Object that should be added in tree</param>
/// <exception cref="ArgumentNullException">Thrown if parameter was null</exception>
public void Add(T item)
{
if (item is null)
{
throw new ArgumentNullException("item", "item can`t be null");
}
if (Root is null)
{
Root = new Node <T>(item);
Count++;
TreeEventArgs <T> args = new TreeEventArgs <T>(item, $"Element {item} was added into the tree(Root)");
ElementAdded?.Invoke(this, args);
}
else
{
AddingRecursively(Root, item);
}
}
/// <summary>
/// Adds element to the tree according to comparer
/// </summary>
/// <param name="item">Object that should be added in tree</param>
/// <exception cref="ArgumentNullException">Thrown if parameter was null</exception>
public void Add(T item)
{
if (item is null)
{
throw new ArgumentNullException("item");
}
var node = new BinaryTreeNode <T>(item);
var EventArg = new TreeEventArgs <T>(item, "Item has been added");
if (root == null)
{
root = node;
}
else
{
BinaryTreeNode <T> current = root, parent = null;
while (current != null)
{
parent = current;
if (Comparer.Compare(item, current.Value) < 0)
{
current = current.Left;
}
else
{
current = current.Right;
}
}
if (Comparer.Compare(item, parent.Value) < 0)
{
parent.Left = node;
}
else
{
parent.Right = node;
}
}
Count++;
ElementAdded?.Invoke(this, EventArg);
}
public void Add(T element)
{
List.Add(element);
ElementAdded.Invoke(element);
}
private void NotifyElementAdded(T item)
{
ElementAdded?.Invoke(item);
CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
protected void OnAdded(SvgElement element)
{
ElementAdded?.Invoke(this._document, new SvgElementEventArgs {
Element = element
});
}
internal void OnLayoutElementAdded(LayoutElement element)
{
ElementAdded?.Invoke(this, new LayoutElementEventArgs(element));
}
