private void Alpha_Changed(IChangeable obj) { ParticleStyle.Target.AlphaOverLifetime.Clear(); foreach (SyncLinearKey <float> key in Alpha) { ParticleStyle.Target.AlphaOverLifetime.Append(key); } }
private void Colors_Changed(IChangeable obj) { ParticleStyle.Target.ColorOverLifetime.Clear(); foreach (SyncLinearKey <color> key in Colors) { ParticleStyle.Target.ColorOverLifetime.Append(key); } }
/// <summary> /// Method returns new, the smallest circle which can contains two other circles inside. /// </summary> /// <param name="firstObject">First circle.</param> /// <param name="secondObject">Second circle.</param> /// <returns>New circle.</returns> public IChangeable BuildTheSmallest(IChangeable firstObject, IChangeable secondObject) { var circle = new Circle(this.writer) { Radius = ((Circle)firstObject).Radius + ((Circle)secondObject).Radius }; return(circle); }
/// <summary> /// Method returns new, the smallest rectangle which can contains two other rectangles inside. /// </summary> /// <param name="rectangleFirts">First rectangle.</param> /// <param name="rectangleSecond">Second rectangle.</param> /// <returns>New rectangle.</returns> public IChangeable BuildTheSmallest(IChangeable rectangleFirts, IChangeable rectangleSecond) { Rectangle temp = new Rectangle(this.writer) { Height = ((Rectangle)rectangleFirts).Height + ((Rectangle)rectangleSecond).Height, Width = ((Rectangle)rectangleFirts).Width > ((Rectangle)rectangleSecond).Width ? ((Rectangle)rectangleFirts).Width : ((Rectangle)rectangleSecond).Width }; return(temp); }
public ActionResult Change(int id, string action) { IDictionary <int, Applience> applienceDictionary = (SortedDictionary <int, Applience>)Session["Apps"]; IChangeable app = applienceDictionary[id] as IChangeable; switch (action) { case "Down": app.Down(); break; case "Up": app.Up(); break; } return(RedirectToAction("Index")); }
public void Run() { TrafficLightFactory trafficLightFactory = new TrafficLightFactory(); List <IChangeable> trafficLights = new List <IChangeable>(); string[] trafficStates = Console.ReadLine().Split(); int changesCount = int.Parse(Console.ReadLine()); for (int index = 0; index < trafficStates.Length; index++) { LightColor state = (LightColor)Enum.Parse(typeof(LightColor), trafficStates[index]); IChangeable trafficLight = trafficLightFactory.CreateTrafficLight(state); trafficLights.Add(trafficLight); } for (int counter = 0; counter < changesCount; counter++) { trafficLights.ForEach(tl => tl.ChangeState()); string result = string.Join(" ", trafficLights); Console.WriteLine(result); } }
/// <summary> /// Performs certain action on the object. /// </summary> /// <param name="obj">Object to be changed.</param> /// <param name="keyInfo">Code of key which user pushed.</param> public static void ObjectAction(IChangeable obj, int keyInfo) { UIPart.Counter = 0; UIPart.Writer.SetCursorPosition(0, 0); dynamic manageObject; if (obj is ICircle) { manageObject = obj as ICircle; } else { manageObject = obj as IRectangle; } if (keyInfo == (int)ConsoleKey.N) { CurrentObject++; if (CurrentObject == ObjectCount) { CurrentObject = 0; } return; } if (keyInfo == (int)ConsoleKey.P) { CurrentObject--; if (CurrentObject < 0) { CurrentObject = ObjectCount - 1; } return; } if (keyInfo == (int)ConsoleKey.M) { Regime = "Move"; return; } if (keyInfo == (int)ConsoleKey.S) { Regime = "Size"; return; } switch (keyInfo) { case (int)ConsoleKey.LeftArrow: { if (Regime == "Move") { manageObject.Move(-1, 0); } else { if (obj is ICircle) { manageObject.Resize(-1); } else { manageObject.Resize(0, -1); } }; break; } case (int)ConsoleKey.RightArrow: { if (Regime == "Move") { manageObject.Move(1, 0); } else { if (obj is ICircle) { manageObject.Resize(1); } else { manageObject.Resize(0, 1); } }; break; } case (int)ConsoleKey.UpArrow: { if (Regime == "Move") { manageObject.Move(0, -1); } else { if (manageObject is IRectangle) { manageObject.Resize(1, 0); } }; break; } case (int)ConsoleKey.DownArrow: { if (Regime == "Move") { manageObject.Move(0, 1); } else { if (manageObject is IRectangle) { manageObject.Resize(-1, 0); } }; break; } } }
private List<IChanges> GetPropertyCallbacks(IChangeable component, string property) { var componentCallbacks = GetComponentCallbacks(component); List<IChanges> callbacks; componentCallbacks.TryGetValue(property, out callbacks); if (null == callbacks) { callbacks = new List<IChanges>(); componentCallbacks[property] = callbacks; } return callbacks; }
public void UnsubscribeFromComponentChange(IChangeable component, string property, IChanges callback) { GetPropertyCallbacks(component, property).Remove(callback); }
public void PublishComponentChange(IChangeable component, string property) { PrivatePublish(GetPropertyCallbacks(component, property)); }
public ChangeCommand(IChangeable target, int id) { _target = target; _id = id; }
public ChangeableAppSettings(IAppSettings source, IChangeable changeable) { _source = source; _changeable = changeable; }
private void Update_Paticles(IChangeable obj) { ParticleStyle.Target.UseColorOverLifetime.Value = true; Colors_Changed(Colors); Alpha_Changed(Alpha); }
/// <summary> /// Prints stats about object. /// </summary> /// <param name="obj">Object of IChangeable interface.</param> public static void PrintStats(IChangeable obj) { PrintString("Regime is : " + ObjectController.Regime + '\n'); PrintString(obj.ToString()); }
private ParameterValueReader(IChangeable obj, string param, IDataContainer owner) { Obj = obj; Param = param; Owner = owner; }
public static void Add <T>(this IChangeable <T> r, T item) => r.Change(ItemChangedArgs.Add(item));
internal static ParameterValueReader GetParameterValueReader(IChangeable obj, string param, IDataContainer owner) { Func<ParameterValueReader> create = new Func<ParameterValueReader>(() => new ParameterValueReader(obj, param, owner)); return DoubleDictionary<object, string, ParameterValueReader>.GetItem(obj, param, create); }
public static void Remove <T>(this IChangeable <T> r, T item) => r.Change(ItemChangedArgs.Remove(item));
public void PublishComponentChange(IChangeable component) { foreach (var callbacks in GetComponentCallbacks(component)) { PrivatePublish(callbacks.Value); } }
public static void Remove <T>(this IChangeable <T> r, int id) => r.Change(ItemChangedArgs.Remove <T>(id));
public void SubscribeToComponentChange(IChangeable component, string property, IChanges callback) { GetPropertyCallbacks(component, property).Add(callback); }
public static void Update <T>(this IChangeable <T> r, T item) => r.Change(ItemChangedArgs.Update(item));
private Dictionary<string, List<IChanges>> GetComponentCallbacks(IChangeable component) { Dictionary<string, List<IChanges>> callbacks; allComponentCallbacks.TryGetValue(component, out callbacks); if (null == callbacks) { callbacks = new Dictionary<string, List<IChanges>>(); allComponentCallbacks[component] = callbacks; } return callbacks; }
public static void Reset <T>(this IChangeable <T> r, IEnumerable <T> newItems) => r.Change(ItemChangedArgs.Reset(newItems, null));
public void ExceptionInEventHandler(Func <ReadedFileInfo, IChangeable> checkerCreator, string[] workflow) { string file = Path.GetTempFileName(); File.WriteAllBytes(file, new byte[] { 1, 2, 3 }); var fileInfo = ReadedFileInfo.Create(file, _ => _.CopyTo(Stream.Null)); IChangeable monitor = null; var wait = new ManualResetEvent(false); Exception unhandledException = null; UnhandledExceptionEventHandler handler = (sender, args) => { unhandledException = (Exception)args.ExceptionObject; wait.Set(); }; AppDomain.CurrentDomain.UnhandledException += handler; try { foreach (var op in workflow) { switch (op) { case "create": monitor = checkerCreator(fileInfo); break; case "subscribe": monitor.Changed += (a, e) => { throw new Exception("test"); }; break; case "delete": SafeDelete(file); break; case "modify": Task.Factory.StartNew(() => { Thread.Sleep(150); using (var fs = new FileStream(file, FileMode.Open, FileAccess.Write, FileShare.ReadWrite)) { fs.Position = 2; fs.WriteByte(1); fs.Close(); }; }, TaskCreationOptions.LongRunning); break; case "delay": Thread.Sleep(75); break; default: throw new NotSupportedException(); } } Assert.IsTrue(wait.WaitOne(10000), "10 sec elapsed"); } finally { AppDomain.CurrentDomain.UnhandledException -= handler; } Console.WriteLine(unhandledException); Assert.That(unhandledException.Message, Is.EqualTo("Error while file checking.")); Assert.That(unhandledException.InnerException, Is.Not.Null); Assert.That(unhandledException.InnerException.Message, Is.EqualTo("test")); }
private void Colors_Changed(IChangeable obj) => UpdateGradient();