private void cmdReturn_Click(object sender, RoutedEventArgs e)
{
var userCredit = (Models.UserCreditBalance)((FrameworkElement)sender).DataContext;
if (null == userCredit)
{
return;
}
var win = new Windows.Collector.Credit.CollectorCreditReturnWindow();
win.Owner = Application.Current.MainWindow;
win.Title = userCredit.Description;
win.Setup(_tsb, userCredit);
if (win.ShowDialog() == false)
{
return;
}
if (null != ItemChanged)
{
ItemChanged.Call(this, System.EventArgs.Empty);
}
RefreshUserCredits();
}
void DomNode_AttributeChanged(object sender, AttributeEventArgs e)
{
if (IsLayerItem(e.DomNode))
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(e.DomNode));
}
}
private void Initialize()
{
ItemsAdded.Subscribe(x =>
{
_toInsert.Add(x);
//Dump();
});
ItemsRemoved.Subscribe(x =>
{
if (x.IsNew)
{
_toInsert.Remove(x);
//Dump();
}
else
{
_toUpdate.Remove(x);
_toDelete.Add(x);
// Dump();
}
});
ItemChanged.Subscribe(x =>
{
if (!x.Sender.IsNew)
{
_toUpdate.Add(x.Sender);
// Dump();
}
});
}
protected void OnItemChanged(T[] addedItems, T[] removedItems)
{
if (ItemChanged != null)
{
ItemChanged.Invoke(addedItems, removedItems);
}
}
private void OnItemChanged(string name)
{
if (ItemChanged != null)
{
ItemChanged.Invoke(name);
}
}
private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e)
{
if (RaiseValueChanged)
{
DataGridViewCheckBoxCell cc;
ItemResult ItemChanged;
if (dataGridView1.Columns[e.ColumnIndex].Name.Equals("CheckedIn"))
{
cc = dataGridView1[e.ColumnIndex, e.RowIndex] as DataGridViewCheckBoxCell;
ItemChanged = GenerateItemResult(e.RowIndex);
if ((bool)cc.Value)
{
ItemChanged.LastCheckInValue = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
(dataGridView1["LastCheckIn", e.RowIndex] as DataGridViewTextBoxCell).Value = ItemChanged.LastCheckInValue;
ItemChanged.UpsertCheckInOut(Form1.MasterConnection, true);
dataGridView1.Rows[e.RowIndex].DefaultCellStyle.BackColor = System.Drawing.Color.LightGreen;
//Cursor.Current = Cursors.WaitCursor;
}
else
{
ItemChanged.LastCheckOutValue = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
(dataGridView1["LastCheckOut", e.RowIndex] as DataGridViewTextBoxCell).Value = ItemChanged.LastCheckOutValue;
ItemChanged.UpsertCheckInOut(Form1.MasterConnection, false);
dataGridView1.Rows[e.RowIndex].DefaultCellStyle.BackColor = System.Drawing.Color.LightPink;
//Cursor.Current = Cursors.WaitCursor;
}
}
}
}
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();
});
}
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 DomNode_AttributeChanged(object sender, AttributeEventArgs e)
{
if (IsPrototypeItem(e.DomNode, e.DomNode.Parent))
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(e.DomNode));
}
}
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 TValue this[TKey key] {
get { return(Base[key]); }
set {
Base[key] = value;
ItemChanged?.Invoke(this, new NotifyItemChangedEventArgs <TKey>(key));
}
}
void setupCollection(IScheduler sched)
{
ChangeTrackingEnabled = true;
_sched = sched ?? RxApp.DeferredScheduler;
invalidateHash();
ItemsAdded.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
CreatedOn[x.ContentHash] = _sched.Now;
UpdatedOn[x.ContentHash] = _sched.Now;
});
ItemsRemoved.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
CreatedOn.Remove(x.ContentHash);
UpdatedOn.Remove(x.ContentHash);
});
ItemChanged.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
UpdatedOn[x.Sender.ContentHash] = _sched.Now;
});
Changed.Subscribe(_ => invalidateHash());
}
private void GenerateFlat(DataItem parent)
{
Beginning.Raise(this, EventArgs.Empty);
var items = s_random.Next(5, 16);
for (var i = 0; i < items; i++)
{
var data = CreateItem(parent);
data.ItemChanged += DataItemChanged;
if (parent != null)
{
parent.Children.Add(data);
}
else
{
m_data.Add(data);
}
ItemInserted.Raise(this, new ItemInsertedEventArgs <object>(-1, data, parent));
}
if (parent != null)
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(parent));
}
Ending.Raise(this, EventArgs.Empty);
Ended.Raise(this, EventArgs.Empty);
}
private void ModifySelected(IEnumerable <object> selection)
{
Beginning.Raise(this, EventArgs.Empty);
foreach (var obj in selection)
{
var data = obj.As <DataItem>();
if (data == null)
{
continue;
}
switch (data.Type)
{
case DataType.Integer:
data.Value = (int)data.Value + s_random.Next(2, 6);
break;
case DataType.String:
data.Value = string.Format("{0}{1}", data.Value, Alphabet[s_random.Next(0, Alphabet.Length)]);
break;
}
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(data));
}
Ending.Raise(this, EventArgs.Empty);
Ended.Raise(this, EventArgs.Empty);
}
public void Push(TItem obj)
{
data.Add(obj);
ItemChanged?.Invoke(new StackEventData <TItem> {
IsPushed = true, Value = obj
});
}
public static ObservableCollectionEx <IItemChanged> ToItemsChanged(this Tree collection, Commit commit, Uri repoPath, IMediatorService mediator, int secondsToTimeout,
Action <Commit, ObjectId, int> onViewChangeDetails)
{
var result = new List <IItemChanged>();
collection.ToList().ForEach(p =>
{
//var isModified = p.Target.
var itemChanged = new ItemChanged()
{
FilePath = p.Path,
//ChangeType = p.Mode,
//HasBeenModified = isModified,
OnViewChanges = new DelegateCommand(ignore =>
{
// TODO: figure out how to do this
if (false)
{
onViewChangeDetails(commit, p.Target.Id, secondsToTimeout);
}
})
// TODO: implement
//HasLocalEdits =
};
result.Add(itemChanged);
});
return(new ObservableCollectionEx <IItemChanged>(result));
}
protected virtual void OnItemChange()
{
ItemChanged?.Invoke(this, new PlaylistItemChangedEventArgs()
{
Changes = ItemChanges.None
});
}
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);
}
public static ObservableCollectionEx <IItemChanged> ToItemsChanged(this SvnChangeItemCollection collection, SvnRevision latestRevision, Uri repoPath, IMediatorService mediator, int secondsToTimeout, Action <SvnRevision, Uri, SvnChangeItem, int> onViewChangeDetails)
{
var result = new List <IItemChanged>();
collection.ToList().ForEach(p =>
{
var isModified = p.Action == SvnChangeAction.Modify;
var itemChanged = new ItemChanged()
{
FilePath = p.RepositoryPath.ToString(),
ChangeType = Enum.GetName(typeof(SvnChangeAction), p.Action)[0].ToString(CultureInfo.InvariantCulture),
HasBeenModified = isModified,
OnViewChanges = new DelegateCommand(ignore =>
{
if (isModified)
{
onViewChangeDetails(latestRevision, repoPath, p, secondsToTimeout);
}
})
// TODO: implement
//HasLocalEdits =
};
result.Add(itemChanged);
});
return(new ObservableCollectionEx <IItemChanged>(result));
}
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);
}
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);
}
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());
}
}
public override void Selected(UIPickerView pickerView, nint row, nint component)
{
selectedIndex = (int)row;
if (ItemChanged != null)
{
ItemChanged.Invoke(this, new EventArgs());
}
}
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);
}
private void DomNode_AttributeChanged(object sender, AttributeEventArgs e)
{
Resource resource = e.DomNode.As <Resource>();
if (resource != null)
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(resource));
}
}
private void DomNode_AttributeChanged(object sender, AttributeEventArgs e)
{
Character character = e.DomNode.As <Character>();
if (character != null)
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(character));
}
}
private void DomNode_AttributeChanged(object sender, AttributeEventArgs e)
{
Event _event = e.DomNode.As <Event>();
if (_event != null)
{
ItemChanged.Raise(this, new ItemChangedEventArgs <object>(_event));
}
}
