protected override Geometry2D.Single.Box SegmentBounds(Geometry2D.Single.Transform transform)
{
Geometry2D.Single.Point p0 = this.Start;
Geometry2D.Single.Point p1 = this.First;
Geometry2D.Single.Point p2 = this.Second;
Geometry2D.Single.Point p3 = this.End;
Geometry2D.Single.Transform derivative = new Geometry2D.Single.Transform(transform.A, transform.B, transform.C, transform.D, 0, 0);
Geometry2D.Single.Transform inverse = derivative.Inverse;
Geometry2D.Single.Point e1p = inverse * new Geometry2D.Single.Point(1, 0);
Geometry2D.Single.Point e2p = inverse * new Geometry2D.Single.Point(0, 1);
Geometry2D.Single.Point zero = -3 * p0 + 3 * p1;
Geometry2D.Single.Point one = 6 * p0 - 12 * p1 + 6 * p2;
Geometry2D.Single.Point two = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
Collection.List<float> parameters = new Collection.List<float>();
parameters.Add(0f);
parameters.Add(1f);
this.AddParameterValues(parameters, e1p, zero, one, two);
this.AddParameterValues(parameters, e2p, zero, one, two);
Geometry2D.Single.Point[] points = new Geometry2D.Single.Point[parameters.Count];
for (int i = 0; i < points.Length; i++)
{
//float alpha = i / (float)(points.Length - 1);
float alpha = parameters[i];
Geometry2D.Single.Point current = Kean.Math.Single.Power(1 - alpha, 3) * p0 + 3 * Kean.Math.Single.Power(1 - alpha, 2) * alpha * p1 + 3 * (1 - alpha) * Kean.Math.Single.Power(alpha, 2) * p2 + Kean.Math.Single.Power(alpha, 3) * p3;
points[i] = transform * current;
}
return Geometry2D.Single.Box.Bounds(points);
}
public override bool Flush()
{
Collection.List<char> accumulator = new Collection.List<char>();
while (!this.queue.Empty)
foreach (char c in this.queue.Dequeue())
accumulator.Add(c);
System.Diagnostics.Debug.Write(new string(accumulator.ToArray()));
return true;
}
public override string Complete(string incomplete)
{
Collection.List<string> alternatives = new Collection.List<string>();
foreach (string value in this.Values)
if (value.StartsWith(incomplete))
alternatives.Add(value);
string result = "";
if (alternatives.Count > 0)
for (int i = 0; i < alternatives[0].Length && alternatives.All(s => s[i] == alternatives[0][i]); i++)
result += alternatives[0][i];
return result;
}
public void Initialize(IFactory factory)
{
this.Structures = new Collection.List<Structure>(factory.Create<Structure>(), factory.Create<Structure>());
this.Classes = new Collection.List<Class>(factory.Create<ComplexClass>(), factory.Create<Class>());
this.Objects = new Collection.List<object>(factory.Create<ComplexClass>(), factory.Create<Class>(), factory.Create<bool>(), factory.Create<DateTime>());
this.Numbers = new Collection.List<int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
this.Floats.Add(0.1337f).Add(1.1337f).Add(2.1337f).Add(3.1337f).Add(4.1337f).Add(5.1337f).Add(6.1337f).Add(7.1337f).Add(8.1337f).Add(9.1337f);
this.Empty = new Collection.List<int>();
this.Single = new Collection.List<int>();
this.Single.Add(1337);
this.SingleObject = new Collection.List<object>(factory.Create<Class>());
}
protected override Geometry2D.Single.Box SegmentBounds(Geometry2D.Single.Transform transform)
{
Geometry2D.Single.Box result = new Geometry2D.Single.Box();
Tuple<Geometry2D.Single.Point, float, float> coordinates = this.PlatformctArcCoordinates();
float startAngle = coordinates.Item2;
float endAngle = coordinates.Item3;
Geometry2D.Single.Transform derivative = new Geometry2D.Single.Transform(transform.A, transform.B, transform.C, transform.D, 0, 0);
Geometry2D.Single.Transform inverse = derivative.Inverse;
Geometry2D.Single.Point e1p = inverse * new Geometry2D.Single.Point(1, 0);
Geometry2D.Single.Point e2p = inverse * new Geometry2D.Single.Point(0, 1);
Collection.List<float> angles = new Collection.List<float>();
angles.Add(startAngle);
angles.Add(endAngle);
this.AnglesAdd(angles, Kean.Math.Single.ArcusTangensExtended(-e1p.X * this.Radius.Height, e1p.Y * this.Radius.Width), startAngle, endAngle);
this.AnglesAdd(angles, Kean.Math.Single.ArcusTangensExtended(-e2p.X * this.Radius.Height, e2p.Y * this.Radius.Width), startAngle, endAngle);
Geometry2D.Single.Point[] points = new Geometry2D.Single.Point[angles.Count];
for (int i = 0; i < points.Length; i++)
{
float angle = angles[i];
points[i] = transform * (new Geometry2D.Single.Point(this.Radius.Width * Kean.Math.Single.Cosinus(angle), this.Radius.Height * Kean.Math.Single.Sinus(angle)) + coordinates.Item1);
}
result = Geometry2D.Single.Box.Bounds(points);
return result;
}
char[] FilterInput(Func<char?> read)
{
Collection.IList<char> buffer = new Collection.List<char>();
char? next;
while (buffer.Count <= 0 && (next = read()).HasValue)
switch (next.Value)
{
case '\x1b': // ESC
if ((next = read()).HasValue)
switch (next.Value)
{
case '[': // Arrow keys
if ((next = read()).HasValue)
switch (next.Value)
{
case 'A': this.OnCommand(EditCommand.UpArrow); break;
case 'B': this.OnCommand(EditCommand.DownArrow); break;
case 'C': this.OnCommand(EditCommand.RightArrow); break;
case 'D': this.OnCommand(EditCommand.LeftArrow); break;
case '1':
if ((next = read()).HasValue)
switch (next.Value)
{
case '~': this.OnCommand(EditCommand.Home); break;
}
break;
case '3':
if ((next = read()).HasValue)
switch (next.Value)
{
case '~': this.OnCommand(EditCommand.Delete); break;
}
break;
case '4':
if ((next = read()).HasValue)
switch (next.Value)
{
case '~': this.OnCommand(EditCommand.End); break;
}
break;
case '?':
System.Text.StringBuilder type = new System.Text.StringBuilder();
while ((next = read()).HasValue && next != 'c')
type.Append(next.Value);
string[] parameters = type.ToString().Split(';');
if (parameters.Length > 0)
switch (parameters[0])
{
default:
case "1":
this.Level = OperatingLevel.VT100;
break;
case "6":
case "62":
case "63":
case "64":
this.Level = OperatingLevel.VT400;
break;
}
break;
}
break;
}
break;
case '\x7f': //Delete
switch(this.Level)
{
case OperatingLevel.VT100:
this.OnCommand(EditCommand.Delete);
break;
case OperatingLevel.VT400:
this.OnCommand(EditCommand.Backspace);
break;
}
break;
default:
buffer.Add(next.Value);
break;
}
return buffer.ToArray();
}
public override bool RequestType(Parser editor)
{
Collection.List<string> results = new Collection.List<string>();
foreach (Parameter.Abstract parameter in this.Parameters)
results.Add(parameter.Name + " : " + parameter.Type);
editor.TypeResponse(this, "method : (" + results.Join(" * ") + ") => " + this.ReturnType);
return true;
}
char[] FilterInput(Func<char?> read)
{
Collection.IList<char> buffer = new Collection.List<char>();
char? next;
while (buffer.Count <= 0 && (next = read()).HasValue)
switch (next.Value)
{
case '\0':
break;
case '\x04':
this.OnCommand(EditCommand.Exit);
break;
case '\b':
this.OnCommand(EditCommand.Backspace);
break;
case '\t':
this.OnCommand(EditCommand.Tab);
break;
case '\n':
this.OnCommand(EditCommand.Enter);
break;
case '\r':
this.OnCommand(EditCommand.Enter);
if ((next = read()).HasValue && (next.Value != '\n' && next.Value != '\0'))
buffer.Add(next.Value);
break;
default:
buffer.Add(next.Value);
break;
}
return buffer.ToArray();
}
/// <summary>
/// Creates a new parser.
/// </summary>
public Parser()
{
this.arguments = new Collection.List<Argument>();
}
/// <summary>
/// Parses the argument list and activates the respective callbacks.
/// </summary>
/// <param name="arguments">Argument list to parse.</param>
/// <returns></returns>
public bool Parse(string[] arguments)
{
bool result = true;
Collection.Queue<Token> tokens = new Collection.Queue<Token>();
foreach(string argument in arguments)
{
if (argument.StartsWith("--"))
tokens.Enqueue(new Token(TokenType.Long, argument.Substring(2)));
else if (argument.StartsWith("-") && argument.Length > 1 && char.IsLetter(argument[1]))
{
foreach (char c in argument.Substring(1))
tokens.Enqueue(new Token(TokenType.Short, c.ToString()));
}
else
tokens.Enqueue(new Token(TokenType.Parameter, argument));
}
while (tokens.Count > 0 && result)
{
Argument argument = null;
switch (tokens.Peek().Type)
{
case TokenType.Long:
argument = this[tokens.Dequeue().Value];
break;
case TokenType.Short:
argument = this[tokens.Dequeue().Value[0]];
break;
case TokenType.Parameter:
this.UnassociatedParameterHandler.Call(tokens.Dequeue().Value);
break;
}
if (argument.NotNull() && result)
{
Collection.List<string> parameters = new Collection.List<string>();
for (int i = 0; i < argument.Parameters && result; i++)
{
if (!tokens.Empty && tokens.Peek().Type == TokenType.Parameter)
parameters.Add(tokens.Dequeue().Value);
else
result = false;
}
if (result)
argument.Handler(parameters.ToArray());
}
}
return result;
}
Tuple<string, Member, string[]> Parse(string line)
{
string prefix = "";
Member member;
if (line.StartsWith(".."))
{
member = this.Current.Parent;
if (member.IsNull())
member = this.Current;
else
prefix = "..";
line = line.Substring(2);
}
else if (line.StartsWith("."))
{
member = this.Root;
if (this.current != member)
prefix = ".";
line = line.Substring(1);
}
else
member = this.current;
string[] splitted = line.Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
Collection.List<string> parameters = new Collection.List<string>();
if (splitted.Length > 0)
{
foreach (string name in splitted[0].Split(new char[] { '.' }))
if (member is Object)
{
Member next = (member as Object).Find(m => m.Name == name);
if (next.IsNull())
{
parameters.Add(name);
break;
}
else
member = next;
}
if (splitted.Length > 1)
parameters.Add(splitted[1].SplitAt());
}
return Tuple.Create(prefix, member, parameters.ToArray());
}