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();
