public override void Selected(UIPickerView pickerView, System.nint row, System.nint compononet)
{
string Box = GroupNames[(int)row];
SelectedGroup = Box;
GroupChanged?.Invoke(null, null);
}
/// <summary>
/// Handles <see cref="GroupInfoMessages.SetGroup"/>.
/// </summary>
/// <param name="bs">The <see cref="BitStream"/> to read from.</param>
void ReadSetGroup(BitStream bs)
{
_members.Clear();
_founder = null;
var isInGroup = bs.ReadBool();
if (isInGroup)
{
// Read the group members
var numMembers = bs.ReadByte();
var members = bs.ReadStrings(numMembers);
_members.AddRange(members);
// Read the founder's name
_founder = bs.ReadString();
}
// Raise events
OnGroupChanged();
if (GroupChanged != null)
{
GroupChanged.Raise(this, EventArgs.Empty);
}
}
private static void ProcessSetGroupPermissionsRequest(ref BinaryReader reader, int playerNumber)
{
if (Network.NetworkMode == NetworkMode.Server)
{
if (!Network.Players[playerNumber].Group.IsAdmin)
{
return;
}
int id = reader.ReadInt32();
Group group = Network.GetGroupByID(id);
int permissionsLength = reader.ReadInt32();
group.ImportPermissions(reader.ReadBytes(permissionsLength));
DatabaseController.SetGroupPermissions(group);
for (int i = 0; i < Network.Players.Length; i++)
{
//if (Network.Players[i].Group?.ID == group.ID)
if (Network.Players[i].Group == group)
{
SendPlayerPermissions(i);
}
}
GroupChanged?.Invoke(null, EventArgs.Empty);
}
}
/// <summary>
/// Fires the ServerInfoChanged event
/// </summary>
/// <param name="serverAddress"></param>
protected void FireGroupChanged(SourceDiscoveryGroup group)
{
if (GroupChanged != null)
{
GroupChanged.Invoke(this, new GroupEventArgs(group));
}
}
void UpdateGroupsComponentAddedOrRemoved(Entity entity, int index, IComponent component)
{
List <EntityGroup> groups = m_GroupsForIndex[index];
if (groups != null)
{
List <GroupChanged> events = m_GroupChangedListPool.Get();
for (int i = 0; i < groups.Count; i++)
{
events.Add(groups[i].HandleEntity(entity));
}
for (int i = 0; i < events.Count; i++)
{
GroupChanged groupChangedEvent = events[i];
if (groupChangedEvent != null)
{
groupChangedEvent(groups[i], entity, index, component);
}
}
m_GroupChangedListPool.Push(events);
}
}
public Collector(Group <IEntity>[] groups, GroupEvent[] groupEvents)
{
m_Groups = groups;
m_CollectedEntities = new HashSet <IEntity>();
m_GroupEvents = groupEvents;
if (groupEvents.Length != groupEvents.Length)
{
throw new GameFrameworkException("Unbalanced count with groups and group events");
}
m_AddEntityCache = AddEntity;
}
private void PbiTreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (e.NewValue is TreeViewPbiGroup newTreeViewPbiGroup)
{
SelectedGroup = newTreeViewPbiGroup.Group as Group;
SelectedDataset = null;
GroupChanged?.Invoke(this, EventArgs.Empty);
}
else if (e.NewValue is TreeViewPbiDataset newTreeViewPbiDataset)
{
SelectedGroup = null;
SelectedDataset = newTreeViewPbiDataset.Dataset;
DatasetChanged?.Invoke(this, EventArgs.Empty);
}
}
/// <summary>
/// Clears all of the group information.
/// </summary>
public void Clear()
{
var changed = IsInGroup;
_members.Clear();
_founder = null;
if (changed)
{
if (GroupChanged != null)
{
GroupChanged.Raise(this, EventArgs.Empty);
}
}
}
/// Creates a Collector and will collect changed entities
/// based on the specified groupEvents.
public Collector(IGroup[] groups, GroupEvent[] groupEvents)
{
_groups = groups;
_collectedEntities = new HashSet <IEntity>(EntityEqualityComparer <IEntity> .comparer);
_groupEvents = groupEvents;
if (groups.Length != groupEvents.Length)
{
throw new CollectorException(
"Unbalanced count with groups (" + groups.Length +
") and group events (" + groupEvents.Length + ").",
"Group and group events count must be equal."
);
}
_addEntityCache = addEntity;
Activate();
}
protected void Load(IEnumerable <TModel> units, IUnitOfWork unitOfWork, bool isNew)
{
UnitOfWork = unitOfWork;
var unitsArray = units as TModel[] ?? units.ToArray();
//проставляем количество родительских юнитов включенного оборудования
var productsIncluded = unitsArray.SelectMany(x => x.ProductsIncluded).ToList();
foreach (var productIncluded in productsIncluded)
{
productIncluded.ParentsCount = unitsArray.Count(x => x.ProductsIncluded.Contains(productIncluded));
}
//создаем контейнер
Groups = new GroupsCollection <TModel, TGroup, TMember>(GetGroups(unitsArray), isNew);
Groups.SumChanged += () => { RaisePropertyChanged(nameof(Sum)); };
// реакция на выбор группы
Groups.SelectedGroupChanged += group =>
{
RemoveCommand?.RaiseCanExecuteChanged();
AddProductIncludedCommand?.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(Prices));
RaisePropertyChanged(nameof(PricesLaborHours));
};
// реакция на выбор включенного оборудования
Groups.SelectedProductIncludedChanged += productIncluded =>
{
(RemoveProductIncludedCommand)?.RaiseCanExecuteChanged();
SetCustomFixedPriceCommand?.RaiseCanExecuteChanged();
};
// событие для того, чтобы вид перепривязал группы
RaisePropertyChanged(nameof(Groups));
// подписка на события изменения каждой группы и их членов
((IValidatableChangeTrackingCollection <TGroup>)Groups).PropertyChanged += (sender, args) => GroupChanged?.Invoke();
Groups.CollectionChanged += (sender, args) => GroupChanged?.Invoke();
// обновление прайса каждой группы
Groups.ForEach(RefreshPrice);
}
protected void subjectChosen(object chosenObject)
{
try {
var id = Convert.ToInt32(chosenObject);
if (id == -1)
{
return;
}
var group = CurrentGroups.SingleOrDefault(s => s.GroupId == id);
var isChosen = setChosenGroup(group);
if (isChosen)
{
GroupChanged?.Invoke(PlatformServices.Preferences.GroupId, group.GroupName);
}
} catch (Exception ex) {
AppLogs.Log(ex);
}
}
// Entity removed observable
public IObservable <GroupChangedEventArgs <T> > OnEntityRemovedAsObservable <T>()
{
var entityRemoved = Observable.FromEvent <GroupChanged, GroupChangedEventArgs <T> >(handler => {
GroupChanged entityRemovedHandler = (group, entity, index, component) => {
if (component is T)
{
var args = new GroupChangedEventArgs <T>();
args.group = group;
args.entity = entity;
args.index = index;
args.component = (T)component;
handler(args);
}
};
return(entityRemovedHandler);
},
entityRemovedHandler => OnEntityRemoved += entityRemovedHandler,
entityRemovedHandler => OnEntityRemoved -= entityRemovedHandler);
return(entityRemoved);
}
protected virtual void OnGroupChanged()
{
GroupChanged?.Invoke(this, null);
}
private void GroupsChanged(GroupChanged obj)
{
AllGroups.Clear();
BLL.GroupBLL.GetAllGroups().ToList().ForEach(x => AllGroups.Add(x));
}
private void Groups_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
GroupChanged?.Invoke(this, EventArgs.Empty);
}
public void AddNew(Group @group)
{
groups.AddLast(@group);
GroupChanged?.Invoke();
}
private void OnCommunityChanged()
{
GroupChanged?.Invoke();
}
protected void OnGroupChanged(string old, string @new)
{
GroupChanged?.Invoke(this, new ObjectEventArgs <string, string>(old, @new));
}
