public void OnListChange(string server, int list, ListChangeType changeType)
{
_isListChanged = true;
_listChange = new CallbackObjects.ListChange {
ServerName = server, ListIndex = list, ListChangeType = changeType
};
}
/// <summary>
/// Adds or removes machines from the machines list.
/// </summary>
/// <param name="machine">Machine to add or delete.</param>
/// <param name="listChangeType">List change type.</param>
public void ChangeMachine(Machine machine, ListChangeType listChangeType)
{
switch (listChangeType)
{
case ListChangeType.AutoAdd:
case ListChangeType.AddByLoad:
case ListChangeType.AddByUser:
// If Machine already exists we don't need to do anything else here;
if (HasMachineWithId(machine.MachineId))
{
return;
}
Machines.Add(machine);
break;
case ListChangeType.RemoveByUser:
Machines.Remove(machine);
break;
case ListChangeType.RemoveByEvent:
if (machine.Services.Count == 0)
{
Machines.Remove(machine);
}
break;
}
OnMachineListChanged(machine, listChangeType);
}
public void OnListChange(string server, int list, ListChangeType changeType)
{
lock (_channelsLocker)
{
if (_channels.Contains(new Channel(server, list)))
{
WrapWcfCallback(() => _callback.OnListChange(server, list, changeType));
}
}
}
private void onListChanged(List <TItem> items, ListChangeType changeType)
{
var onListChanged = OnListChanged;
if (onListChanged == null)
{
return;
}
onListChanged.Invoke(new AGSHashSetChangedEventArgs <TItem>(changeType, items));
}
public ListChangedEventArgs(
ListChangeType changeType,
int changedSegmentStartIndex,
T[] newSegmentItems,
T[] oldSegmentItems)
{
_changeType = changeType;
_oldSegmentItems = oldSegmentItems;
_newSegmentItems = newSegmentItems;
_changedSegmentStartIndex = changedSegmentStartIndex;
}
private void OnChanged(
ListChangeType changeType,
int changedSegmentStartIndex,
T[] newSegmentItems,
T[] oldSegmentItems)
{
OnChanged(
new ListChangedEventArgs <T>(
changeType,
changedSegmentStartIndex,
newSegmentItems,
oldSegmentItems));
}
/// <summary>
/// Fires the <see cref="MachineListChanged"/> event.
/// </summary>
/// <param name="machine">Machine instance.</param>
/// <param name="listChangeType">Machine list change type.</param>
protected virtual void OnMachineListChanged(Machine machine, ListChangeType listChangeType)
{
if (listChangeType == ListChangeType.RemoveByEvent || listChangeType == ListChangeType.RemoveByUser)
{
int removedServicesQuantity = machine.RemoveAllServices();
if (removedServicesQuantity > 0)
{
SavetoFile();
}
if (machine != LocalMachine)
{
machine.MachineStatusChanged -= OnMachineStatusChanged;
machine.ServiceListChanged -= OnMachineServiceListChanged;
machine.ServiceStatusChanged -= OnMachineServiceStatusChanged;
machine.ServiceStatusChangeError -= OnMachineServiceStatusChangeError;
}
}
else
{
if (listChangeType == ListChangeType.Updated)
{
SavetoFile();
}
machine.MachineStatusChanged -= OnMachineStatusChanged;
machine.ServiceListChanged -= OnMachineServiceListChanged;
machine.ServiceStatusChanged -= OnMachineServiceStatusChanged;
machine.ServiceStatusChangeError -= OnMachineServiceStatusChangeError;
machine.WorkbenchInstallationChanged -= OnWorkbenchInstallationChanged;
machine.MachineStatusChanged += OnMachineStatusChanged;
machine.ServiceListChanged += OnMachineServiceListChanged;
machine.ServiceStatusChanged += OnMachineServiceStatusChanged;
machine.ServiceStatusChangeError += OnMachineServiceStatusChangeError;
machine.WorkbenchInstallationChanged += OnWorkbenchInstallationChanged;
}
if (MachineListChanged != null)
{
MachineListChanged(machine, listChangeType);
}
}
protected virtual void OnComponentsChanged(ListChangeType changeType, int index1, int index2)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AGS.API.AGSListChangedEventArgs`1"/> class.
/// </summary>
/// <param name="changeType">Change type.</param>
/// <param name="item">Item.</param>
/// <param name="index">Index.</param>
public AGSListChangedEventArgs(ListChangeType changeType, TItem item, int index)
{
ChangeType = changeType;
Item = item;
Index = index;
}
private void onListChanged(TItem item, int index, ListChangeType changeType)
{
OnListChanged.Invoke(this, new AGSListChangedEventArgs <TItem>(changeType, item, index));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AGS.API.AGSListChangedEventArgs`1"/> class.
/// </summary>
/// <param name="changeType">Change type.</param>
/// <param name="items">Items.</param>
public AGSListChangedEventArgs(ListChangeType changeType, IEnumerable <AGSListItem <TItem> > items)
{
ChangeType = changeType;
_items = items;
}
protected virtual void OnSlotListChanged(ListChangeType ct, params SlotDefinition[] slt)
{
EventHandler<SlotListChangedEventArgs> h = AfterSlotListChanged;
if (h != null)
h(this, new SlotListChangedEventArgs(ct, slt));
}
protected virtual void OnExtension(ListChangeType ct, params ClassDefinition[] extensions)
{
EventHandler<ExtensionListChangedEventArgs> h = AfterExtensionListChanged;
if (h != null) {
ExtensionListChangedEventArgs args = new ExtensionListChangedEventArgs(ct, extensions);
h(this, args);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AGS.API.AGSHashSetChangedEventArgs`1"/> class.
/// </summary>
/// <param name="changeType">Change type.</param>
/// <param name="item">Item.</param>
public AGSHashSetChangedEventArgs(ListChangeType changeType, TItem item)
{
ChangeType = changeType;
_singleItem = item;
}
protected MethodDefinition[] InnerMethods; // TODO: может это и излишне...
#endregion Fields
#region Constructors
public MethodListChangedEventArgs(ListChangeType ct, params MethodDefinition[] mth)
{
InnerChangeType = ct;
InnerMethods = mth;
}
protected ClassDefinition[] InnerExtensions; // TODO: может это и излишне...
#endregion Fields
#region Constructors
public ExtensionListChangedEventArgs(ListChangeType ct, params ClassDefinition[] mth)
{
InnerChangeType = ct;
InnerExtensions = mth;
}
protected SlotDefinition[] InnerSlots; // TODO: может это и излишне...
#endregion Fields
#region Constructors
public SlotListChangedEventArgs(ListChangeType ct, params SlotDefinition[] slt)
{
InnerChangeType = ct;
InnerSlots = slt;
}
private void OnComponentChanged(ListChangeType listChangeType, int i1, int i2)
{
switch (listChangeType)
{
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.Add:
ComponentTemplatesList.Add(new EntryComponentTemplate(TemplateInstance.Componets[i1]));
ObserversList.ForEach(x => x.Componets.Add(ComponentTemplatesList[ComponentTemplatesList.Count - 1].AddObserver()));
TemplateInstance.Componets[i1].OnEditModeModified += () => ApplyComponentToObservers(TemplateInstance.Componets.IndexOf(TemplateInstance.Componets[i1]));
break;
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.Duplicate:
ComponentTemplatesList.Insert(i1 + 1, new EntryComponentTemplate(TemplateInstance.Componets[i1 + 1]));
ObserversList.ForEach(x => x.Componets.Insert(i1 + 1, ComponentTemplatesList[i1 + 1].AddObserver()));
TemplateInstance.Componets[i1].OnEditModeModified += () => ApplyComponentToObservers(TemplateInstance.Componets.IndexOf(TemplateInstance.Componets[i1]));
break;
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.Remove:
if (ComponentTemplatesList.Count == 0)
{
goto case ListChangeType.Clear;
}
ComponentTemplatesList[i1].ClearObservers();
//remove component from entry observers
ObserversList.ForEach(x => { x.Componets.RemoveAt(i1); });
//remove component from template
ComponentTemplatesList.RemoveAt(i1);
break;
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.Clear:
foreach (var entryComponent in ComponentTemplatesList)
{
entryComponent.ClearObservers();
}
ComponentTemplatesList.Clear();
ObserversList.ForEach(x => { x.Componets.Clear(); });
break;
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.Reorder:
var temp = ComponentTemplatesList[i1];
ComponentTemplatesList[i1] = ComponentTemplatesList[i2];
ComponentTemplatesList[i2] = temp;
foreach (var observer in ObserversList)
{
var temp2 = observer.Componets[i1];
observer.Componets[i1] = observer.Componets[i2];
observer.Componets[i2] = temp2;
}
break;
//---------------------------------------------------------------------------------------------------------------------
case ListChangeType.None:
case ListChangeType.DataChanged:
default:
break;
//---------------------------------------------------------------------------------------------------------------------
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AGS.API.AGSHashSetChangedEventArgs`1"/> class.
/// </summary>
/// <param name="changeType">Change type.</param>
/// <param name="items">Items.</param>
public AGSHashSetChangedEventArgs(ListChangeType changeType, IEnumerable <TItem> items)
{
ChangeType = changeType;
_items = items;
}
/// <summary>
/// Fires the <see cref="MachineServiceListChanged"/> event.
/// </summary>
/// <param name="machine">Machine instance.</param>
/// <param name="service">MySQLService instance.</param>
/// <param name="listChangeType">Service list change type.</param>
protected virtual void OnMachineServiceListChanged(Machine machine, MySqlService service, ListChangeType listChangeType)
{
switch (listChangeType)
{
case ListChangeType.RemoveByEvent:
case ListChangeType.RemoveByUser:
MachineServiceListChanged?.Invoke(machine, service, listChangeType);
if (machine.Services.Count == 0)
{
ChangeMachine(machine, ListChangeType.RemoveByEvent);
}
break;
case ListChangeType.AutoAdd:
if (machine.Services.Count == 1)
{
ChangeMachine(machine, ListChangeType.AutoAdd);
}
MachineServiceListChanged?.Invoke(machine, service, listChangeType);
break;
default:
MachineServiceListChanged?.Invoke(machine, service, listChangeType);
break;
}
SaveToFile();
}
protected virtual void OnMethodListChanged(ListChangeType ct, params MethodDefinition[] methods)
{
EventHandler<MethodListChangedEventArgs> h = AfterMethodListChanged;
if (h != null)
h(this, new MethodListChangedEventArgs(ct, methods));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AGS.API.AGSListChangedEventArgs`1"/> class.
/// </summary>
/// <param name="changeType">Change type.</param>
/// <param name="item">Item.</param>
public AGSListChangedEventArgs(ListChangeType changeType, AGSListItem <TItem> item)
{
ChangeType = changeType;
_singleItem = item;
}
protected virtual void UpdateSlotListAfterExtention(ListChangeType ct, params ClassDefinition[] exts)
{
if (exts == null || exts.Length == 0) return;
// собираем у себя все слоты родителей
foreach (ClassDefinition extension in exts) {
if (ct == ListChangeType.Remove) {
// TODO: дописать (см. так же RemoveSlot
;
} else {
foreach (SlotDefinition sd in extension.Slots) {
// TODO: что делать с конфликтами?
// XXX Не правильно! нужно проверять, где находится extention
// в списке наследования, до или после cd.ClassDeclared...
InnerSlots[sd.Name] = sd;
}
// сначала снимаем, потом навешиваем обработчики, что бы
// не было двойного навешивания...
extension.AfterSlotListChanged -= OnExtensionSlotListChanged;
extension.AfterMethodListChanged -= OnExtensionMethodListChanged;
extension.AfterExtensionListChanged -= OnExtensionExtend;
// TODO: объединить диспечеры!
extension.AfterSlotListChanged += OnExtensionSlotListChanged;
extension.AfterMethodListChanged += OnExtensionMethodListChanged;
extension.AfterExtensionListChanged += OnExtensionExtend;
}
}
}
private void onListChanged(TItem item, ListChangeType changeType)
{
OnListChanged.FireEvent(this, new AGSHashSetChangedEventArgs <TItem>(changeType, item));
}
