public void DispatchEvent(MyEvents gridEvent) { System.EventHandler <MyEventInfo> eventToDispatch = null; switch (gridEvent) { case MyEvents.Event_1: { eventToDispatch = Event_1; break; } case MyEvents.Event_2: { eventToDispatch = Event_2; break; } case MyEvents.Event_3: { eventToDispatch = Event_3; break; } case MyEvents.Event_4: { eventToDispatch = Event_4; break; } case MyEvents.Event_5: { eventToDispatch = Event_5; break; } } if (eventToDispatch == null) { return; } var eventInfo = new MyEventInfo() { Event = gridEvent }; eventToDispatch(this, eventInfo); }
/// <summary> /// Occurs when the user moves away from the text box containing the stint length /// </summary> void stintLength_LostFocus(object sender, EventArgs e) { int newStintLaps; //Validates the input bool incorrectValue = !int.TryParse(stintLength.Text, out newStintLaps); if (!incorrectValue) { newStintLaps = (int)Functions.ValidateBetweenExclusive(newStintLaps, 0, upperBound, "stint length", ref incorrectValue, true); } if (!incorrectValue) { thisStrategy.Stints = thisStrategy.ChangeStintLength(stintIndex, newStintLaps); } //If something has changed, update the stint and the strategy. if (newStintLaps != originalLength) { originalLength = newStintLaps; stintLength.LostFocus -= stintLength_LostFocus; thisStrategy.UpdateStrategyParameters(); MyEvents.OnStrategyModified(thisDriver, thisStrategy, false); } }
void UpdateCalendar() { var events = MyEvents.Select(i => new CalendarInlineEvent { StartTime = i.StartTime.ToLocalTime(), EndTime = i.StartTime.AddHours(3).ToLocalTime(),//i.EndTime.ToLocalTime(), Subject = i.Name, Color = i.RSVPStatus == "attending" ? Color.Blue : Color.Red }); CalEvents.Clear(); ScheduleEvents.Clear(); foreach (var ev in MyEvents) { CalEvents.Add(new CalendarInlineEvent() { StartTime = ev.StartTime.ToLocalTime(), EndTime = ev.EndTime.AddHours(3).ToLocalTime(), Subject = ev.Name, Color = ev.RSVPStatus == "attending" ? Color.Blue : Color.Red }); ScheduleEvents.Add(new ScheduleAppointment() { StartTime = ev.StartTime.ToLocalTime(), EndTime = ev.EndTime.AddHours(3).ToLocalTime(), Subject = ev.Name, Notes = ev.Id, Color = ev.RSVPStatus == "attending" ? Color.Blue : Color.Red }); } ; }
void MyPanel_PanelClosed() { if (inContentPanel) { MyEvents.OnRemoveContentPanel(this.PanelIndex); } removed = true; }
/// <summary> /// Shows a detailed section of the axes around the specified lap /// </summary> /// <param name="displayUpToLap">The lap to show in detail</param> void ScaleAxes(int displayUpToLap) { int displayFromLap = (displayUpToLap - 15 < 0 ? 0 : displayUpToLap - 15); horizontalAxis.axisLabelSpacing = 1; horizontalAxis.baseOffset = displayFromLap; horizontalAxis.scaleFactor = (float)(graphArea.Width) / (float)(displayUpToLap - displayFromLap); MyEvents.OnAxesComputerGenerated(horizontalAxis, verticalAxis, graphNormalisationType); }
private async void SetupSampleData() { var items = await SampleData.GetEventFeed(); foreach (var item in items) { FeatureEvents.Add(item); MyEvents.Add(item); AllEvents.Add(item); } }
/// <summary> /// Saves the current settings data and writes it to files if it is valid /// </summary> void ConfirmChanges() { bool incorrectValue = false; SaveSettingsData(ref incorrectValue); if (!incorrectValue) { Data.Settings.WriteSettingsData(); } MyEvents.OnSettingsModified(); }
public void ChangeStintTyreType(int stintToChange, TyreType newTyreType) { listOfStints[stintToChange].tyreType = newTyreType; int lapsThroughRace = listOfStints[stintToChange].startLap; listOfStints[stintToChange] = PopulateSingleStint(Stints[stintToChange], ref lapsThroughRace); UpdateStrategyParameters(); MyEvents.OnStrategyModified(Data.Drivers[driverIndex], this, false); }
void OK_Click(object sender, EventArgs e) { //Validate the input bool incorrectValue = false; PopulateAxisValues(ref incorrectValue); if (!incorrectValue) //If all values are within reasonable bounds { //Modify the axes MyEvents.OnAxesChangedByUser(localHorizontalAxis, localVerticalAxis, localNormalisationType); } }
/// <summary> /// Once data is loaded, displays and populates the controls on the panel /// </summary> void StrategyViewerData_DataLoaded() { MyEvents.OnFinishedLoadingStrategies(); if (!isInitialised) { InitialiseControls(); AddToolStrip(); isInitialised = true; } DrawGraph(true, true); DisplayStints(Data.DriverIndex); }
/// <summary> /// Sets the axes to default locations proportional to the size of the graph panel /// </summary> public void SetupAxes(int raceLaps) { horizontalAxis.startLocation = 50; //Get the available graph area graphArea = SetGraphArea(); horizontalAxis.baseOffset = 0; horizontalAxis.scaleFactor = (float)(graphArea.Width) / (float)(raceLaps + 1); horizontalAxis.axisLabelSpacing = (int)((25 * raceLaps) / (graphArea.Width)); verticalAxis.baseOffset = 0; verticalAxis.scaleFactor = (float)((graphArea.Height) / 100); verticalAxis.startLocation = (graphArea.Height / 2) + 10; verticalAxis.axisLabelSpacing = (int)(50 / verticalAxis.scaleFactor); MyEvents.OnAxesModified(horizontalAxis, verticalAxis, graphNormalisationType, false); }
public void DispatchEvent(MyEvents gridEvent) { System.EventHandler<MyEventInfo> eventToDispatch = null; switch (gridEvent) { case MyEvents.Event_1: { eventToDispatch = Event_1; break; } case MyEvents.Event_2: { eventToDispatch = Event_2; break; } case MyEvents.Event_3: { eventToDispatch = Event_3; break; } case MyEvents.Event_4: { eventToDispatch = Event_4; break; } case MyEvents.Event_5: { eventToDispatch = Event_5; break; } } if (eventToDispatch == null) return; var eventInfo = new MyEventInfo() { Event = gridEvent }; eventToDispatch(this, eventInfo); }
private void AddPitStopToStrategy(int driverIndex, int lapNumber) { Strategy thisStrategy = strategyViewerData.GetStrategy(driverIndex); bool stopWithinRange; int nearestStop = thisStrategy.GetNearestPitStop(lapNumber, 1, out stopWithinRange); if (stopWithinRange) { thisStrategy.Stints = thisStrategy.RemovePitStop(nearestStop); } else { thisStrategy.Stints = thisStrategy.AddPitStop(lapNumber); } thisStrategy.UpdateStrategyParameters(); MyEvents.OnStrategyModified(Data.Drivers[driverIndex], thisStrategy, false); }
void StartTimingDataPanel(bool loadFromFile) { Model.CalculationControllers.CalculationController.PopulateDriverDataFromFiles(Data.RaceIndex); Model.CalculationControllers.CalculationController.CalculatePaceParameters(); if (Program.TimeAnalysis != null) { RemoveContentPanel(Program.TimeAnalysis); //If the panel has been started and not initialised (i.e. data not loaded): if (Program.TimeAnalysis.Removed && Program.TimeAnalysis.IsInitialised) { Program.TimeAnalysis.OnPanelClosed(AssociatedForm); } } Program.TimeAnalysis = new PaceParameters(base.AssociatedForm, loadFromFile); MyEvents.OnFinishedLoadingParameters(); }
public bool AddAvatarPedestalsToTrigger(GameObject MyObjectWithTrigger, List <GameObject> MyAvatarPedestals) { VRC_Trigger MyTriggerScript; List <VRC_Trigger.TriggerEvent> TriggerEvents; VRC_Trigger.TriggerEvent MyTriggerEvent; List <VRC_EventHandler.VrcEvent> MyEvents; VRC_EventHandler.VrcEvent MyEvent; if (MyObjectWithTrigger == null) { CustomMessage = "Select Objects With Trigger If You Want To Toggle Avatar Pedestals By Pressing Button"; return(false); } MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>(); if (MyTriggerScript == null) { CustomMessage = "Object Does Not Contain A Trigger"; return(false); } MyTriggerScript.interactText = "Avatars"; TriggerEvents = MyTriggerScript.Triggers; MyTriggerEvent = new VRC_Trigger.TriggerEvent(); MyTriggerEvent.TriggerType = VRC_Trigger.TriggerType.OnInteract; if (bLocalActivateByTrigger) { MyTriggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local; } MyEvents = MyTriggerEvent.Events; MyEvent = new VRC_EventHandler.VrcEvent(); MyEvent.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive; MyEvent.ParameterObjects = MyAvatarPedestals.ToArray(); MyEvent.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.Toggle; MyEvents.Add(MyEvent); TriggerEvents.Add(MyTriggerEvent); return(true); }
public async Task GetMyEvents() { var feedResultEntity = await _eventManager.GetMyEvents(Locator.ViewModels.MainPageVm.CurrentTokens, "inSessionAndUpcoming", Locator.ViewModels.MainPageVm.CurrentUser.Region); var result = await ResultChecker.CheckSuccess(feedResultEntity); if (!result) { return; } var feedEntity = JsonConvert.DeserializeObject <EventsResponse>(feedResultEntity.ResultJson); foreach (var feed in feedEntity.Events) { MyEvents.Add(feed); } }
/// <summary> /// Handles the button clicked events on any of the buttons within the control. /// </summary> /// <param name="controlNumber">The control number that fired the event</param> void ButtonClicked(int controlNumber) { int startLapNumber = thisStrategy.Stints[stintIndex].startLap; int midLapNumber = (int)((thisStrategy.Stints[stintIndex].stintLength) / 2) + startLapNumber; //Performs the required action on the strategy: switch (controlNumber) { case 0: thisStrategy.SwapStints(stintIndex - 1, stintIndex); break; //moves stint up case 1: thisStrategy.SwapStints(stintIndex, stintIndex + 1); break; //moves stint down case 2: thisStrategy.Stints = thisStrategy.AddPitStop(midLapNumber); break; //splits stint case 3: thisStrategy.Stints = thisStrategy.RemovePitStop(startLapNumber); break; //merges stint with previous } //Updates the strategy's parameters thisStrategy.UpdateStrategyParameters(); MyEvents.OnStrategyModified(thisDriver, thisStrategy, false); }
void AddClass(string name, ManagementClass c) { TreeNode node = treeClasses.Nodes[0]; if (c.Derivation.Contains("__Event")) { Globals.FindOrAddNode("Event-Generating", ref node); MyEvents.Classify(name, ref node); } else { if (TestForProperties(c, ref node)) { MyProperties.Classify(name, ref node); } else { Globals.FindOrAddNode("Other", ref node); MyOther.Classify(name, ref node); } } node.Nodes.Add(name, name, 3, 2); }
/// <summary> /// Scales the axes after the availabe graph area is changed /// </summary> /// <param name="oldSize">The old graph area</param> /// <param name="newSize">The new graph area</param> void ScaleAxes(Rectangle oldSize, Rectangle newSize) { float scaleFactorX = (float)newSize.Width / (float)oldSize.Width; float scaleFactorY = (float)newSize.Height / (float)oldSize.Height; horizontalAxis.axisLabelSpacing = (int)Math.Round(scaleFactorX * horizontalAxis.axisLabelSpacing); if (horizontalAxis.axisLabelSpacing == 0) { horizontalAxis.axisLabelSpacing = 1; } verticalAxis.axisLabelSpacing = (int)Math.Round(scaleFactorY * verticalAxis.axisLabelSpacing); if (verticalAxis.axisLabelSpacing == 0) { verticalAxis.axisLabelSpacing = 1; } horizontalAxis.scaleFactor *= scaleFactorX; verticalAxis.scaleFactor *= scaleFactorY; verticalAxis.startLocation = (int)(scaleFactorY * verticalAxis.startLocation); MyEvents.OnAxesComputerGenerated(horizontalAxis, verticalAxis, graphNormalisationType); }
public MyEventArgs(MyEvents myEvents) { MyEvents = myEvents; }
public List <Event> GetUpcoming() { var events = MyEvents.Where(m => m.FromDate >= DateTime.UtcNow && !m.IsDeleted).OrderBy(e => e.FromDate).ToList(); return(events); }
public List <Event> PastEvents() { var events = MyEvents.Where(m => m.FromDate < DateTime.UtcNow && !m.IsDeleted).OrderByDescending(e => e.FromDate).Take(5).ToList(); return(events); }
void lapNumber_SelectedIndexChanged(object sender, EventArgs e) { currentLapNumber = lapNumber.SelectedIndex + 1; MyEvents.OnLapNumberChanged(currentLapNumber); }
private void Awake() { GameSystem.dailyData11 = data; MyEvents.Add(new MyEvent7(ref MyEvents)); }
public ActionResult My(string Search, int Order = 0) { var friendship = new MyEvents(DB, Search, Order, CurrentUser); return(PartialView(friendship)); }
public void LoadList() { MyEvents <T, M> .LoadList("getList").ForEach(w => this.Items.Add(w)); }
/// <summary> /// Runs a race simulation and outputs the results to a graph. /// </summary> public void SimulateRace() { //overtake variables: Driver driverAhead, driverBehind; RaceStrategy temp; for (int lapNumber = 0; lapNumber < laps; lapNumber++) //for each lap { for (int position = 0; position < Data.NumberOfDrivers; position++) { //check for lapped car encounters: bool stayInLoop = true; float previousLapDeltaTime = 0; float thisLapDeltaTime = 0; for (int lappedPosition = Data.NumberOfDrivers - 1; stayInLoop; lappedPosition--) { previousLapDeltaTime = (raceStrategies[lappedPosition].CumulativeTime - raceStrategies[position].CumulativeTime); thisLapDeltaTime = (raceStrategies[lappedPosition].RaceLapTimes[lapNumber] - raceStrategies[position].RaceLapTimes[lapNumber]); if ((previousLapDeltaTime % raceStrategies[position].RaceLapTimes[lapNumber]) < thisLapDeltaTime) { raceStrategies[lappedPosition].RaceLapTimes[lapNumber] += Data.Settings.BackmarkerLoss; } stayInLoop = (previousLapDeltaTime > raceStrategies[position].RaceLapTimes[lapNumber]); } } for (int position = 1; position < raceStrategies.Length; position++) { //check for overtakes: driverAhead = raceStrategies[position - 1].Driver; driverBehind = raceStrategies[position].Driver; if (CalculateOvertake(driverAhead, driverBehind, position, lapNumber) || forcedOvertake[driverBehind.DriverIndex, lapNumber]) { raceStrategies[position - 1].RaceLapTimes[lapNumber] += Data.Settings.TimeLoss; //swap strategies temp = raceStrategies[position - 1]; raceStrategies[position - 1] = raceStrategies[position]; raceStrategies[position] = temp; } else { //check for following in traffic if (FollowingInTraffic(position - 1, position, lapNumber)) { float minimumTime = raceStrategies[position - 1].CumulativeTime + raceStrategies[position - 1].RaceLapTimes[lapNumber] + Data.Settings.TimeGap; float requiredLap = minimumTime - raceStrategies[position].CumulativeTime; raceStrategies[position].RaceLapTimes[lapNumber] = requiredLap; } } } List <PitStop> pitStopList = new List <PitStop>(); for (int position = 0; position < raceStrategies.Length; position++) { //update pit stops: if (raceStrategies[position].PitStops.Exists(lapNumber + 1)) { pitStopList.Add(new PitStop(position, lapNumber, raceStrategies[position].PaceParameters.PitStopLoss)); } } foreach (PitStop p in pitStopList) { p.SimulateStop(ref raceStrategies); } PitStop.UpdateRacePositionsAfterPitStop(ref raceStrategies, pitStopList); for (int position = 0; position < raceStrategies.Length; position++) { //update the times: raceStrategies[position].CumulativeTime += raceStrategies[position].RaceLapTimes[lapNumber]; //update the positions: positions[position, lapNumber].driver = raceStrategies[position].Driver.DriverIndex; positions[position, lapNumber].position = position; positions[position, lapNumber].cumulativeTime = raceStrategies[position].CumulativeTime; if (position == 0) { positions[position, lapNumber].gap = 0; positions[position, lapNumber].interval = lapNumber; } else { positions[position, lapNumber].gap = GetGapBetweenCars(0, position, lapNumber); positions[position, lapNumber].interval = GetGapBetweenCars(position - 1, position, lapNumber); } } MyEvents.OnUpdateIntervals(positions, lapNumber); } //end for each lap StartGraph(); }
public bool RemoveObjectsInTrigger(GameObject MyGameObject, GameObject MyObjectWithTrigger) { VRC_Trigger MyTriggerScript; List <VRC_Trigger.TriggerEvent> TriggerEvents = null; List <VRC_EventHandler.VrcEvent> MyEvents; int i, l, m, n, k; if (MyObjectWithTrigger != null) { MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>(); if (MyTriggerScript != null) { TriggerEvents = MyTriggerScript.Triggers; } } if (TriggerEvents != null) { for (k = 0; k < TriggerEvents.Count; k++) { MyEvents = TriggerEvents[k].Events; if (MyEvents == null || MyEvents.Count == 0) { TriggerEvents.RemoveAt(k); k--; } if (MyEvents != null) { for (i = 0; i < MyEvents.Count; i++) { n = 0; for (l = MyEvents[i].ParameterObjects.Length - 1; l >= 0; l--) { if (MyEvents[i].ParameterObjects[l] == MyGameObject) { for (m = l; m < MyEvents[i].ParameterObjects.Length - 1; m++) { MyEvents[i].ParameterObjects[m] = MyEvents[i].ParameterObjects[m + 1]; } n++; } } if (n > 0) { n = MyEvents[i].ParameterObjects.Length - n; Array.Resize(ref MyEvents[i].ParameterObjects, n); if (MyEvents[i].ParameterObjects.Length == 0) { MyEvents.RemoveAt(i); i--; if (MyEvents.Count == 0) { TriggerEvents.RemoveAt(k); k--; } } } if (MyEvents == null) { break; } } } } } return(true); }
public bool RemoveWrongVariablesInTrigger(GameObject MyObjectWithTrigger) { VRC_Trigger MyTriggerScript; List <VRC_Trigger.TriggerEvent> TriggerEvents = null; List <VRC_EventHandler.VrcEvent> MyEvents; int i, l, m, n, k; if (MyObjectWithTrigger == null) { CustomMessage = "Select \"Objects With Trigger\" To Remove Wrong Variables"; return(false); } MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>(); if (MyTriggerScript == null) { CustomMessage = "Object Does Not Contain A Trigger"; return(false); } TriggerEvents = MyTriggerScript.Triggers; if (TriggerEvents != null) { for (k = 0; k < TriggerEvents.Count; k++) { MyEvents = TriggerEvents[k].Events; if (MyEvents.Count == 0) { TriggerEvents.RemoveAt(k); k--; } if (MyEvents != null) { for (i = 0; i < MyEvents.Count; i++) { n = 0; for (l = MyEvents[i].ParameterObjects.Length - 1; l >= 0; l--) { if (MyEvents[i].ParameterObjects[l] == null) { for (m = l; m < MyEvents[i].ParameterObjects.Length - 1; m++) { MyEvents[i].ParameterObjects[m] = MyEvents[i].ParameterObjects[m + 1]; } n++; } } if (n > 0) { n = MyEvents[i].ParameterObjects.Length - n; Array.Resize(ref MyEvents[i].ParameterObjects, n); if (MyEvents[i].ParameterObjects.Length == 0) { MyEvents.RemoveAt(i); i--; if (MyEvents.Count == 0) { TriggerEvents.RemoveAt(k); k--; } } } if (MyEvents == null) { break; } } } } } return(true); }
public static void Trigger(MyEvents myEvents) { OnMyEvent(new MyEventArgs(myEvents)); }
private void AxisModified(object sender, axisParameters e) { MyEvents.OnAxesComputerGenerated(GraphPanel.HorizontalAxis, GraphPanel.VerticalAxis, GraphPanel.NormalisationType); Invalidate(); }
static void Bridges() { var evt = new MyEvents(); // // Rx doesn't claim to substitue existing technologies with some new // approach using IObservable exclusively. For example, regular .NET // events, the asynchronous pattern, etc. are still perfectly fine to // be used. However, when composition enters the picture, Rx provides // a solution. Therefore we can bridge the old world to the new world // using various operators. Rx is the glue that binds those worlds // together using operators and combinators. // // // A first sample is FromEvent for which we have a reflective version // as well as one that uses add/remove handler delegates. // Console.WriteLine("FromEvent"); var mme1 = Observable.FromEvent<MyEventArgs>(evt, "Bar"); var mme2 = Observable.FromEvent<MyEventArgs>(handler => evt.Bar += handler, handler => evt.Bar -= handler); using (mme1.Subscribe(e => Console.WriteLine("1 --> " + e.EventArgs.Value))) using (mme2.Subscribe(e => Console.WriteLine("2 --> " + e.EventArgs.Value))) { evt.Raise(42); evt.Raise(43); } evt.Raise(24); // All subscriptions gone; no output expected. Console.WriteLine(); // // Secondly, there's the asynchronous invocation Begin/End pair pattern, // which can be bridged using FromAsyncPattern. // Console.WriteLine("FromAsyncPattern"); using (var fs = File.OpenRead(@"..\..\Program.cs")) { // // The signature of the Begin method is reflected in the FromAsyncPattern // generic parameters. The last one is the return type, in this case an // int returning the number of bytes read, as seen on the End method. // var readAsync = Observable.FromAsyncPattern<byte[], int, int, int>(fs.BeginRead, fs.EndRead); // // Using readAsync, we can invoke the Begin/End pair without worrying about // the IAsyncResult madness. In here, res will be an IObservable<int> which // will contain the result of the EndRead call, i.e. the number of bytes // read from the input. // var data = new byte[16]; var res = readAsync(data, 0, data.Length); // // We'll use Run to go synchronously here, such that we don't dispose the // opened FileStream prematurely. // res.Run(x => Console.WriteLine("{0} bytes read: {1}", x, Encoding.ASCII.GetString(data))); } Console.WriteLine(); // // Third, the Task Parallel Library introduced in .NET 4 (and backported to 3.5 // when installing Rx) has the notion of a Task<T> which is like a single-result // IObservable<T> (i.e. a deferred Return<T> observable). We can convert this to // an observable as well. // Console.WriteLine("Task<T>"); var tsk = Task<int>.Factory.StartNew(() => { Thread.Sleep(2000); return 42; }); tsk.ToObservable().Run(Console.WriteLine); Console.WriteLine(); // // Fourth, enumerable sequences can be iterated asynchronously, resulting in an // observable sequence as well. Let's create some sequence that ticks at a slow // pace, producing values 0..9, and watch it using observables. Instead of using // Run which would make the whole thing synchronous, we're printing dots on the // main thread till completion is signaled by the enumeration that's happening // on a background thread spawn by ToObservable. This illustrates how concurrency // is introduced by ToObservable. // Console.WriteLine("ToObservable"); var xs = Enumerable.Range(0, 10).Select(x => { Thread.Sleep(x * 100); return x; }); var isDone = false; xs.ToObservable(Scheduler.ThreadPool /* where to do the iteration */) .Subscribe(Console.WriteLine, () => isDone = true); while (!isDone) { Console.Write("."); Thread.Sleep(500); } Console.WriteLine(); // // Finally, regular functions or actions can be invoked in the background as well, // exposing their results through an IObservable using the Start operator. // Console.WriteLine("Func"); var anw = Observable.Start(() => { Thread.Sleep(2000); return 42; }); anw.Run(Console.WriteLine); Console.WriteLine(); }