public void CancelSkill() { this.so.EventGroup.FireEvent((int)Event.Cancelskill, so, EventGroup.NewArg <EventSingleArgs <string>, string>(RunningSkill.SourceData.path)); RunningSkill.Cancel(); Pool.SP.Recycle(RunningSkill); RunningSkill = null; }
public async Task <IHttpActionResult> PutEventGroup(Guid id, EventGroup eventGroup) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != eventGroup.id) { return(BadRequest()); } db.Entry(eventGroup).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!EventGroupExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) { if (e.Button == MouseButtons.Right && e.Node != null) { _contextNode = e.Node; ContextMenu menu = new ContextMenu(); menu.MenuItems.Add("Add Event Group to End").Click += OnAddEventGroup; if (e.Node.Tag is EventGroup) { EventGroup eg = (EventGroup)e.Node.Tag; menu.MenuItems.Add("Create Event Group Before").Click += OnCreateEventGroupBefore; menu.MenuItems.Add("Create Event Group After").Click += OnCreateEventGroupAfter; if (eg.stopCondition == null) { menu.MenuItems.Add("-"); MenuItem mi = menu.MenuItems.Add("Add Stop Condition"); mi.Click += OnAddStopCondition; } } else if (e.Node.Text == "Events") { menu.MenuItems.Add("-"); menu.MenuItems.Add("Add Event").Click += OnAddEvent; } menu.Show(treeView1, e.Location); } }
/// <summary> /// Enqueues an event to the actor with the specified id. /// </summary> private EnqueueStatus EnqueueEvent(Actor actor, Event e, Actor sender, EventGroup group, SendOptions options) { EventOriginInfo originInfo; string stateName = null; if (sender is StateMachine senderStateMachine) { originInfo = new EventOriginInfo(sender.Id, senderStateMachine.GetType().FullName, NameResolver.GetStateNameForLogging(senderStateMachine.CurrentState)); stateName = senderStateMachine.CurrentStateName; } else if (sender is Actor senderActor) { originInfo = new EventOriginInfo(sender.Id, senderActor.GetType().FullName, string.Empty); } else { // Message comes from the environment. originInfo = new EventOriginInfo(null, "Env", "Env"); } EventInfo eventInfo = new EventInfo(e, originInfo) { MustHandle = options?.MustHandle ?? false, Assert = options?.Assert ?? -1 }; Guid opId = group == null ? Guid.Empty : group.Id; this.LogWriter.LogSendEvent(actor.Id, sender?.Id.Name, sender?.Id.Type, stateName, e, opId, isTargetHalted: false); return(actor.Enqueue(e, group, eventInfo)); }
private async Task CreateGroupAndAssignStudentAndEventAsync(string studentId, string eventId) { var group = new Group() { Name = "group", CreatorId = Guid.NewGuid().ToString(), }; await this.DbContext.Groups.AddAsync(group); var studentGroup = new StudentGroup() { StudentId = studentId, GroupId = group.Id }; await this.DbContext.StudentsGroups.AddAsync(studentGroup); var eventGroup = new EventGroup() { EventId = eventId, GroupId = group.Id }; await this.DbContext.EventsGroups.AddAsync(eventGroup); await this.DbContext.SaveChangesAsync(); this.DbContext.Entry <EventGroup>(eventGroup).State = EntityState.Detached; this.DbContext.Entry <Group>(group).State = EntityState.Detached; this.DbContext.Entry <StudentGroup>(studentGroup).State = EntityState.Detached; }
public async Task <IHttpActionResult> PostEventGroup(EventGroup eventGroup) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } db.EventGroups.Add(eventGroup); try { await db.SaveChangesAsync(); } catch (DbUpdateException) { if (EventGroupExists(eventGroup.id)) { return(Conflict()); } else { throw; } } return(CreatedAtRoute("DefaultApi", new { id = eventGroup.id }, eventGroup)); }
private void EleGroup_EditClick(object sender, RoutedEventArgs e) { EventGroup eventGroup = (EventGroup)((FrameworkElement)sender).DataContext; EventGroupEditPageViewModel eventGroupViewModel = new EventGroupEditPageViewModel(eventGroup, viewModel.GetAllGroups()); Frame.Navigate(typeof(EventGroupEditPage), eventGroupViewModel); }
/// <summary> /// Finds the active event at any give time for a certain event group using a binary search in a per event collection /// </summary> /// <remarks>This collection is updated by UpdateMap</remarks> public Event GetEffectAtTime(TimeDivisionReference time, EventGroup group) { var collection = precomputedEvents[(int)group]; if (collection.Count == 0) { return(null); } int left = 0; int right = collection.Count - 1; while (left < right) { int mid = left + (right - left) / 2; var middle = collection[mid]; if (middle.Position.CompareTo(time) < 0) { left = mid + 1; } else { right = mid; } } return(collection[left].Event); }
internal void Init(CreateInfo createInfo) { EventGroup = new EventGroup(); Team = createInfo.Team; Pool.SP.Recycle(createInfo); createInfo = null; }
public void MapEventGroup_EntityWithNoAssociated_SomeMapped() { var entity = new EventGroup { Id = 1, EventParentId = 1, UserId = "foo", Name = "bar", Description = "baz" }; var expected = new EventGroupModel { Id = 1, EventParentId = 1, Name = "bar", Description = "baz" }; var actual = target.Map <EventGroupModel>(entity); Assert.AreEqual(expected.Id, actual.Id); Assert.AreEqual(expected.EventParentId, actual.EventParentId); Assert.AreEqual(expected.EventParentName, actual.EventParentName); Assert.AreEqual(expected.Name, actual.Name); Assert.AreEqual(expected.Description, actual.Description); }
private async void EleGroup_RemoveClick(object sender, RoutedEventArgs e) { EventGroup eventGroup = (EventGroup)((FrameworkElement)sender).DataContext; await AskRemove(viewModel.Settings.Groups.Collection, eventGroup, $"Do you want to remove group:\n{eventGroup.Name}"); }
private void OnLoadUI(string uiName, UnityEngine.Object obj) { PendingViewInfo info = default(PendingViewInfo); for (int i = _waitingForLoadView.Count - 1; i >= 0; i--) { var pendingViewInfo = _waitingForLoadView[i]; if (pendingViewInfo.UiName.Equals(uiName)) { info = pendingViewInfo; _waitingForLoadView.RemoveAt(i); break; } } if (!info.Equals(default(PendingViewInfo)) && info.UiName.Equals(uiName)) { GameObject go = UnityEngine.Object.Instantiate(obj) as GameObject; go.transform.parent = Main.SP.UIParent; var v = Activator.CreateInstance(info.UiType) as View; _views.Add(v); v.name = uiName; v.Init(go); v.Show(info.Param); FireEvent((int)UIEventList.OnShowUI, this, EventGroup.NewArg <EventSingleArgs <View>, View>(v)); } }
/// <summary> /// Creates a new actor of the specified <see cref="Type"/> and name, using the specified /// unbound actor id, and passes the specified optional <see cref="Event"/>. This event /// can only be used to access its payload, and cannot be handled. The method returns only /// when the actor is initialized and the <see cref="Event"/> (if any) is handled. /// </summary> internal Task <ActorId> CreateActorAndExecuteAsync(ActorId id, Type type, string name, Event initialEvent = null, EventGroup group = null) { var creatorOp = this.Scheduler.GetExecutingOperation <ActorOperation>(); return(this.CreateActorAndExecuteAsync(id, type, name, initialEvent, creatorOp?.Actor, group)); }
private void HideUI(object sender, EventMsg e) { var v = e as EventSingleArgs <View>; v.value.OnHide(); FireEvent((int)UIEventList.OnHideUI, this, EventGroup.NewArg <EventSingleArgs <View>, View>(v.value)); }
/// <inheritdoc/> internal override void SendEvent(ActorId targetId, Event e, Actor sender, EventGroup group, SendOptions options) { if (e is null) { string message = sender != null? string.Format("{0} is sending a null event.", sender.Id.ToString()) : "Cannot send a null event."; this.Assert(false, message); } if (sender != null) { this.Assert(targetId != null, "{0} is sending event {1} to a null actor.", sender.Id, e); } else { this.Assert(targetId != null, "Cannot send event {1} to a null actor.", e); } this.AssertExpectedCallerActor(sender, "SendEvent"); EnqueueStatus enqueueStatus = this.EnqueueEvent(targetId, e, sender, group, options, out Actor target); if (enqueueStatus is EnqueueStatus.EventHandlerNotRunning) { this.RunActorEventHandler(target, null, false, null); } }
public int Add(EventGroupModel model) { try { var user = new EventGroup() { EventId = model.EventId, GroupId = model.GroupId, CreatedBy = model.CreatedBy, CreatedOn = UnixTimeBaseClass.UnixTimeNow }; _db.EventGroups.Add(user); _db.SaveChanges(); return(user.EventGroupId); } catch (Exception ex) { JavaScriptSerializer js = new JavaScriptSerializer(); string json = js.Serialize(model); Log.Error("EventGroup - Add - " + json, ex); throw; } }
public ServiceResult InsertEventGroup(INode n) { if (!this.DataAccessAuthorized(n, "post", false)) { return(ServiceResponse.Error("You are not authorized this action.")); } n.Initialize(this._requestingUser.UUID, this._requestingUser.AccountUUID, this._requestingUser.RoleWeight); var s = (EventGroup)n; s.Name = s.Name.Trim(); using (var context = new GreenWerxDbContext(this._connectionKey)) { EventGroup dbU = context.GetAll <EventGroup>()?.FirstOrDefault(wu => (wu.Name?.EqualsIgnoreCase(s.Name) ?? false) && wu.AccountUUID == s.AccountUUID); if (dbU != null) { return(ServiceResponse.Error("EventGroup already exists.")); } if (context.Insert <EventGroup>(s)) { return(ServiceResponse.OK("", s)); } } return(ServiceResponse.Error("An error occurred inserting EventGroup " + s.Name)); }
/// <summary> /// Initializes a new instance of the <see cref="MockStateMachineManager"/> class. /// </summary> internal MockStateMachineManager(ControlledRuntime runtime, StateMachine instance, EventGroup group) { this.Runtime = runtime; this.Instance = instance; this.IsEventHandlerRunning = true; this.ProgramCounter = 0; this.CurrentEventGroup = group; }
public void Init() { InitConfig(); LockFrameMgr = new LockFrameMgr(); SceneManager = new SceneManager(); EventGroup = new EventGroup(); _timeStep = 1f / LockFrameMgr.FixedFrameRate; }
protected virtual void OnHit(SceneObject receiver) { var _battleScene = LogicCore.SP.SceneManager.CurrentScene as BattleScene; EventManager.TriggerEvent(ProjectileAction.hitEvent, new RuntimeData(Sender, receiver, Data)); EventGroup.FireEvent((int)ProjectileEvent.OnHit, this, null); _battleScene.RemoveSceneObject(this.Id); }
internal override IRule ToRule() { var group = new EventGroup(); group.Bookings = new DbBookingDao().GetByEvents(EventIds); group.Events = new DbEventDao().GetBy(EventIds); return(new EventGroupRule(group, AvailabilityStatus.Booked)); }
private void IbnAddGroup_Click(object sender, RoutedEventArgs e) { EventGroup eventGroup = new EventGroup(); EventGroupEditPageViewModel eventGroupViewModel = new EventGroupEditPageViewModel(eventGroup, viewModel.GetAllGroups()); viewModel.Settings.Groups.Collection.Add(eventGroup); Frame.Navigate(typeof(EventGroupEditPage), eventGroupViewModel); }
protected void StartListenerTask(EventGroup eventGroups) { _uiSyncContext = SynchronizationContext.Current; _listenerCancellationTokenSource = new CancellationTokenSource(); _listenerTask = new Task(() => HandleArgusTVEvents(_listenerCancellationTokenSource.Token), _listenerCancellationTokenSource.Token, TaskCreationOptions.LongRunning); _listenerTask.Start(); }
/// <summary> /// Lay ra danh sach cac su kien trong nhom su kien nay /// </summary> /// <param name="mmEventGroup">mã nhóm sự kiện được chọn </param> /// <Modified> /// Author Date Comments /// Cuongdb 18/2/2008 Tạo mới /// </Modified> public void BindData(int mmEventGroup) { DataTable dt; //DataRow arow; mEventGroup = new EventGroup(mmEventGroup); dt = mEventGroup.GetEvents(); grdSuKien.DataSource = dt; }
private void OnAddStopCondition(object sender, EventArgs e) { EventGroup eg = (EventGroup)_contextNode.Tag; eg.stopCondition = new StopCondition(); TreeNode stopCondition = _contextNode.Nodes.Add("Stop Condition"); stopCondition.Tag = eg.stopCondition; SetDirty(); }
/// <summary> /// Initializes a new instance of the <see cref="MockActorManager"/> class. /// </summary> internal MockActorManager(ControlledRuntime runtime, Actor instance, EventGroup group) { this.Runtime = runtime; this.Instance = instance; this.IsEventHandlerRunning = true; this.ProgramCounter = 0; this.IsTransitionStatementCalledInCurrentAction = false; this.IsInsideOnExit = false; this.CurrentEventGroup = group; }
/// <inheritdoc/> public void OnReceiveEvent(Event e, EventGroup group, EventInfo eventInfo) { if (group != null) { // Inherit the event group of the receive operation, if it is non-null. this.CurrentEventGroup = group; } this.Runtime.NotifyReceivedEvent(this.Instance, e, eventInfo); }
public void SendCommand(LockFrameCommand cmd) { #if LocalDebug cmd.Execute(); return; #endif NetDataWriter w = new NetDataWriter(true); cmd.Serialize(w); EventDispatcher.FireEvent(UIEventList.SendNetMsg.ToInt(), this, EventGroup.NewArg <EventSingleArgs <NetDataWriter>, NetDataWriter>(w)); }
/// <summary> /// Name: ValidDeparment /// Description: Method to check if department is valid /// </summary> private void ValidDeparment(IEnumerable <EventGroup> currentEventGroups, EventGroup eventGroup) { foreach (EventGroup currentEventGroup in currentEventGroups) { if (currentEventGroup.Name.ToLower().Equals(eventGroup.Name.ToLower())) { throw new ManagerException(ERROR_EVENTGROUP_ALREADY_EXIST, new System.Exception(string.Format("A event group with name: {0}, already exist", eventGroup.Name))); } } }
public void PreloadGroup(string name) { EventGroup group = null; RESULT result = eventSystem.getGroup(name, true, ref group); fmodErrorCheck(result); result = group.loadEventData(); fmodErrorCheck(result); }
/// <summary> /// Subscribe your client to a group of ARGUS TV events using a polling mechanism. /// </summary> /// <param name="uniqueClientId">The unique ID (e.g. your DNS hostname combined with a constant GUID) to identify your client.</param> /// <param name="eventGroups">The event group(s) to subscribe to (flags can be OR'd).</param> public async Task SubscribeServiceEvents(string uniqueClientId, EventGroup eventGroups) { var request = NewRequest(HttpMethod.Post, "ServiceEvents/{0}/Subscribe/{1}", uniqueClientId, eventGroups); await ExecuteAsync(request).ConfigureAwait(false); }
public static void LogEvent(EventGroup eg, string name) { LogEvent(eg.ToString(), name); }
public RegionGroup(Region Region) { _Events = new EventGroup(); _Region = Region; }
public EventGroupsWithSubGroups(EventGroup grp, EventGroupSubType[] subGrps) { EventGroup = grp; SubGroups = subGrps; }