private void TestWeakSubscribe(Action<EventTarget, IEventSource> subscribe, Action<IEventSource> fireEvent)
{
// Setup event source, target & wire together
var target = new EventTarget();
var wr = new WeakReference(target);
var source = CreateWovenEventSource();
subscribe(target, source);
// Confirm event fires correctly.
Assert.IsNotNull(wr.Target);
fireEvent(source);
Assert.AreEqual(1, target.FireCount);
// Confirm that the event source does not keep the target alive.
target = null;
System.GC.Collect();
Assert.IsNull(wr.Target);
// Fire the event again to force clean up of the weak event handler instance
// There is no way to check that clean up, however this will confirm the woven IL is correct
fireEvent(source);
// Keep the source alive until here: if it's GC'd this test will be invalid.
System.GC.KeepAlive(source);
}
private void TestWeakUnsubscribe(Action<EventTarget, IEventSource> subscribe, Action<IEventSource> fireEvent, Action<EventTarget, IEventSource> unsubscribe, Func<IEventSource, bool> isEventSubscribed)
{
// Setup event source, target & wire together
var target = new EventTarget();
var wr = new WeakReference(target);
var source = CreateWovenEventSource();
subscribe(target, source);
// Confirm event fires correctly.
Assert.IsNotNull(wr.Target);
fireEvent(source);
Assert.AreEqual(1, target.FireCount);
// Remove the handler
unsubscribe(target, source);
// Fire the event again & confirm handler removed
fireEvent(source);
Assert.IsFalse(isEventSubscribed(source));
Assert.AreEqual(1, target.FireCount);
// Keep the source alive until here: if it's GC'd this test will be invalid.
System.GC.KeepAlive(source);
}
public static TestEventTarget BuildTargetFromDataBaseData(string idReferral)
{
using (NpgsqlConnection connection = Global.GetSqlConnection())
{
string findPatient = "SELECT id_case_aid_form, id_case_aid_place, id_case_aid_type, case_close_date, case_open_date, reception_appoint_date FROM public.referral WHERE id_referral = '" + idReferral + "' ORDER BY id_referral DESC LIMIT 1";
NpgsqlCommand person = new NpgsqlCommand(findPatient, connection);
using (NpgsqlDataReader personFromDataBase = person.ExecuteReader())
{
EventTarget p = new EventTarget();
while (personFromDataBase.Read())
{
//что делать с IsReferralReviwedSpecified, Lpu, ReceptionAppointComment, ReceptionAppointTime, ReferralReviewDate и RefferalCreatedDate?
if (personFromDataBase["case_close_date"] != DBNull.Value)
p.CaseCloseDate = Convert.ToDateTime(personFromDataBase["case_close_date"]);
if (personFromDataBase["case_open_date"] != DBNull.Value)
p.CaseOpenDate = Convert.ToDateTime(personFromDataBase["case_open_date"]);
if (personFromDataBase["reception_appoint_date"] != DBNull.Value)
p.ReceptionAppointDate = Convert.ToDateTime(personFromDataBase["reception_appoint_date"]);
TestEventTarget pers = new TestEventTarget(p);
if (personFromDataBase["id_case_aid_form"] != DBNull.Value)
pers.caseAidForm = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_form"]));
if (personFromDataBase["id_case_aid_place"] != DBNull.Value)
pers.caseAidPlace = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_place"]));
if (personFromDataBase["id_case_aid_type"] != DBNull.Value)
pers.caseAidType = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_type"]));
return pers;
}
}
}
return null;
}
public TestEventTarget(EventTarget r)
{
target = r ?? new EventTarget();
caseAidForm = new TestCoding(target.CaseAidForm);
caseAidPlace = new TestCoding(target.CaseAidPlace);
caseAidType = new TestCoding(target.CaseAidType);
lpu = new TestCoding(target.Lpu);
}
public void PerformanceTest([Values(1,10)] int attachCount)
{
var target = new EventTarget();
var sw = new Stopwatch();
var eventRaiseCalls = 10000000;
var expectedCalls = attachCount * eventRaiseCalls;
for (int i = 0; i < attachCount; i++)
{
target.OrdinaryEvent += Target_OrdinaryEvent;
target.WeakEvent += Target_OrdinaryEvent;
target.WeakEventSource += Target_OrdinaryEvent;
}
sw.Reset();
sw.Start();
RaiseEvents(eventRaiseCalls, () => target.RaiseOrdinaryEvent());
var ordinary = sw.ElapsedMilliseconds;
Assert.That(target.CallCount, Is.EqualTo(expectedCalls), "call count mismatch RaiseOrdinaryEvent");
target.CallCount = 0;
sw.Reset();
sw.Start();
RaiseEvents(eventRaiseCalls, () => target.RaiseWeakEventSource());
var wes = sw.ElapsedMilliseconds;
Assert.That(target.CallCount, Is.EqualTo(expectedCalls), "call count mismatch RaiseWeakEventSource");
target.CallCount = 0;
sw.Reset();
sw.Start();
RaiseEvents(eventRaiseCalls, () => target.RaiseWeakEvent());
var we = sw.ElapsedMilliseconds;
Assert.That(target.CallCount, Is.EqualTo(expectedCalls), "call count mismatch RaiseWeakEvent");
target.CallCount = 0;
var top = (wes / 100) * 103;
Console.Out.WriteLine($"{nameof(EventTarget.OrdinaryEvent)} {ordinary}");
Console.Out.WriteLine($"{nameof(EventTarget.WeakEventSource)} {wes}");
Console.Out.WriteLine($"{nameof(EventTarget.WeakEvent)} {we}");
Console.Out.WriteLine($"top {top}");
Assert.That(ordinary, Is.LessThanOrEqualTo(we), "ordinary should be the fastest");
if (we < wes && we > 0)
{
var p = ((wes/we)*100L);
Console.Out.WriteLine($"WeakEvent execution time is {p}% relative to {nameof(wes)}");
}
}
public TestEventTarget(EventTarget r)
{
if (r != null)
target = r;
else
target = new EventTarget();
if (target.CaseAidForm != null)
caseAidForm = new TestCoding(target.CaseAidForm);
if (target.CaseAidPlace != null)
caseAidPlace = new TestCoding(target.CaseAidPlace);
if (target.CaseAidType != null)
caseAidType = new TestCoding(target.CaseAidType);
if (target.Lpu != null)
lpu = new TestCoding(target.Lpu);
}
/// <summary>This slide is now starting.</summary>
internal virtual void start()
{
// Dispatch a "timelinestart" event.
SlideEvent se = createEvent("start");
// Dispatch here:
dispatchEvent(se);
// Dispatch to the element too:
EventTarget et = eventTarget;
if (et != null)
{
et.dispatchEvent(se);
}
}
public override void ConfigureServices(IServiceCollection services) =>
base.ConfigureServices(services
.AddGoogleExceptionLogging(options =>
{
options.ProjectId = ProjectId;
options.ServiceName = EntryData.Service;
options.Version = EntryData.Version;
// This is just so that our validator finds the log entries associated to errors.
options.Options = ErrorReportingOptions.Create(EventTarget.ForLogging(ProjectId, "aspnetcore"));
})
.AddGoogleTrace(options =>
{
options.ProjectId = ProjectId;
options.Options = TraceOptions.Create(
double.PositiveInfinity, BufferOptions.NoBuffer(), RetryOptions.NoRetry(ExceptionHandling.Propagate));
}));
public void initWheelEvent(string typeArg, bool canBubbleArg, bool cancelableArg, AbstractView viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, short buttonArg, EventTarget relatedTargetArg, string modifiersListArg, double deltaXArg, double deltaYArg, double deltaZArg, long deltaModeArg)
{
modifiersListArg = modifiersListArg.ToLower();
bool ctrlKeyArg = modifiersListArg.Contains("control");
bool altKeyArg = modifiersListArg.Contains("alt");
bool shiftKeyArg = modifiersListArg.Contains("shift");
bool metaKeyArg = modifiersListArg.Contains("meta");
if (modifiersListArg.Contains("altgraph")) ctrlKeyArg = altKeyArg = true;
base.initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, screenXArg, screenYArg, clientXArg, clientYArg, ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg, buttonArg, relatedTargetArg);
deltaX = deltaXArg;
deltaY = deltaYArg;
deltaZ = deltaZArg;
deltaMode = deltaModeArg;
}
public void Logging_LogTarget()
{
var logTarget = LogTarget.ForOrganization(_organizationId);
var logName = "another-log";
var monitoredResource = new MonitoredResource {
Type = "not_global"
};
var eventTarget = EventTarget.ForLogging(logTarget, logName, _loggingClient, monitoredResource);
Assert.Equal(EventTargetKind.Logging, eventTarget.Kind);
Assert.Null(eventTarget.ErrorReportingClient);
Assert.Equal(_loggingClient, eventTarget.LoggingClient);
Assert.Equal(logTarget, eventTarget.LogTarget);
Assert.Equal(logName, eventTarget.LogName);
Assert.Equal(monitoredResource, eventTarget.MonitoredResource);
}
public void Logging_ProjectId()
{
var logName = "another-log";
var eventTarget = EventTarget.ForLogging(
_projectId, logName, _loggingClient, MonitoredResourceBuilder.GlobalResource);
Assert.Equal(EventTargetKind.Logging, eventTarget.Kind);
Assert.Equal(_projectId, eventTarget.ProjectId);
Assert.Null(eventTarget.ErrorReportingClient);
Assert.Equal(_loggingClient, eventTarget.LoggingClient);
Assert.NotNull(eventTarget.LogTarget);
Assert.Equal(LogTargetKind.Project, eventTarget.LogTarget.Kind);
Assert.Equal(_projectId, eventTarget.LogTarget.ProjectId);
Assert.Equal(logName, eventTarget.LogName);
Assert.Equal(MonitoredResourceBuilder.GlobalResource, eventTarget.MonitoredResource);
}
public static void Trigger <TArgs>(EventTarget target, TArgs args)
{
HashSet <Action <TArgs> > handlers = null;
if (events.TryGetValue(target, out var potentialHandlers))
{
foreach (var potentialHandler in potentialHandlers)
{
if (potentialHandler is Action <TArgs> handler)
{
if (handlers == null)
{
handlers = HashSetPool <Action <TArgs> > .New();
}
handlers.Add(handler);
}
}
}
if (handlers == null || handlers.Count == 0)
{
if (OpenWarning)
{
if (target.target == null)
{
IcLog.Warning($"Global Event: {target.name} No Any Handle.");
}
else
{
IcLog.Warning($"{target.name}---:---{target.target} No Any Handle.");
}
return;
}
}
if (handlers != null)
{
foreach (var handler in handlers)
{
handler.Invoke(args);
}
handlers.Free();
}
}
public IEnumerator TestStandardVsJob()
{
int value = 0;
EventTarget target = EventTarget.CreateTarget();
Action <TestJob> callback1 = x => { Assert.IsTrue(x.result == 10); };
Action <EvSimpleEvent> callback2 = x => { value += x.value; };
EventManager.SubscribeWithJob <TestJob, EvSimpleEvent>(target, new TestJob(), callback1, EventUpdateTick.Update);
EventManager.Subscribe(target, callback2, EventUpdateTick.Update);
EventManager.SendEvent(target, new EvSimpleEvent(10), EventUpdateTick.Update);
yield return(null);
Assert.IsTrue(value == 10);
}
public void SetUp()
{
_handlers = new Mock <IEventHandlers>();
_rootOriginal = new object();
_root = new EventTarget(_rootOriginal, () => null);
_root.AddEventListener("click", _handlers.Object.OnRootBubble, false);
_root.AddEventListener("click", _handlers.Object.OnRootCapture, true);
_parentOriginal = new object();
_parent = new EventTarget(_parentOriginal, () => _root);
_parent.AddEventListener("click", _handlers.Object.OnParentBubble, false);
_childOriginal = new object();
_child = new EventTarget(_childOriginal, () => _parent);
_child.AddEventListener("click", _handlers.Object.OnChildBubble, false);
}
public void WeakSubscribeDisposedTest()
{
EventSource eventSource = new EventSource();
EventTarget target = new EventTarget(eventSource);
using (target)
{
Assert.AreEqual(0, EventTarget.RaiseCount);
eventSource.RaiseEvents();
Assert.AreEqual(3, EventTarget.RaiseCount);
}
Assert.AreEqual(3, EventTarget.RaiseCount);
eventSource.RaiseEvents();
Assert.AreEqual(3, EventTarget.RaiseCount);
}
public void ReserveEntityTargets()
{
// See ExampleCustomEventSystem for a description of what EventTarget are and how they could be
// used. Also see EventTarget.cs
// Reservations allow us to reserve a block of event targets for us to use however way we see fit. Will
// prevent EventTarget from giving out targets within that reservation on EventTarget creation or other'
// reservations.
EventTargetReservation reservation = EventTarget.ReserveTargets(100);
// Grabs an EventTarget by index
EventTarget target0 = reservation.GetEntityTarget(0);
EventTarget target50 = reservation.GetEntityTarget(50);
// Throws an error if outside the reservation (if checks are enabled)
EventTarget target200 = reservation.GetEntityTarget(200);
}
public async Task LogAsync()
{
var options = ErrorReportingOptions.Create(
EventTarget.ForLogging("pid", loggingClient: new Mock <LoggingServiceV2Client>().Object));
var mockConsumer = new Mock <IConsumer <LogEntry> >();
mockConsumer.Setup(c => c.ReceiveAsync(
IsContext(_method, _uri, _userAgent, options), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
IContextExceptionLogger logger = new ErrorReportingContextExceptionLogger(
mockConsumer.Object, _service, _version, options);
await logger.LogAsync(CreateException(), new FakeContextWrapper());
mockConsumer.VerifyAll();
}
private void OnPointerUp(Event e)
{
EventTarget target = e.Target ?? e.GetSrcElement();
if (target != this.HtmlElement || !IsPressed)
{
return;
}
IsPressed = false;
if (IsEnabled && mouseUp != null)
{
Window.SetTimeout(mouseUp);
}
e.PreventDefault();
}
internal override bool ResourceStatus(EventTarget package, int status)
{
if (base.ResourceStatus(package, status))
{
// Run the onload event if we're in an iframe:
if (window.iframe != null)
{
// Dispatch to the element too (don't bubble):
UIEvent e = new UIEvent("load");
e.SetTrusted(false);
window.iframe.dispatchEvent(e);
}
return(true);
}
return(false);
}
public IEnumerator TestFlush()
{
EventTarget target = EventTarget.CreateTarget();
int value = 0;
Action <EvSimpleEvent> callback = x => { value += x.value; };
EventManager.Subscribe(target, callback, EventUpdateTick.Update);
EventManager.SendEvent(target, new EvSimpleEvent(10), EventUpdateTick.Update);
EventManager.FlushAll();
Assert.IsTrue(value == 10);
yield return(null);
Assert.IsTrue(value == 10);
}
public int dispatchEvent(EventTarget e)
{
List <EventRegister> listeners = null;
if (!listener.ContainsKey(e.name))
{
return(0);
}
listeners = listener[e.name];
for (int i = 0; i < listeners.Count; ++i)
{
e.targetDispatcher = this;
e.targetRegister = listeners[i];
listeners[i].callback.Invoke(e);
//listeners[i].thisObject.(listeners[i].callback)(e);
}
return(0);
}
/// <summary>This slide is now done.</summary>
internal virtual void end()
{
// Dispatch a "slideend" event.
SlideEvent se = createEvent("end");
// Dispatch here:
dispatchEvent(se);
// Dispatch to the element too:
EventTarget et = eventTarget;
if (et != null)
{
et.dispatchEvent(se);
}
// Quit timing lead:
endTimingLead();
}
static public TestEventTarget BuildTargetFromDataBaseData(string idReferral)
{
using (NpgsqlConnection connection = Global.GetSqlConnection())
{
string findPatient = "SELECT id_case_aid_form, id_case_aid_place, id_case_aid_type, case_close_date, case_open_date, reception_appoint_date FROM public.referral WHERE id_referral = '" + idReferral + "' ORDER BY id_referral DESC LIMIT 1";
NpgsqlCommand person = new NpgsqlCommand(findPatient, connection);
using (NpgsqlDataReader personFromDataBase = person.ExecuteReader())
{
EventTarget p = new EventTarget();
while (personFromDataBase.Read())
{
//что делать с IsReferralReviwedSpecified, Lpu, ReceptionAppointComment, ReceptionAppointTime, ReferralReviewDate и RefferalCreatedDate?
if (personFromDataBase["case_close_date"] != DBNull.Value)
{
p.CaseCloseDate = Convert.ToDateTime(personFromDataBase["case_close_date"]);
}
if (personFromDataBase["case_open_date"] != DBNull.Value)
{
p.CaseOpenDate = Convert.ToDateTime(personFromDataBase["case_open_date"]);
}
if (personFromDataBase["reception_appoint_date"] != DBNull.Value)
{
p.ReceptionAppointDate = Convert.ToDateTime(personFromDataBase["reception_appoint_date"]);
}
TestEventTarget pers = new TestEventTarget(p);
if (personFromDataBase["id_case_aid_form"] != DBNull.Value)
{
pers.caseAidForm = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_form"]));
}
if (personFromDataBase["id_case_aid_place"] != DBNull.Value)
{
pers.caseAidPlace = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_place"]));
}
if (personFromDataBase["id_case_aid_type"] != DBNull.Value)
{
pers.caseAidType = TestCoding.BuildCodingFromDataBaseData(Convert.ToString(personFromDataBase["id_case_aid_type"]));
}
return(pers);
}
}
}
return(null);
}
public IEnumerator TestMultipleEntitiesJob()
{
EventTarget entity1 = EventTarget.CreateTarget();
EventTarget entity2 = EventTarget.CreateTarget();
Action <TestJob> callback1 = x => { Assert.IsTrue(x.result == 10); };
Action <TestJob> callback2 = x => { Assert.IsTrue(x.result == 20); };
EventManager.SubscribeWithJob <TestJob, EvSimpleEvent>(entity1, new TestJob(), callback1, EventUpdateTick.Update);
EventManager.SubscribeWithJob <TestJob, EvSimpleEvent>(entity2, new TestJob(), callback2, EventUpdateTick.Update);
EventManager.SendEvent(entity1, new EvSimpleEvent(10), EventUpdateTick.Update);
yield return(null);
EventManager.SendEvent(entity2, new EvSimpleEvent(20), EventUpdateTick.Update);
yield return(null);
}
public static MemberTarget ReadMemberTarget(XmlReader reader)
{
if (reader == null || reader.NodeType != XmlNodeType.Element)
{
return(null);
}
switch (reader.Name)
{
case "MemberTarget":
MemberTarget memberTarget = new MemberTarget();
memberTarget.ReadXml(reader);
return(memberTarget);
case "ConstructorTarget":
ConstructorTarget constructorTarget = new ConstructorTarget();
constructorTarget.ReadXml(reader);
return(constructorTarget);
case "ProcedureTarget":
ProcedureTarget procedTarget = new ProcedureTarget();
procedTarget.ReadXml(reader);
return(procedTarget);
case "EventTarget":
EventTarget eventTarget = new EventTarget();
eventTarget.ReadXml(reader);
return(eventTarget);
case "PropertyTarget":
PropertyTarget propertyTarget = new PropertyTarget();
propertyTarget.ReadXml(reader);
return(propertyTarget);
case "MethodTarget":
MethodTarget methodTarget = new MethodTarget();
methodTarget.ReadXml(reader);
return(methodTarget);
}
return(null);
}
public void TestMeUnsubscribe()
{
EventTarget target1 = EventTarget.CreateTarget();
EventTarget target2 = EventTarget.CreateTarget();
int value = -1;
Action <TestJob> callback = x => { Assert.Fail(); };
_handler.Subscribe(target1, new TestJob(value), callback);
_handler.Subscribe(target2, new TestJob(value), callback);
_handler.Unsubscribe(target1, callback);
_handler.QueueEvent(target1, new EvSimpleEvent(10));
_handler.ProcessEvents();
_handler.Unsubscribe(target2, callback);
_handler.VerifyNoSubscribers();
Assert.IsTrue(value == -1);
}
public void TestOtherUnsubscribe()
{
EventTarget target1 = EventTarget.CreateTarget();
EventTarget target2 = EventTarget.CreateTarget();
int value = 5;
Action <TestJob> callback = x => { Assert.IsTrue(x.result == value); };
Action <TestJob> callback2 = x => { Assert.Fail(); };
_handler.Subscribe(target1, new TestJob(value), callback);
_handler.Subscribe(target2, new TestJob(value), callback2);
_handler.Unsubscribe(target2, callback2);
_handler.QueueEvent(target1, new EvSimpleEvent(10));
value = 15;
_handler.ProcessEvents();
_handler.Unsubscribe(target1, callback);
_handler.VerifyNoSubscribers();
}
public void TestSimpleEvent()
{
EventTarget target = EventTarget.CreateTarget();
int value = 10;
Action <TestJob> callback = x => { Assert.IsTrue(x.result == value); };
_handler.Subscribe(target, new TestJob(value), callback);
_handler.QueueEvent(target, new EvSimpleEvent(10));
value = 20;
_handler.ProcessEvents();
_handler.Unsubscribe(target, callback);
_handler.VerifyNoSubscribers();
_handler.QueueEvent(target, new EvSimpleEvent(10));
_handler.ProcessEvents();
}
public void TestMeUnsubscribe()
{
EventTarget target1 = EventTarget.CreateTarget();
EventTarget target2 = EventTarget.CreateTarget();
int value = 0;
Action <EvSimpleEvent> callback = x => value += x.value;
_system.Subscribe(target1, callback);
_system.Subscribe(target2, callback);
_system.Unsubscribe(target1, callback);
_system.QueueEvent(target1, new EvSimpleEvent(10));
_system.ProcessEvents();
_system.Unsubscribe(target2, callback);
_system.VerifyNoSubscribers();
Assert.IsTrue(value == 0);
}
public void TestGameObjectRange()
{
int minId = int.MinValue;
int maxId = int.MaxValue;
int allBits = unchecked ((int)0xffffffff);
// This represents the range for gameobjects, should only be the first 32 bits of a ulong
EventTarget minTarget = new EventTarget(minId);
EventTarget maxTarget = new EventTarget(maxId);
EventTarget allBitsTarget = new EventTarget(allBits);
ulong zeroedBits = 0xffffffff;
zeroedBits <<= 32;
Assert.IsTrue((minTarget.id & zeroedBits) == 0);
Assert.IsTrue((maxTarget.id & zeroedBits) == 0);
Assert.IsTrue((allBitsTarget.id & zeroedBits) == 0);
Assert.IsTrue((EventTarget.CreateTarget().id & zeroedBits) != 0);
}
private void OnPointerDown(Event e)
{
EventTarget target = e.Target ?? e.GetSrcElement();
if (target != this.HtmlElement)
{
return;
}
if (IsEnabled)
{
IsChecked = !IsChecked;
UIEvent uiEvent = e as UIEvent;
overlay.HtmlElement.Style["transformOrigin"] = uiEvent.LayerY == 0 && uiEvent.LayerY == 0 ? "50% 50%" : String.Format("{0}px {1}px", uiEvent.LayerX, uiEvent.LayerY);
overlayAnimation.Start();
}
e.PreventDefault();
}
/// <summary>Called when a scrollwheel changes by the given delta amount.</summary>
public static void OnScrollWheel(Vector2 delta)
{
// Create the event:
WheelEvent e = new WheelEvent();
e.deltaX = delta.x * ScrollWheelMultiplier;
e.deltaY = delta.y * ScrollWheelMultiplier;
e.SetTrusted();
EventTarget target = ActiveReceiver;
// Dispatch the event to the focused element:
if (target.dispatchEvent(e))
{
if (target is HtmlElement)
{
// Run the default:
(target as HtmlElement).OnWheelEvent(e);
}
}
}
public IEnumerator TestUpdateMismatchEvent()
{
EventTarget target = EventTarget.CreateTarget();
int value = 0;
Action <EvSimpleEvent> callback = x => { value += 1; };
EventManager.Subscribe(target, callback, EventUpdateTick.Update);
EventManager.SendEvent(target, new EvSimpleEvent(), EventUpdateTick.LateUpdate);
EventManager.SendEvent(target, new EvSimpleEvent(), EventUpdateTick.FixedUpdate);
yield return(null);
Assert.IsTrue(value == 0);
EventManager.SendEvent(target, new EvSimpleEvent(), EventUpdateTick.Update);
yield return(null);
Assert.IsTrue(value == 1);
}
/// <summary>
/// Uninitializes this instance.
/// </summary>
protected override void Uninitialize()
{
base.Uninitialize();
if (_saveTargetInfo != null)
{
_saveTargetInfo.Event -= OnSaved;
_saveTargetInfo.CleanUp();
_saveTargetInfo = null;
}
if (_saveAndCloseTargetInfo != null)
{
_saveAndCloseTargetInfo.Event -= OnSavedAndClosed;
_saveAndCloseTargetInfo.CleanUp();
_saveAndCloseTargetInfo = null;
}
if (_cancelTargetInfo != null)
{
_cancelTargetInfo.Event -= OnCanceled;
_cancelTargetInfo.CleanUp();
_cancelTargetInfo = null;
}
if (_cancelAndCloseTargetInfo != null)
{
_cancelAndCloseTargetInfo.Event -= OnCanceledAndClosed;
_cancelAndCloseTargetInfo.CleanUp();
_cancelAndCloseTargetInfo = null;
}
if (_closeTargetInfo != null)
{
_closeTargetInfo.Event -= OnClosed;
_closeTargetInfo.CleanUp();
_closeTargetInfo = null;
}
}
public Event LoadRandomEvent(List <Event> events, Boat eventTarget, bool displayImmediately = false)
{
Event e = PickRandomEvent(events);
EventTarget et = new EventTarget(e, eventTarget);
if (e != null)
{
if (displayImmediately)
{
eventsToDisplay.AddFirst(et);
}
else
{
eventsToDisplay.AddLast(et);
}
}
if (displayImmediately)
{
DisplayEvent();
}
return(e);
}
internal Window(
Func <object> getSyncObj,
Action <string, string, string> openWindow,
INavigator navigator)
{
_openWindow = openWindow ?? ((x, y, z) => {});
Screen = new Screen
{
Width = 1024,
Height = 768,
AvailWidth = 1024,
AvailHeight = 768,
ColorDepth = 24,
PixelDepth = 24
};
InnerWidth = 1024;
InnerHeight = 768;
Navigator = navigator;
History = new History(OnSetState);
Location = new Location(History, () => _engine.Uri, s => _engine.OpenUrl(s));
_timers = new WindowTimers(getSyncObj);
_timers.OnException += exception =>
{
if (exception is JavaScriptException jsEx)
{
_engine.Console.Log($"JavaScript error in timer handler function (Line:{jsEx.LineNumber}, Col:{jsEx.Column}, Source: {jsEx.Source}): {jsEx.Error}");
}
else
{
_engine.Console.Log("Unhandled exception in timer handler function: " + exception.ToString());
}
};
_eventTarget = new EventTarget(this, () => null, () => _engine.Document);
}
/// <summary>
/// Dispatch the event as described in the specification.
/// http://www.w3.org/TR/DOM-Level-3-Events/
/// </summary>
/// <param name="target">The target of the event.</param>
/// <returns>A boolean if the event has been cancelled.</returns>
internal Boolean Dispatch(EventTarget target)
{
_flags |= EventFlags.Dispatch;
_target = target;
var eventPath = new List <EventTarget>();
var parent = target as Node;
if (parent != null)
{
while ((parent = parent.Parent) != null)
{
eventPath.Add(parent);
}
}
_phase = EventPhase.Capturing;
DispatchAt(eventPath.Reverse <EventTarget>());
_phase = EventPhase.AtTarget;
if (!_flags.HasFlag(EventFlags.StopPropagation))
{
CallListeners(target);
}
if (_bubbles)
{
_phase = EventPhase.Bubbling;
DispatchAt(eventPath);
}
_flags &= ~EventFlags.Dispatch;
_phase = EventPhase.None;
_current = null;
return(_flags.HasFlag(EventFlags.Canceled));
}
public void UpdateTestEventTarget(EventTarget e)
{
if (e.CaseCloseDate != null)
this.target.CaseCloseDate = e.CaseCloseDate;
if (e.CaseOpenDate != null)
this.target.CaseOpenDate = e.CaseOpenDate;
if (e.IsReferralReviwed != null)
this.target.IsReferralReviwed = e.IsReferralReviwed;
if (e.ReceptionAppointComment != null)
this.target.ReceptionAppointComment = e.ReceptionAppointComment;
if (e.ReceptionAppointDate != null)
this.target.ReceptionAppointDate = e.ReceptionAppointDate;
if (e.ReceptionAppointTime != null)
this.target.ReceptionAppointTime = e.ReceptionAppointTime;
if (e.ReferralReviewDate != null)
this.target.ReferralReviewDate = e.ReferralReviewDate;
if (e.RefferalCreatedDate != null)
this.target.RefferalCreatedDate = e.RefferalCreatedDate;
if (e.CaseAidForm != null)
this.caseAidForm = new TestCoding(e.CaseAidForm);
if (e.CaseAidPlace != null)
this.caseAidPlace = new TestCoding(e.CaseAidPlace);
if (e.CaseAidType != null)
this.caseAidType = new TestCoding(e.CaseAidType);
if (e.Lpu != null)
this.lpu = new TestCoding(e.Lpu);
}
public void initFocusEvent(string typeArg, bool canBubbleArg, bool cancelableArg, AbstractView viewArg, long detailArg, EventTarget relatedTargetArg)
{
base.initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
relatedTarget = relatedTargetArg;
}
/// <summary>
/// Initializes the value of a mouse event.
/// </summary>
/// <param name="type">The event type name.</param>
/// <param name="canBubble">Whether or not the event can bubble.</param>
/// <param name="canCancel">Whether or not the event can be cancelled.</param>
/// <param name="view">The associated view.</param>
/// <param name="detail">The event details.</param>
/// <param name="screenX">The vertical screen coordinate.</param>
/// <param name="screenY">The horizontal screen coordinate.</param>
/// <param name="clientX">The vertical client coordinate.</param>
/// <param name="clientY">The horizontal client coordinate.</param>
/// <param name="ctrlKey">Whether the Ctrl key is pressed.</param>
/// <param name="altKey">Whether the Alt key is pressed.</param>
/// <param name="shiftKey">Whether the Shift key is pressed.</param>
/// <param name="metaKey">Whther the meta key is pressed.</param>
/// <param name="button">The associated mouse button.</param>
/// <param name="relatedTarget">The secondary target.</param>
public void initMouseEvent(string type, bool canBubble, bool canCancel,
Window view, int detail, int screenX, int screenY, int clientX, int clientY,
bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, int button, EventTarget relatedTarget) { }
private static EventTarget CreateEventTarget(XPathNavigator api)
{
EventTarget target = new EventTarget();
if((bool)api.Evaluate(apiIsExplicitImplementationExpression))
target.ExplicitlyImplements = CreateMemberReference(api.SelectSingleNode(apiImplementedMembersExpression));
return target;
}
private void WriteEvent(EventTarget trigger, XmlWriter writer)
{
WriteProcedureName(trigger, writer);
}
/// <summary>
/// Dispatch the event as described in the specification.
/// http://www.w3.org/TR/DOM-Level-3-Events/
/// </summary>
/// <param name="target">The target of the event.</param>
/// <returns>A boolean if the event has been cancelled.</returns>
internal Boolean Dispatch(EventTarget target)
{
_flags |= EventFlags.Dispatch;
_target = target;
var eventPath = new List<EventTarget>();
var parent = target as Node;
if (parent != null)
{
while ((parent = parent.Parent) != null)
eventPath.Add(parent);
}
_phase = EventPhase.Capturing;
DispatchAt(eventPath.Reverse<EventTarget>());
_phase = EventPhase.AtTarget;
if (!_flags.HasFlag(EventFlags.StopPropagation))
CallListeners(target);
if (_bubbles)
{
_phase = EventPhase.Bubbling;
DispatchAt(eventPath);
}
_flags &= ~EventFlags.Dispatch;
_phase = EventPhase.None;
_current = null;
return _flags.HasFlag(EventFlags.Canceled);
}
void CallListeners(EventTarget target)
{
_current = target;
target.CallEventListener(this);
}
private void TestStrongSubscribe(IEventSource source, Action<EventTarget, IEventSource> subscribe, Action<IEventSource> fireEvent)
{
// Confirm that an event that cannot be makde weak retains
// a strong reference to the target and still works.
// Setup event source, target & wire together
var target = new EventTarget();
var wr = new WeakReference(target);
subscribe(target, source);
// Confirm event fires correctly.
Assert.IsNotNull(wr.Target);
fireEvent(source);
Assert.AreEqual(1, target.FireCount);
// Confirm that the event source does keep the target alive.
target = null;
System.GC.Collect();
Assert.IsNotNull(wr.Target);
fireEvent(source);
target = (EventTarget)wr.Target;
Assert.AreEqual(2, target.FireCount);
}
private void WriteEvent (EventTarget trigger, DisplayOptions options, XmlWriter writer) {
WriteProcedureName(trigger, options, writer);
}
public void initMouseEvent(string typeArg, bool canBubbleArg, bool cancelableArg, AbstractView viewArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, short buttonArg, EventTarget relatedTargetArg)
{
base.initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
screenX = screenXArg;
screenY = screenYArg;
clientX = clientXArg;
clientY = clientYArg;
ctrlKey = ctrlKeyArg;
shiftKey = shiftKeyArg;
altKey = altKeyArg;
metaKey = metaKeyArg;
button = buttonArg;
relatedTarget = relatedTargetArg;
}
