//public void AddItem(int ID)
//{
// items[ID].enabled = true;
// if (onItemChangedCallBack != null)
// onItemChangedCallBack.Invoke();
//}
public void Add(Item item, bool showMenu = true)
{
items.Add(item);
if (onItemChangedCallBack != null)
{
onItemChangedCallBack.Invoke();
}
if (showMenu && onItemChangeNotif != null)
{
onItemChangeNotif.Invoke();
}
}
public bool AddItem(Item item)
{
if (items.Count >= inventorySize)
{
print("Not enough space!");
return(false);
}
items.Add(item);
if (itemChanged != null)
{
itemChanged.Invoke();
}
return(true);
}
public async Task PlaylistItemChanged(MultiplayerPlaylistItem item)
{
if (Room == null)
{
return;
}
var playlistItem = await createPlaylistItem(item, true).ConfigureAwait(false);
Scheduler.Add(() =>
{
if (Room == null)
{
return;
}
Debug.Assert(APIRoom != null);
Room.Playlist[Room.Playlist.IndexOf(Room.Playlist.Single(existing => existing.ID == item.ID))] = item;
int existingIndex = APIRoom.Playlist.IndexOf(APIRoom.Playlist.Single(existing => existing.ID == item.ID));
APIRoom.Playlist.RemoveAt(existingIndex);
APIRoom.Playlist.Insert(existingIndex, playlistItem);
// If the currently-selected item was the one that got replaced, update the selected item to the new one.
if (CurrentMatchPlayingItem.Value?.ID == playlistItem.ID)
{
CurrentMatchPlayingItem.Value = playlistItem;
}
ItemChanged?.Invoke(item);
RoomUpdated?.Invoke();
});
}
public void SelectItem(int row, int column)
{
_borders[row][_values[row]].BorderBrush = null;
_values[row] = column;
_borders[row][column].BorderBrush = new SolidColorBrush(_borderColors[row]);
ItemChanged?.Invoke(row, column);
}
public void Push(TItem obj)
{
data.Add(obj);
ItemChanged?.Invoke(new StackEventData <TItem> {
IsPushed = true, Value = obj
});
}
public TValue this[TKey key] {
get { return(Base[key]); }
set {
Base[key] = value;
ItemChanged?.Invoke(this, new NotifyItemChangedEventArgs <TKey>(key));
}
}
protected void OnItemChanged(T[] addedItems, T[] removedItems)
{
if (ItemChanged != null)
{
ItemChanged.Invoke(addedItems, removedItems);
}
}
public bool TryTakeItems(string itemId, int quantity, out int remainingQuantity)
{
if (quantity <= 0)
{
throw new ArgumentException("Invalid number of items to use");
}
remainingQuantity = GetQuantity(itemId);
if (remainingQuantity < quantity)
{
return(false);
}
remainingQuantity -= quantity;
if (remainingQuantity == 0)
{
_inventoryQuantities.Remove(itemId);
}
else
{
_inventoryQuantities[itemId] = remainingQuantity;
}
ItemChanged?.Invoke(itemId, remainingQuantity, -quantity);
return(true);
}
internal unsafe AddItemResult TryAddItemBuffer(string path, int pos, char *buffer, IRegItem item)
{
if (!GetGroupAndEnd(path, pos, buffer, out ParseResult result))
{
return(AddItemResult.InvalidPath);
}
if (result.HasTrailingSlash)
{
if (result.ContainingGroup.SubGroups.ContainsKey(result.End))
{
return(AddItemResult.ItemAlreadyExists);
}
result.ContainingGroup.SubGroups.Add(result.End, (RegGroup)item);
}
else
{
if (result.ContainingGroup.SubItems.ContainsKey(result.End))
{
return(AddItemResult.ItemAlreadyExists);
}
result.ContainingGroup.SubItems.Add(result.End, item);
}
ItemChanged?.Invoke(this, new EventArgs());
return(AddItemResult.Success);
}
private void AddRuleButton_Click(object sender, EventArgs e)
{
if (m_point != null)
{
IPointRule prt = _factory.CreateDefaultPointRule();
int idx = m_point.RuleCount;
conditionList.AddRuleControl(prt, idx).Focus();
m_point.AddRule(prt);
}
else if (m_line != null)
{
ILineRule lrt = _factory.CreateDefaultLineRule();
int idx = m_line.RuleCount;
conditionList.AddRuleControl(lrt, idx).Focus();
m_line.AddRule(lrt);
}
else if (m_area != null)
{
IAreaRule art = _factory.CreateDefaultAreaRule();
int idx = m_area.RuleCount;
conditionList.AddRuleControl(art, idx).Focus();
m_area.AddRule(art);
}
else if (m_comp != null)
{
ICompositeRule cr = _factory.CreateDefaultCompositeRule();
int idx = m_area.RuleCount;
conditionList.AddRuleControl(cr, idx).Focus();
m_comp.AddCompositeRule(cr);
}
ItemChanged?.Invoke(this, null);
}
private void OnItemChanged(string name)
{
if (ItemChanged != null)
{
ItemChanged.Invoke(name);
}
}
protected virtual void OnItemChange()
{
ItemChanged?.Invoke(this, new PlaylistItemChangedEventArgs()
{
Changes = ItemChanges.None
});
}
protected void OnItemChanged(string message)
{
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new ExchangeItemChangeEventArgs(this, message));
}
}
public Task PlaylistItemChanged(MultiplayerPlaylistItem item)
{
if (Room == null)
{
return(Task.CompletedTask);
}
Scheduler.Add(() =>
{
if (Room == null)
{
return;
}
Debug.Assert(APIRoom != null);
Room.Playlist[Room.Playlist.IndexOf(Room.Playlist.Single(existing => existing.ID == item.ID))] = item;
int existingIndex = APIRoom.Playlist.IndexOf(APIRoom.Playlist.Single(existing => existing.ID == item.ID));
APIRoom.Playlist.RemoveAt(existingIndex);
APIRoom.Playlist.Insert(existingIndex, createPlaylistItem(item));
ItemChanged?.Invoke(item);
RoomUpdated?.Invoke();
});
return(Task.CompletedTask);
}
private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
{
NotifyCollectionChangedEventArgs args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, sender, sender, IndexOf((T)sender));
base.OnCollectionChanged(args);
ItemChanged?.Invoke(sender, e);
}
public override void Selected(UIPickerView pickerView, nint row, nint component)
{
selectedIndex = (int)row;
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new EventArgs());
}
}
protected override void SetItem(int index, T item)
{
base.SetItem(index, item);
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new EventArgs());
}
}
protected override void RemoveItem(int index)
{
base.RemoveItem(index);
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new EventArgs());
}
}
protected override void ClearItems()
{
base.ClearItems();
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new EventArgs());
}
}
private void OnFileCreated(object sender, FileSystemEventArgs e)
{
if (frozen)
{
return;
}
ResetTimer();
ItemChanged?.Invoke(this, e.FullPath, null, false, WatcherChangeTypes.Created);
}
private void MoveRuleDownButton_Click(object sender, EventArgs e)
{
if (m_currentSelection == null)
{
conditionList.SelectedItem = m_lastSelection;
}
conditionList.MoveSelectedRule(true);
ItemChanged?.Invoke(this, null);
}
public void Clear()
{
var keys = Base.Keys.ToArray();
Base.Clear();
foreach (var key in keys)
{
ItemChanged?.Invoke(this, new NotifyItemChangedEventArgs <TKey>(key));
}
}
/// <summary>
/// Fires the ItemChanged event, optionally specifying a different sender.
/// </summary>
/// <param name="sender">Sender that raised the event.</param>
protected virtual void OnItemChanged(object sender)
{
if (_itemChangedSuspend > 0)
{
_changeOccured = true;
return;
}
ItemChanged?.Invoke(sender, EventArgs.Empty);
}
/// <summary>
/// Occurs when the item is changed. If this list is not suspended, it will forward the change event
/// on. Otherwise, it will ensure that when resume events is called that the on change method
/// is fired at that time.
/// </summary>
/// <param name="sender">The sender that raised the event.</param>
protected virtual void OnItemChanged(object sender)
{
if (EventsSuspended)
{
_hasChanged = true;
}
else
{
ItemChanged?.Invoke(sender, EventArgs.Empty);
}
}
public ScrollableList(List <T> DataSource, Rect frame, string Title = null) : base(frame, Title)
{
_source = DataSource;
data = new(getInnerBound(), DataSource);
data.SelectedItemChanged += (e) => {
ItemChanged?.Invoke(this, e);
};
Add(data);
}
public MenuItem RemoveItem(string id)
{
if (!items.TryGetValue(id, out MenuItem itemToRemove))
{
return(null);
}
items.Remove(id);
ItemRemoved?.Invoke(this, itemToRemove, id);
ItemChanged?.Invoke(this);
return(itemToRemove);
}
public void UpdatedExternal(TIdType id)
{
if (!data.ContainsKey(id))
{
return;
}
var res = data[id];
OnUpdate(res);
ItemChanged?.Invoke(this, new ItemChangeEvent <TInterfaceType>(res));
}
public bool Remove(Item item)
{
if (items.Contains(item))
{
item.QuantityChange -= OnItemQuantityChange;
items.Remove(item);
ItemChanged?.Invoke(item);
return(true);
}
return(false);
}
private void OnItemQuantityChange(Item item)
{
// Remove the item if it was all used up. -->
if (item.Quantity <= 0)
{
Remove(item);
}
else
{
ItemChanged?.Invoke(item);
}
}
public bool Remove(KeyValuePair <TKey, TValue> item)
{
if (Base.Remove(item))
{
ItemChanged?.Invoke(this, new NotifyItemChangedEventArgs <TKey>(item.Key));
return(true);
}
else
{
return(false);
}
}
