public static Action DoOrReserve(
this IEventContainer eventContainer,
Action action,
Func <bool> predicate)
{
eventContainer.Subscribe(OnReservedEventTriggered);
if (predicate())
{
UnsubscribeAndAction();
}
return(() => eventContainer.Unsubscribe(OnReservedEventTriggered));
#region Local Methods
void OnReservedEventTriggered(object sender, EventArgs arg)
{
if (predicate())
{
UnsubscribeAndAction();
}
}
void UnsubscribeAndAction()
{
eventContainer.Unsubscribe(OnReservedEventTriggered);
action();
}
#endregion
}
private static Action NewMethod <TEventArg>(IEventContainer <TEventArg> eventContainer, Action action, Func <bool> predicate)
{
eventContainer.Subscribe(OnReservedEventTriggered);
if (predicate())
{
UnsubscribeAndAction();
}
return(() => eventContainer.Unsubscribe(OnReservedEventTriggered));
#region Local Methods
void OnReservedEventTriggered(object sender, TEventArg arg)
{
if (predicate())
{
UnsubscribeAndAction();
}
}
void UnsubscribeAndAction()
{
eventContainer.Unsubscribe(OnReservedEventTriggered);
action();
}
#endregion
}
public override void ApplyBase(IStatContainer stats, IEventContainer events)
{
events.GetEvent(EventInfo.Identifier).Event.OnExecute += Explode;
_damageMult = stats.AddStat(ExplosionDamageFactorInfo, DamageFactorBase * Coeffecient);
_range = stats.AddStat(ExplosionRangeInfo, RangeBase);
}
public static Action DoOrReserve <TEventArg>(
this IEventContainer <TEventArg> eventContainer,
Action action,
Func <bool> predicate)
{
return(NewMethod(eventContainer, action, predicate));
}
public override void RemoveStack(IStatContainer stats, IEventContainer events)
{
foreach (Element element in Stats)
{
stats.RemoveStatElement(element.Info.Identifier, element);
}
}
public override void ApplyStack(IStatContainer stats, IEventContainer events)
{
foreach (Element element in Stats)
{
stats.AddStatElement(element.Info.Identifier, new StatElement(element, element.Value * Coeffecient));
}
}
/// <summary>
/// Ctor. for unit testing.
/// </summary>
public EventAggregatorService(IErrorHandler errorHandler, IPublisherCreator publisherCreator, IEventContainer unpublishedEvents)
{
syncLock = new object();
pluginSubscribers = new Dictionary <string, IEventPublisher>();
this.errorHandler = errorHandler;
this.publisherCreator = publisherCreator;
this.unpublishedEvents = unpublishedEvents;
}
public UnpublishedEventsContainerTester()
{
// 1) arrange
var eventQueue = new EventQueue();
eventConteiner = new UnpublishedEventsContainer(eventQueue);
pluginName = "TeoVincent";
e = new Event_Mock();
publisher = MockRepository.GenerateStub <IEventPublisher>();
}
/// <summary>
/// Ctor. for WCF service hosting.
/// </summary>
public EventAggregatorService()
{
syncLock = new object();
pluginSubscribers = new Dictionary <string, IEventPublisher>();
errorHandler = new ErrorPrinter();
publisherCreator = new CurrentContextCallbackCreator();
IEventQueue ququedEventsQueue = new EventQueue();
unpublishedEvents = new UnpublishedEventsContainer(ququedEventsQueue);
}
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
stringsToReturn.Clear();
stringsToReturn.Add("<NONE>");
IEventContainer eventContainer = null;// EditorLogic.CurrentNamedObject;
if (eventContainer == null)
{
eventContainer = EditorLogic.CurrentScreenSave;
}
string appendText = "";
string containerName = null;
if (eventContainer != null)
{
containerName = FlatRedBall.IO.FileManager.RemovePath(eventContainer.Name);
}
else if (EditorLogic.CurrentEntitySave != null)
{
containerName = FlatRedBall.IO.FileManager.RemovePath(EditorLogic.CurrentEntitySave.Name);
}
if (eventContainer != null && eventContainer is NamedObjectSave)
{
if (((NamedObjectSave)eventContainer).GetCustomVariable(Form1.Self.PropertyGrid.SelectedGridItem.Label.Replace(" Set", "")) != null)
{
appendText = "Set";
}
}
string nameToPrepend = FlatRedBall.IO.FileManager.RemovePath(containerName);
string nameFromLabel = Form1.Self.PropertyGrid.SelectedGridItem.Label.Replace(" Set", "");
// Make a suggested name
string suggestedName =
nameToPrepend + nameFromLabel
+ appendText;
stringsToReturn.Add(suggestedName);
return(new StandardValuesCollection(stringsToReturn));
}
private void SetEventValue(string categoryString, IEventContainer eventContainer, string value)
{
switch (categoryString)
{
case "Active Events":
EventResponseSave eventToModify = null;
for (int i = eventContainer.Events.Count - 1; i > -1; i--)
{
if (eventContainer.Events[i].EventName == this.Name)
{
eventToModify = eventContainer.Events[i];
break;
}
}
if (eventToModify == null)
{
throw new Exception("Could not find an event by the name of " + Name);
}
else
{
string valueAsString = value;
if (string.IsNullOrEmpty(valueAsString) || valueAsString == "<NONE>")
{
eventContainer.Events.Remove(eventToModify);
}
else
{
//eventToModify.InstanceMethod = valueAsString;
}
}
//EventSave eventSave = EditorLogic.Current
break;
case "Unused Events":
//EventSave eventSave = EventManager.AllEvents[Name];
//eventSave.InstanceMethod = value;
//EditorLogic.CurrentEventContainer.Events.Add(eventSave);
break;
}
}
/// <summary>
/// Invoke the AXADefaultClaimEventValues virtual process against this event, via a plugin call.
/// </summary>
/// <param name="ev"> Event type object </param>
/// <param name="eventContainer">Event Container</param>
/// <param name="point">Points PostComplete,Precomplete</param>
private void InvokeVirtualProcess(IEvent ev, IEventContainer eventContainer, Xiap.Framework.TransactionInvocationPoint point)
{
ProductXML.ProductEvent pdevent = ev.GetProduct();
if (pdevent != null)
{
IBusinessComponent eventComponent = (IBusinessComponent)ev;
string alias = "AXADefaultClaimEventValues";
// invoke the 'process handler' plugin
if (_Logger.IsInfoEnabled)
{
_Logger.Info("Invoked Virtual plugin " + alias + point.ToString() + "for " + eventComponent.GetType().Name);
}
ProcessParameters processParameters = new ProcessParameters() { Alias = alias, TransactionInvocationPoint = point };
ProcessHelper.HandleVirtualProcess(eventComponent, processParameters);
}
}
public static Action Subscribe <TEventArg>(
this IEventContainer <TEventArg> eventContainer,
Action <object, TEventArg> action,
Func <object, TEventArg, bool> predicate = null)
{
predicate = predicate ?? Predicates.True;
eventContainer.Subscribe(OnTriggered);
return(() => { eventContainer.Unsubscribe(OnTriggered); });
void OnTriggered(object sender, TEventArg arg)
{
if (predicate(sender, arg))
{
action?.Invoke(sender, arg);
}
}
}
public bool TryActivateEvent(out IEventContainer activeEvent)
{
activeEvent = null;
lock (_lock)
{
if (!_queuedEvents.Any())
{
return(false);
}
var evnt = _queuedEvents[0];
_queuedEvents.RemoveAt(0);
evnt.EventStatus = IEventContainer.Status.Executing;
if (ActiveEvent != null)
{
_executedEvents.Add(ActiveEvent as EventContainer);
}
ActiveEvent = evnt;
activeEvent = ActiveEvent;
RaiseStateChanged();
return(true);
}
}
public override void ApplyStack(IStatContainer stats, IEventContainer events)
{
stats.AddStatElement(ExplosionDamageFactorInfo.Identifier, new StatElement(this, DamageFactorStack * Coeffecient));
stats.AddStatElement(ExplosionRangeInfo.Identifier, new StatElement(this, RangeStack));
}
/// <summary>
/// Create event on transaction
/// </summary>
/// <param name="eventContainer">Event Container</param>
private void CreateEventOnTransaction(IEventContainer eventContainer)
{
ClaimHeader clmHeader = null;
// Get claim header depending on the EventContainer (area event was raised in)
if (eventContainer is ClaimDetail)
{
clmHeader = ((ClaimDetail)eventContainer).Parent as ClaimHeader;
}
else
{
clmHeader = eventContainer as ClaimHeader;
}
if (clmHeader == null)
{
return;
}
ProductVersion product = clmHeader.GetProduct();
// Check for Transaction headers in progress,
// cycle through each of them.
// In each Claim Transaction header, cycle through all the Claim Transaction Groups
if (clmHeader.InProgressClaimTransactionHeaders != null)
{
foreach (ClaimTransactionHeader clmTransHeader in clmHeader.InProgressClaimTransactionHeaders)
{
foreach (ClaimTransactionGroup clmTransGroup in clmTransHeader.ClaimTransactionGroups)
{
// Create the event on the Claim Detail, based on whether the transaction is a Payment, Reserve or Recovery
switch (clmTransHeader.ClaimTransactionSource)
{
case (short)StaticValues.ClaimTransactionSource.Reserve:
this.CreateEvent(clmHeader,clmTransGroup.ClaimDetail, clmTransHeader, product, ClaimConstants.EVENT_TYPECODE_RESERVE);
break;
case (short)StaticValues.ClaimTransactionSource.Payment:
this.CreateEvent(clmHeader,clmTransGroup.ClaimDetail, clmTransHeader, product, ClaimConstants.EVENT_TYPECODE_PAYMENT);
break;
case (short)StaticValues.ClaimTransactionSource.RecoveryReserve:
this.CreateEvent(clmHeader,clmTransGroup.ClaimDetail, clmTransHeader, product, ClaimConstants.EVENT_TYPECODE_RECOVERYRESERVE);
break;
case (short)StaticValues.ClaimTransactionSource.RecoveryReceipt:
this.CreateEvent(clmHeader,clmTransGroup.ClaimDetail, clmTransHeader, product, ClaimConstants.EVENT_TYPECODE_RECOVERYRECEIPT);
break;
}
}
}
}
}
public override void RemoveEffect(IModdable target)
{
IEventContainer container = target as IEventContainer;
container.GetEvent(Event).Detach(Handler);
}
public ModContainer(IStatContainer stats, IEventContainer events)
{
_stats = stats;
_events = events;
}
public abstract void ApplyStack(IStatContainer stats, IEventContainer events);
public override PropertyDescriptorCollection GetProperties(object component, Attribute[] attributes)
{
List <PropertyDescriptor> propertiesToReturn = new List <PropertyDescriptor>();
IEventContainer asEventContainer = component as IEventContainer;
PropertyInfo[] properties = component.GetType().GetProperties(
BindingFlags.Instance | BindingFlags.Public);
#region Get the events defined by the class
PropertyDescriptorCollection propertyDescriptions = null;
bool isStatic = EditorLogic.CurrentNamedObject == null;
if (isStatic)
{
propertyDescriptions = TypeDescriptor.GetProperties(
component, new Attribute[] { new BroadcastAttribute(BroadcastStaticOrInstance.Internal) });
}
else
{
propertyDescriptions = TypeDescriptor.GetProperties(
component, new Attribute[] { new BroadcastAttribute(BroadcastStaticOrInstance.Instance), new CategoryAttribute("Active Events") });
}
#endregion
BroadcastAutofillTypeConverter autofillConverter =
new BroadcastAutofillTypeConverter();
if (asEventContainer != null)
{
#region Add active events which come from the events CSV
foreach (EventResponseSave es in asEventContainer.Events)
{
propertyDescriptions = PropertyDescriptorHelper.AddProperty(
propertyDescriptions, es.EventName, typeof(string),
autofillConverter,
new Attribute[] { new CategoryAttribute("Active Events") });
}
#endregion
#region Add Unused Events
foreach (EventSave es in EventManager.AllEvents.Values)
{
string name = es.EventName;
bool doesNamedObjectUseThis = false;
foreach (EventResponseSave usedEvent in asEventContainer.Events)
{
if (usedEvent.EventName == name)
{
doesNamedObjectUseThis = true;
break;
}
}
if (!doesNamedObjectUseThis)
{
propertyDescriptions = PropertyDescriptorHelper.AddProperty(
propertyDescriptions, es.EventName, typeof(string),
new FlatRedBall.Glue.FormHelpers.StringConverters.BroadcastAutofillTypeConverter(),
new Attribute[] { new CategoryAttribute("Unused Events") });
}
}
#endregion
}
NamedObjectSave asNamedObject = component as NamedObjectSave;
if (asNamedObject != null)
{
Attribute[] customVariableEvents = new Attribute[] { new CategoryAttribute("Custom Variable Set Events") };
foreach (CustomVariableInNamedObject cv in asNamedObject.InstructionSaves)
{
propertyDescriptions = PropertyDescriptorHelper.AddProperty(
propertyDescriptions, cv.Member + " Set", typeof(string),
autofillConverter,
customVariableEvents);
}
#region Remove the ClickEvent if it's not an IClickable
if (asNamedObject.SourceType != SourceType.Entity)
{
propertyDescriptions = PropertyDescriptorHelper.RemoveProperty(
propertyDescriptions, "ClickEvent");
}
else if (!string.IsNullOrEmpty(asNamedObject.SourceClassType))
{
EntitySave entitySave = Glue.Elements.ObjectFinder.Self.GetEntitySave(asNamedObject.SourceClassType);
if (entitySave != null && entitySave.ImplementsIClickable == false)
{
propertyDescriptions = PropertyDescriptorHelper.RemoveProperty(
propertyDescriptions, "ClickEvent");
}
}
#endregion
}
return(propertyDescriptions);
////foreach (PropertyDescriptor propertyDescriptor in propertyDescriptions)
////{
//// propertiesToReturn.Add(propertyDescriptions);
////}
//foreach (PropertyInfo property in properties)
//{
// //object[] propertyAttributes = property.GetCustomAttributes(false);
// //foreach (object o in propertyAttributes)
// {
// //if (o is BroadcastAttribute)
// {
// propertiesToReturn.Add(propertyDescriptions[property.Name]);
// }
// }
//}
//PropertyDescriptorCollection toReturn = new PropertyDescriptorCollection(
// propertiesToReturn.ToArray());
//return toReturn;
}
private void SetEventValue(string categoryString, IEventContainer eventContainer, string value)
{
switch (categoryString)
{
case "Active Events":
EventResponseSave eventToModify = null;
for (int i = eventContainer.Events.Count - 1; i > -1; i--)
{
if (eventContainer.Events[i].EventName == this.Name)
{
eventToModify = eventContainer.Events[i];
break;
}
}
if (eventToModify == null)
{
throw new Exception("Could not find an event by the name of " + Name);
}
else
{
string valueAsString = value;
if (string.IsNullOrEmpty(valueAsString) || valueAsString == "<NONE>")
{
eventContainer.Events.Remove(eventToModify);
}
else
{
//eventToModify.InstanceMethod = valueAsString;
}
}
//EventSave eventSave = EditorLogic.Current
break;
case "Unused Events":
//EventSave eventSave = EventManager.AllEvents[Name];
//eventSave.InstanceMethod = value;
//EditorLogic.CurrentEventContainer.Events.Add(eventSave);
break;
}
}
public SubscribingEventAggregatorServiceTester()
{
errorHandler = MockRepository.GenerateMock <IErrorHandler>();
eventConteiner = MockRepository.GenerateMock <IEventContainer>();
plugin = "TeoVincent";
}
public static void AddEventContainer(IEventContainer container)
{
EventContainerCollection.Add(container);
}
public override void RemoveBase(IStatContainer stats, IEventContainer events)
{
events.GetEvent(EventInfo.Identifier).Event.OnExecute -= Explode;
}
public abstract void RemoveStack(IStatContainer stats, IEventContainer events);
public override void RemoveStack(IStatContainer stats, IEventContainer events)
{
stats.RemoveStatElement(ExplosionDamageFactorInfo.Identifier, this);
stats.RemoveStatElement(ExplosionRangeInfo.Identifier, this);
}
