public Job(OmniRecordManager omniRecordManager, EventDispatcher eventDispatcher, CreativePackagesStore creativePackagesStore, Logger logger)
{
_logger = logger;
_creativePackagesStore = creativePackagesStore;
_eventDispatcher = eventDispatcher;
_omniRecordManager = omniRecordManager;
}
public static XnaMatrix GetTransformBetween(EventDispatcher from, EventDispatcher to)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
else if (to == null)
{
throw new ArgumentNullException("to");
}
if (from == to)
{
return XnaMatrix.Identity;
}
// construct a path from current dispatcher to root (null)
List<EventDispatcher> path = new List<EventDispatcher>();
for (var i = from; i != null; i = i.Dispatcher)
{
path.Add(i);
}
EventDispatcher commonAncestor = null;
// traverse from the target dispatcher up to meet the first dispatcher in the path
for (var i = to; i != null; i = i.Dispatcher)
{
if (path.Contains(i))
{
commonAncestor = i;
break;
}
}
if (commonAncestor == null)
{
throw new InvalidOperationException("Dispatcher is not in the same tree.");
}
// get the transform from current dispatcher to common ancestor
XnaMatrix transform1 = XnaMatrix.Identity;
for (var i = from; i != commonAncestor; i = i.Dispatcher)
{
if (i is ITransformNode)
{
transform1 *= (i as ITransformNode).Transform;
}
}
// get the transform from target dispatcher to common ancestor
XnaMatrix transform2 = XnaMatrix.Identity;
for (var i = to; i != commonAncestor; i = i.Dispatcher)
{
if (i is ITransformNode)
{
transform2 *= (i as ITransformNode).Transform;
}
}
return transform1 * transform2.Invert();
}
public static EventDispatcher DafaultCenter()
{
if (null == dafaultCenter) {
GameObject notificationObjiect = new GameObject("Default Event Center");
dafaultCenter = notificationObjiect.AddComponent<EventDispatcher>();
}
return dafaultCenter;
}
void Awake()
{
events = GetComponent<EventDispatcher>();
anim = GetComponent<Animator>();
playerAudio = GetComponent<AudioSource>();
playerMovement = GetComponent<PlayerMovement>();
playerShooting = GetComponentInChildren<PlayerShooting>();
currentHealth = startingHealth;
}
// PRIVATE STATIC
//--------------------------------------
// Methods
//--------------------------------------
// PUBLIC
/// <summary>
/// Start this instance.
/// </summary>
public TestFromOtherScope (string aName_string)
{
name_string = aName_string;
eventDispatcher = new EventDispatcher (this);
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1);
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent2);
}
public given_dispatcher_with_handler_for_envelope()
{
this.sut = new EventDispatcher();
this.handlerMock = new Mock<IEventHandler>();
this.handlerMock.As<IEnvelopedEventHandler<EventA>>();
this.sut.Register(this.handlerMock.Object);
}
public void addCallBack(TestCallBack test)
{
test(10);
EventDispatcher eventDispatcher = new EventDispatcher();
eventDispatcher.AddListeners += onTestEvent;
eventDispatcher.dispatchEventWith("helloEvent");
}
public void PublishingSingleEventShouldPublishEventToRegisteredBus()
{
var busMock = new Mock<IEventBus>();
var dispatcher = new EventDispatcher();
var eventMock = new Mock<IEvent>();
dispatcher.RegisterBus(busMock.Object);
dispatcher.Publish(eventMock.Object);
busMock.Verify(b => b.Publish(It.IsAny<IEvent>()), Times.Once());
}
void Awake()
{
anim = GetComponent <Animator> ();
enemyAudio = GetComponent <AudioSource> ();
hitParticles = GetComponentInChildren <ParticleSystem> ();
sphereCollider = GetComponent<SphereCollider> ();
currentHealth = startingHealth;
events = GetComponent<EventDispatcher>();
damageListene = events.GenListener("TakeDamage", this);
}
public void DispatchUndispatchedCommitsIfMarkingDispatched()
{
var e = new FakeEvent();
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, new EventCollection(new Event[] { e }));
var dispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object, new EventStoreSettings { MarkDispatched = true });
eventStore.Setup(mock => mock.GetUndispatched()).Returns(new[] { commit });
dispatcher.EnsurePersistedCommitsDispatched();
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny<EventEnvelope>()), Times.Once());
}
public void PublishingSingleShouldPublishEventToAllRegisteredBuses()
{
var firstBusMock = new Mock<IEventBus>();
var secondBusMock = new Mock<IEventBus>();
var dispatcher = new EventDispatcher();
var eventMock = new Mock<IEvent>();
dispatcher.RegisterBus(firstBusMock.Object);
dispatcher.RegisterBus(secondBusMock.Object);
dispatcher.Publish(eventMock.Object);
firstBusMock.Verify(b => b.Publish(It.IsAny<IEvent>()), Times.Once());
secondBusMock.Verify(b => b.Publish(It.IsAny<IEvent>()), Times.Once());
}
/*
* instance intiation
*/
public NanoTween(EventDispatcher target,float time,params object[] args)
{
_target = target;
_time = time;
_easeFunction = _ease.defaultEasingFunction;
id = _tweenCount.ToString();
_currentTime = 0.0f;
_startTime = Time.time;
_endTime = _time;
int i = 0;
string argName;
_argsName = new ArrayList();
_endArgs = new ArrayList();
_startArgs = new ArrayList();
while(i < args.Length - 1) {
argName = args[i] as string;
if(argName == "ease"){
_easeType = args[i+1] as string;
_easeFunction = _ease.getEasingFunction(_easeType);
}else if(argName == "delay"){
_delay = (float)args[i+1];
}else if(argName == ON_COMPLETE){
_onCompleteCallBack = args[i+1] as CallBack;
}else if(argName == ON_COMPLETE_PARAMS){
_onCompleteParams = args[i+1] as object[];
}else if(argName == ON_START){
_onStartCallBack = args[i+1] as CallBack;
}else if(argName == ON_START_PARAMS){
_onStartParams = args[i+1] as object[];
}else if(argName == ON_UPDATE){
_onUpdateCallBack = args[i+1] as CallBack;
}else if(argName == ON_UPDATE_PARAMS){
_onUpdateParams = args[i+1] as object[];
}else{
_argsName.Add(argName);
_endArgs.Add(args[i+1]);
_startArgs.Add(_target.GetType().GetProperty(argName).GetValue(_target,null));
//Debug.Log( argName+ " : "+ _target.GetType().GetProperty(argName).GetValue(_target,null));
}
i += 2;
}
_tweenCount++;
}
static void Main(string[] args)
{
LoggingSingleton.Instance.LogToFile = true;
LoggingSingleton.Instance.LogToStdout = true;
RestSettings.Instance.ServerIP = "192.168.186.104";
RestSettings.Instance.ServerPort = 81;
RestSettings.Instance.AppID = "app";
bool needExit = false;
//////////////////////////////////////////////////////////////////////
/// Disconnect any existing event handlers...
///
EventDispatcher<MyCall>.DisconnectAllEventHandlers();
//////////////////////////////////////////////////////////////////////
/// Create a new event handler...
///
EventDispatcher<MyCall> ev = new EventDispatcher<MyCall>() { DeleteAllCallsOnConnect = true };
ev.Start();
while (!needExit)
{
ConsoleKeyInfo info = Console.ReadKey(true);
switch (info.KeyChar)
{
case 'g':
case 'G':
CallDispatcher<MyCall>.Instance.GetCalls();
break;
case 'x':
case 'X':
needExit = true;
break;
}
Thread.Sleep(10);
}
ev.Stop();
ev.WaitForStop();
ev.Dispose();
ev = null;
}
/// <summary>
/// Instantiates a <see cref="UIManagerModule"/>.
/// </summary>
/// <param name="reactContext">The React context.</param>
/// <param name="viewManagers">The view managers.</param>
/// <param name="uiImplementation">The UI implementation.</param>
public UIManagerModule(
ReactContext reactContext,
IReadOnlyList<IViewManager> viewManagers,
UIImplementation uiImplementation)
: base(reactContext)
{
if (viewManagers == null)
throw new ArgumentNullException(nameof(viewManagers));
if (uiImplementation == null)
throw new ArgumentNullException(nameof(uiImplementation));
_eventDispatcher = new EventDispatcher(reactContext);
_uiImplementation = uiImplementation;
_moduleConstants = CreateConstants(viewManagers);
reactContext.AddLifecycleEventListener(this);
}
public void PublishingMultipleEventsShouldPublishEventsToRegisteredBus()
{
var busMock = new Mock<IEventBus>();
var dispatcher = new EventDispatcher();
var events = new List<IEvent>();
for( var i=0; i<10; i++ )
{
var eventMock = new Mock<IEvent>();
events.Add(eventMock.Object);
}
dispatcher.RegisterBus(busMock.Object);
dispatcher.Publish(events);
busMock.Verify(b => b.Publish(It.IsAny<IEnumerable<IEvent>>()), Times.Once());
}
public MySqlEventSource(MySqlConnectionString connectionString, EventDispatcher publisher)
{
var cfg = new Configuration()
.DataBaseIntegration(db =>
{
db.ConnectionString = (String)connectionString;
db.Dialect<MySQLDialect>();
});
/* Add the mapping we defined: */
var mapper = new ModelMapper();
mapper.AddMapping(typeof(RecordedEventMap));
HbmMapping mapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
cfg.AddMapping(mapping);
this.factory = cfg.BuildSessionFactory();
this._publisher = publisher;
this._aggregateIdToStreamName = (t, g) => string.Format("{0}-{1}", char.ToLower(t.Name[0]) + t.Name.Substring(1), g);
}
//--------------------------------------
// Methods
//--------------------------------------
// PUBLIC
/// <summary>
/// Start this instance.
/// </summary>
void Start ()
{
//CREATE
eventDispatcher = new EventDispatcher (this);
//ADD 0, 1, 2, OR MORE LISTENERS...
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1); //default is EventDispatcherAddMode.DEFAULT
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent2, EventDispatcherAddMode.SINGLE_SHOT);
//TEST REMOVE
//eventDispatcher.removeAllEventListeners();
//eventDispatcher.removeEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1);
//TEST HAS
//Debug.Log (" hasEventListener(): " + eventDispatcher.hasEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1));
//TEST EVENT SETUP FROM 3 DIFFERENT SCOPES
eventDispatcher.dispatchEvent (new TestEvent (TestEvent.TEST_EVENT_NAME));
}
void OnDisable()
{
EventDispatcher.RemoveListener <int>(OnShowFaceEvent, OnShowFace);
}
public void Connect()
{
bool tResult;
// Create a SessionOptions object to hold the session parameters
SessionOptions tSessionOptions = new SessionOptions();
// Since this program will run on the same PC as the Bloomberg software,
// we use “localhost” as the host name and port 8194 as the default port.
tSessionOptions.ServerHost = "localhost";
tSessionOptions.ServerPort = 8194;
tSessionOptions.MaxEventQueueSize = mNoOfThreadsForEventDispatcher * 20;
tSessionOptions.SlowConsumerWarningHiWaterMark = 0.1f;
tSessionOptions.SlowConsumerWarningLoWaterMark = 0.01f * mNoOfThreadsForEventDispatcher;
//Create a EventDispatcher
EventDispatcher tEventDispatcher = new EventDispatcher(4);
// Create a Session object using the sessionOptions
try
{
tResult = true;
mSession = new Session(tSessionOptions, null, tEventDispatcher);
}
catch (Exception e)
{
tResult = false;
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, ("Can't create new session: " + e.Message)));
return;
}
// Start the Session
tResult = mSession.Start();
if (!tResult)
{
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, ("Can't start session.")));
}
else
{
// Open up the Market data Service
tResult = mSession.OpenService("//blp/mktdata");
// Get a reference to the service
if (tResult)
{
mMktService = mSession.GetService("//blp/mktdata");
}
else
{
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, ("Can't open mktdata service.")));
}
// Open up the Reference data Service
tResult = mSession.OpenService("//blp/refdata");
// Get a reference to the service
if (tResult)
{
mReferenceService = mSession.GetService("//blp/refdata");
}
else
{
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, ("Can't open refdata service.")));
}
// Open up the Market data Service
tResult = mSession.OpenService("//blp/instruments");
// Get a reference to the service
if (tResult)
{
mLookupService = mSession.GetService("//blp/instruments");
}
else
{
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, ("Can't open instruments service.")));
}
if (!isSessionRunning)
{
isSessionRunning = true;
mBbgMsgWorker = new System.Threading.Thread(ProcessBbgEvent);
mBbgMsgWorker.Start();
}
}
}
void OnDestroy()
{
EventDispatcher.RemoveEventListener(EventDefine.Event_Monster_Hold_Screen, OnShakeScreen);
EventDispatcher.AddEventListener <bool>(EventDefine.Event_Struggle_Hold_Success, OnStruggle);
}
/// <summary>
/// Ctor with EventDispatcher dependency.
/// </summary>
/// <param name="publisher"></param>
public InMemEventStore(EventDispatcher publisher)
{
_publisher = publisher;
}
public void Quit()
{
Time.timeScale = 1;
EventDispatcher.DispatchEvent(Events.SCENE_CHANGED, 0);
SceneManager.LoadScene(0);
}
public static void DispatchEvent(this object aObject, string aEvent)
{
EventDispatcher.DispatchEvent(aEvent, aObject);
}
public void Start()
{
waitingForRadius = false;
dispatcher = Service.Get <EventDispatcher>();
dispatcher.AddListener <PenguinInteraction.InteractionStartedEvent>(onInteractionStarted);
}
/// <summary>
/// 确认购买
/// </summary>
void OnEnergyUseOK()
{
EventDispatcher.TriggerEvent <int>(Events.EnergyEvent.BuyEnergy, m_BuyTimes);
EnergyUIViewManager.Instance.ShowUseOKCancel(false);
}
protected void SetGearControlDisable(uint gearID)
{
EventDispatcher.TriggerEvent <uint>(Events.GearEvent.SetGearEventDisable, gearID);
}
public void RegenerateViewModels(AzureEventLogReader logReader, string dbConnectionString)
{
var commandBus = new NullCommandBus();
Database.SetInitializer<ConferenceRegistrationDbContext>(null);
var handlers = new List<IEventHandler>();
handlers.Add(new ConferenceViewModelGenerator(() => new ConferenceRegistrationDbContext(dbConnectionString), commandBus));
handlers.Add(new PricedOrderViewModelUpdater(() => new ConferenceRegistrationDbContext(dbConnectionString)));
using (var context = new ConferenceRegistrationMigrationDbContext(dbConnectionString))
{
context.UpdateTables();
}
try
{
var dispatcher = new EventDispatcher(handlers);
var events = logReader.Query(new QueryCriteria { });
dispatcher.DispatchMessages(events);
}
catch
{
using (var context = new ConferenceRegistrationMigrationDbContext(dbConnectionString))
{
context.RollbackTablesMigration();
}
throw;
}
}
public static void RemoveEventListener(this object aObject, string aEvent, object aDispatcher, Action <EventObject> aMethod)
{
EventDispatcher.RemoveEventListener(aEvent, aDispatcher, aObject, aMethod);
}
//Global Event
public static void AddGlobalEventListener(this object aObject, string aEvent, Action <EventObject> aMethod, int aPriority = 1)
{
EventDispatcher.AddEventListener(aEvent, GlobalDispatcher.Instance, aObject, aMethod, aPriority);
}
public static void DispatchEvent(this object aObject, string aEvent, object[] aParams)
{
EventDispatcher.DispatchEvent(aEvent, aObject, aParams);
}
protected virtual void OnEnable()
{
EventDispatcher.AddListener <GameScoreEvent>(this);
EventDispatcher.AddListener <GameCommandEvent>(this);
}
protected override void AddListeners()
{
base.AddListeners();
EventDispatcher.AddListener(EventNames.UpdateSpecialInstanceUI, new Callback(this.UpdateUI));
EventDispatcher.AddListener("TimeManagerEvent.UnscaleSecondPast", new Callback(this.UpdateUI));
}
protected virtual void OnDisable()
{
EventDispatcher.RemoveListener <GameScoreEvent>(this);
EventDispatcher.RemoveListener <GameCommandEvent>(this);
}
//Local Event
public static void AddEventListener(this object aObject, string aEvent, object aDispatcher, Action <EventObject> aMethod, int aPriority = 1)
{
EventDispatcher.AddEventListener(aEvent, aDispatcher, aObject, aMethod, aPriority);
}
void OnDestroy()
{
EventDispatcher.RemoveEventListener(Events.GAME_STARTED, OnGameStarted);
EventDispatcher.RemoveEventListener(Events.PLAYER_DIED, OnPlayerDied);
}
void OnEnable()
{
EventDispatcher.AddListener <int>(OnShowFaceEvent, OnShowFace);
}
public ModelManager(EventDispatcher dispatcher)
{
_dispatcher = dispatcher;
_models = new Dictionary <string, IModel>();
}
public static void RemoveAllEventListener(this object aObject)
{
EventDispatcher.RemoveAllEventListner(aObject);
}
public void RegenerateV3ViewModels(AzureEventLogReader logReader, IBlobStorage blobStorage, string dbConnectionString, DateTime maxEventTime)
{
Database.SetInitializer<ConferenceRegistrationDbContext>(null);
var handlers = new List<IEventHandler>();
handlers.Add(new DraftOrderViewModelGenerator(() => new ConferenceRegistrationDbContext(dbConnectionString)));
handlers.Add(new PricedOrderViewModelGenerator(() => new ConferenceRegistrationDbContext(dbConnectionString)));
handlers.Add(
new SeatAssignmentsViewModelGenerator(
new ConferenceDao(() => new ConferenceRegistrationDbContext(dbConnectionString)),
blobStorage,
new JsonTextSerializer()));
var dispatcher = new EventDispatcher(handlers);
var events = logReader.Query(new QueryCriteria { EndDate = maxEventTime });
dispatcher.DispatchMessages(events);
}
/// <summary>
/// Invoked at the end of a transaction to commit any updates to the
/// node hierarchy.
/// </summary>
/// <param name="eventDispatcher">The event dispatcher.</param>
/// <param name="batchId">The batch identifier.</param>
public void DispatchViewUpdates(EventDispatcher eventDispatcher, int batchId)
{
foreach (var tag in _shadowNodeRegistry.RootNodeTags)
{
var cssRoot = _shadowNodeRegistry.GetNode(tag);
NotifyBeforeOnLayoutRecursive(cssRoot);
CalculateRootLayout(cssRoot);
ApplyUpdatesRecursive(cssRoot, eventDispatcher);
}
_nativeViewHierarchyOptimizer.OnBatchComplete();
_operationsQueue.DispatchViewUpdates(batchId);
}
public static void RemoveGlobalEventListener(this object aObject, string aEvent, Action <EventObject> aMethod)
{
EventDispatcher.RemoveEventListener(aEvent, GlobalDispatcher.Instance, aObject, aMethod);
}
protected void SetGearControlStateTwo(uint gearID)
{
EventDispatcher.TriggerEvent <uint>(Events.GearEvent.SetGearEventStateTwo, gearID);
}
public void DoNoMarkDispatchedIfDisabled()
{
var commit = new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, new EventCollection(new Event[] { new FakeEvent() }));
var eventDispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object, new EventStoreSettings { MarkDispatched = false });
commit.Id = 1;
eventDispatcher.PostSave(null, commit, null);
eventStore.Verify(mock => mock.MarkDispatched(commit.Id.GetValueOrDefault()), Times.Never());
}
public static void DispatchGlobalEvent(this object aObject, string aEvent, object[] aParams)
{
EventDispatcher.DispatchEvent(aEvent, GlobalDispatcher.Instance, aParams);
}
public void AggregateCanBeNull()
{
var eventDispatcher = new EventDispatcher(eventStore.Object, eventPublisher.Object);
eventDispatcher.PostSave(null, new Commit(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), 1, HeaderCollection.Empty, EventCollection.Empty), null);
eventPublisher.Verify(mock => mock.Publish(HeaderCollection.Empty, It.IsAny<EventEnvelope>()), Times.Never());
}
/// <summary>
/// Создать <see cref="ChatClient"/>.
/// </summary>
/// <param name="address">Адрес сервера.</param>
public ChatClient(Uri address)
: base(address, "chat", true)
{
_eventDispatcher = new EventDispatcher(ex => ex.LogError());
}
// PRIVATE STATIC
//--------------------------------------
// Methods
//--------------------------------------
// PUBLIC
/// <summary>
/// Start this instance.
/// </summary>
void Start () {
//TEST FROM OTHER CLASS
testFromOtherScope = new TestFromOtherScope("blah1"); //PASS SIMPLE STRING FOR DEBUGGING
testFromOtherScope2 = new TestFromOtherScope("blah2"); //PASS SIMPLE STRING FOR DEBUGGING
//TODO, PASS INSTANCE IN OF 'this'? why?
eventDispatcher = new EventDispatcher (this);
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1);
eventDispatcher.addEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent2, EventDispatcherAddMode.SINGLE_SHOT);
//TEST REMOVE ALL
//eventDispatcher.removeAllEventListeners();
//TEST HAS AND REMOVE
//Debug.Log (" hasEventListener(): " + eventDispatcher.hasEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1));
//Debug.Log (" removeEventListener(): " + eventDispatcher.removeEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1));
//Debug.Log (" hasEventListener(): " + eventDispatcher.hasEventListener (TestEvent.TEST_EVENT_NAME, _onCustomEvent1));
//TEST EVENT SETUP FROM 3 DIFFERENT SCOPES
dispatchIt();
testFromOtherScope.dispatchIt();
testFromOtherScope2.dispatchIt();
}
private void InitEvent()
{
RemoveEvent();
destroyAllListenId = EventDispatcher.AddEventListener(sw.game.evt.UIEventType.DESTROY_ALL_NODE, OnDestroyAllNode);
}
public EventStoreRepository(IEventStoreConnection eventStoreConnection, EventDispatcher publisher)
: this(eventStoreConnection, (t, g) => string.Format("{0}-{1}", char.ToLower(t.Name[0]) + t.Name.Substring(1), g))
{
_publisher = publisher;
}
public void InjectDependencies(EventDispatcher eventDispatcher)
{
this.eventDispatcher = eventDispatcher;
}
public EventProcessor(IMessageReceiver receiver, ITextSerializer serializer)
: base(receiver, serializer)
{
this.messageDispatcher = new EventDispatcher();
}
protected override void RemoveListeners()
{
base.RemoveListeners();
EventDispatcher.RemoveListener(EventNames.OnMultiPvpDailyRewardInfoNty, new Callback(this.OnMultiPvpDailyRewardInfoNty));
}
/// <summary>
/// Invoked when the native view that corresponds to a root node has
/// its size changed.
/// </summary>
/// <param name="rootViewTag">The root view tag.</param>
/// <param name="newWidth">The new width.</param>
/// <param name="newHeight">The new height.</param>
/// <param name="eventDispatcher">The event dispatcher.</param>
public void UpdateRootNodeSize(
int rootViewTag,
double newWidth,
double newHeight,
EventDispatcher eventDispatcher)
{
var rootCssNode = _shadowNodeRegistry.GetNode(rootViewTag);
rootCssNode.Width = (float)newWidth;
rootCssNode.Height = (float)newHeight;
// If we're in the middle of a batch, the change will be
// automatically dispatched at the end of the batch. The event
// queue should always be empty, but that is an implementation
// detail.
if (_operationsQueue.IsEmpty())
{
DispatchViewUpdates(eventDispatcher, -1 /* no associated batch id */);
}
}
private void Awake()
{
eventDispatcher = Service.Get <EventDispatcher>();
}
private void ApplyUpdatesRecursive(
ReactShadowNode cssNode,
EventDispatcher eventDispatcher)
{
if (!cssNode.HasUpdates)
{
return;
}
if (!cssNode.IsVirtualAnchor)
{
for (var i = 0; i < cssNode.ChildCount; ++i)
{
ApplyUpdatesRecursive(
cssNode.GetChildAt(i),
eventDispatcher);
}
}
var tag = cssNode.ReactTag;
if (!_shadowNodeRegistry.IsRootNode(tag))
{
cssNode.DispatchUpdates(
_operationsQueue,
_nativeViewHierarchyOptimizer);
if (cssNode.ShouldNotifyOnLayout)
{
eventDispatcher.DispatchEvent(
OnLayoutEvent.Obtain(
tag,
cssNode.LayoutX,
cssNode.LayoutY,
cssNode.LayoutWidth,
cssNode.LayoutHeight));
}
}
cssNode.MarkUpdateSeen();
}
public override void HandleData()
{
var result = (LoginResult)(byte)Arguments[0];
EventDispatcher.TriggerEvent(Events.FrameWorkEvent.Login, result);
}
public void TestTriggerClientRemoval()
{
Assert.AreEqual (0, (dispatcher as ITriggerProvider).Triggerables);
EventDispatcher anotherDispatcher1 = new EventDispatcher ();
(dispatcher as ITriggerProvider).AddTriggerable (anotherDispatcher1);
Assert.AreEqual (1, (dispatcher as ITriggerProvider).Triggerables);
EventDispatcher anotherDispatcher2 = new EventDispatcher ();
(dispatcher as ITriggerProvider).AddTriggerable (anotherDispatcher2);
Assert.AreEqual (2, (dispatcher as ITriggerProvider).Triggerables);
dispatcher.AddListener (SomeEnum.ONE, removeTriggerClientMethod);
dispatcher.Dispatch (SomeEnum.ONE, anotherDispatcher1);
Assert.AreEqual (1, (dispatcher as ITriggerProvider).Triggerables);
dispatcher.AddListener (SomeEnum.ONE, removeTriggerClientMethod);
dispatcher.Dispatch (SomeEnum.ONE, anotherDispatcher2);
Assert.AreEqual (0, (dispatcher as ITriggerProvider).Triggerables);
}
public void Initialize()
{
EventDispatcher.TriggerEvent("InstanceUILoadPartEnd");
}
public ChatDataManager() {
mChatDataList = new List<ChatData>();
mChatDataDict = new Dictionary<enumChatType, List<ChatData>>();
mDispatcher = Director.GetInstance().eventDispatcher;
}
protected override void RemoveListeners()
{
EventDispatcher.RemoveListener("TimeManagerEvent.UnscaleSecondPast", new Callback(this.OnSecondsPast));
base.RemoveListeners();
}
