/// <summary> /// Translate the specified member event into another /// <see cref="MemberEventArgs"/> with a source set to this /// service. /// </summary> /// <param name="evt"> /// The <b>MemberEventArgs</b>. /// </param> protected virtual void TranslateEvent(MemberEventArgs evt) { IService service = (IService)Service; if (service == null) { // for the JOIN events, the Service property may not be set // until after the "real" service is started // (see synchronized block at the EnsureRunningService method) // just wait till we are out of there lock (this) { service = (IService)Service; } } IService serviceSource = evt.Service; // allow for post-mortem events MemberEventArgs evtSafe = new MemberEventArgs( service == serviceSource ? this : serviceSource, evt.EventType, evt.Member); DispatchMemberEvent(evtSafe); }
private void InvokeMemberEvent(MemberEventHandler handler, MemberEventArgs evt) { if (handler != null) { handler(this, evt); } }
/// <summary> /// Invoked when an <see cref="IMember"/> has left the service. /// </summary> /// <param name="sender"> /// <see cref="IService"/> that raised an event. /// </param> /// <param name="evt"> /// An event which indicates that membership has changed. /// </param> public virtual void OnMemberLeft(object sender, MemberEventArgs evt) { if (InvalidationStrategy != CompositeCacheStrategyType.ListenNone) { ResetFrontMap(); } }
private void Lobby_MemberLeft(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var player = PlayerList.Children.Cast <LobbyPlayer2>().FirstOrDefault(p => p.Member == e.Member); PlayerList.Children.Remove(player); }); }
void CreateProperty(MemberEventArgs e, PointerMono _pointer) { var property = (ScriptableProperty)e.scriptableMember; var propertyMono = (MemberMono)CreateMonoObject(e.componentType, _pointer.transform); AddValueGizmo(property.name, propertyMono.transform); propertyMono.Init(property.propertyInfo, _pointer); }
void CreateMethod(MemberEventArgs e, PointerMono _pointer) { var method = (ScriptableMethod)e.scriptableMember; var methodMono = (MethodMono)CreateMonoObject(typeof(MethodMono), _pointer.transform); AddValueGizmo(method.name, methodMono.transform); methodMono.Init(method, _pointer); }
private void Lobby_MemberJoined(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var invitee = e.Member as LobbyInvitee; var member = e.Member as CustomLobbyMember; if (member != null) { StackPanel stack; if (member.Team == 0) { stack = BlueTeam; } else if (member.Team == 1) { stack = RedTeam; } else { throw new Exception("UNEXPECTED TEAM"); } var player = new LobbyPlayer(member); stack.Children.Add(player); if (e.Member.IsMe) { RedJoin.Visibility = BlueJoin.Visibility = Visibility.Collapsed; if (member.Team != 0) { BlueJoin.Visibility = Visibility.Visible; } if (member.Team != 1) { RedJoin.Visibility = Visibility.Visible; } } Sort(); } else { var player = new InvitedPlayer(invitee); InviteList.Children.Add(player); } }); }
/// <summary> /// Dispatch a <see cref="MemberEventArgs"/> to the registered /// event handlers. /// </summary> /// <param name="evt"> /// <b>MemberEventArgs</b> to dispatch. /// </param> protected virtual void DispatchMemberEvent(MemberEventArgs evt) { switch (evt.EventType) { case MemberEventType.Joined: InvokeMemberEvent(m_memberJoined, evt); break; case MemberEventType.Leaving: InvokeMemberEvent(m_memberLeaving, evt); break; case MemberEventType.Left: InvokeMemberEvent(m_memberLeft, evt); break; } }
private void Lobby_MemberJoined(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var member = e.Member as TBDLobbyMember; if (member != null) { var spots = new[] { Pos0, Pos1, Pos2, Pos3, Pos4 }; var player = new TBDPlayer(lobby.IsCaptain, member, 0); spots[member.SlotID].Child = player; } else { Session.Log("Invite: " + e.Member.Name); } }); }
/// <summary> /// Create and dispatch a new local <see cref="MemberEventArgs"/> /// with the given type to the registered event handlers. /// </summary> /// <param name="eventType"> /// The type of <b>MemberEventArgs</b> to create and dispatch. /// </param> protected virtual void DispatchMemberEvent(MemberEventType eventType) { MemberEventArgs evt = new MemberEventArgs(this, eventType, OperationalContext.LocalMember); switch (evt.EventType) { case MemberEventType.Joined: InvokeMemberEvent(MemberJoined, evt); break; case MemberEventType.Leaving: InvokeMemberEvent(MemberLeaving, evt); break; case MemberEventType.Left: InvokeMemberEvent(MemberLeft, evt); break; } }
private void Lobby_MemberChangedTeam(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var member = e.Member as CustomLobbyMember; StackPanel src, dst; if (member.Team == 1) { src = BlueTeam; dst = RedTeam; } else if (member.Team == 0) { src = RedTeam; dst = BlueTeam; } else { throw new Exception("UNEXPECTED TEAM"); } var player = src.Children.Cast <LobbyPlayer>().FirstOrDefault(p => p.Member == member); src.Children.Remove(player); dst.Children.Add(player); if (e.Member.IsMe) { RedJoin.Visibility = BlueJoin.Visibility = Visibility.Collapsed; if (member.Team != 0) { BlueJoin.Visibility = Visibility.Visible; } if (member.Team != 1) { RedJoin.Visibility = Visibility.Visible; } } Sort(); }); }
private void Lobby_MemberLeft(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var member = e.Member as CustomLobbyMember; StackPanel stack; if (member.Team == 0) { stack = BlueTeam; } else if (member.Team == 1) { stack = RedTeam; } else { throw new Exception("UNEXPECTED TEAM"); } var player = stack.Children.Cast <LobbyPlayer>().FirstOrDefault(p => p.Member == e.Member); stack.Children.Remove(player); }); }
private void Lobby_MemberJoined(object sender, MemberEventArgs e) { Dispatcher.Invoke(() => { var member = e.Member as QueueLobbyMember; if (member != null) { var player = new LobbyPlayer2(lobby.IsCaptain, member, 0); PlayerList.Children.Add(player); var players = PlayerList.Children.Cast <LobbyPlayer2>().ToList(); foreach (var control in players) { PlayerList.Children.Remove(control); int index = lobby.Members.IndexOf(control.Member); PlayerList.Children.Insert(index, control); } } else { var player = new InvitedPlayer(e.Member as LobbyInvitee); InviteList.Children.Add(player); } }); }
/** * listener to receive memberLeft event */ public void OnMemberLeft(object sender, MemberEventArgs evt) { fMemberLeft = true; }
/// <summary> /// Invoked when an <see cref="IMember"/> has left the service. /// </summary> /// <remarks> /// Note: this event could be called during the service restart on /// the local node in which case the listener's code should not /// attempt to use any clustered cache or service functionality. /// </remarks> /// <param name="sender"> /// <see cref="IService"/> that raised an event. /// </param> /// <param name="evt"> /// An event which indicates that membership has changed. /// </param> public virtual void OnMemberLeft(object sender, MemberEventArgs evt) { TranslateEvent(evt); }
public void OnCommunityMemberChanged(object sender, MemberEventArgs e) { Update(e.MemberId); }
/// <summary> /// Invoked when an <see cref="IMember"/> has joined the service. /// </summary> /// <remarks> /// <p> /// The most critical situation arises when a number of threads are /// waiting for a local service restart, being blocked by a /// <b>IService</b> object synchronization monitor. Since the Joined /// event should be fired only once, it is called on a client thread /// <b>while holding a synchronization monitor</b>. An attempt to use /// other clustered service functionality during this local event /// notification may result in a deadlock.</p> /// </remarks> /// <param name="sender"> /// <see cref="IService"/> that raised an event. /// </param> /// <param name="evt"> /// An event which indicates that membership has changed. /// </param> public virtual void OnMemberJoined(object sender, MemberEventArgs evt) { ResetFrontMap(); }
/// <summary> /// Invoked when an <see cref="IMember"/> is leaving the service. /// </summary> /// <param name="sender"> /// <see cref="IService"/> that raised an event. /// </param> /// <param name="evt"> /// An event which indicates that membership has changed. /// </param> public virtual void OnMemberLeaving(object sender, MemberEventArgs evt) { }