private void CcSymbolsAddClicked(object sender, EventArgs e)
{
ISymbol s = null;
string type = cmbSymbolType.SelectedItem.ToString();
switch (type)
{
case "Simple":
s = new SimpleSymbol();
break;
case "Character":
s = new CharacterSymbol();
break;
case "Picture":
s = new PictureSymbol();
break;
}
if (s != null)
{
ccSymbols.Symbols.Add(s);
}
ccSymbols.RefreshList();
UpdatePreview();
}
public List <SimpleSymbol> GetDoubleMana()
{
var requestPath = $"/symbology";
var request = new RestRequest(requestPath, DataFormat.Json);
var jsonString = _client.Get(request).Content;
var symbolData = SymbolContainer.FromJson(jsonString);
var symbols = symbolData.Symbols;
var simpleSymbols = new List <SimpleSymbol>();
foreach (var symbol in symbols)
{
if (symbol.AppearsInManaCosts && symbol.Colors.Count != 2)
{
var simpleSymbol = new SimpleSymbol
{
SymbolCode = symbol.SymbolCode,
SymbolText = symbol.SymbolText,
ImgUri = symbol.SvgUri,
SymbolColors = symbol.Colors
};
simpleSymbols.Add(simpleSymbol);
}
}
return(simpleSymbols);
}
private static ISymbolicExpressionGrammar CreateTestGrammar2()
{
var grammar = new SimpleSymbolicExpressionGrammar();
var x = new SimpleSymbol("<x>", 2);
var z = new SimpleSymbol("<z>", 6);
var a = new SimpleSymbol("<a>", 1);
var b = new SimpleSymbol("<b>", 1);
var c = new SimpleSymbol("<c>", 1);
var d = new SimpleSymbol("<d>", 1);
var _x = new SimpleSymbol("x", 0);
var _y = new SimpleSymbol("y", 0);
grammar.AddSymbol(x);
grammar.AddSymbol(z);
grammar.AddSymbol(a);
grammar.AddSymbol(b);
grammar.AddSymbol(c);
grammar.AddSymbol(d);
grammar.AddSymbol(_x);
grammar.AddSymbol(_y);
grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
//uncommenting the line below changes the minimum expression length for the symbol <x>
grammar.AddAllowedChildSymbol(x, z);
grammar.AddAllowedChildSymbol(z, _x);
grammar.AddAllowedChildSymbol(x, a);
grammar.AddAllowedChildSymbol(a, b);
grammar.AddAllowedChildSymbol(b, c);
grammar.AddAllowedChildSymbol(c, d);
grammar.AddAllowedChildSymbol(d, _y);
return(grammar);
}
/// <summary>
/// Contructor of formula that corresponds the double value
/// </summary>
/// <param name="level">the level</param>
/// <param name="sizes">the array of different level symbols' sizes</param>
/// <param name="a">the value</param>
public MathFormula(byte level, int[] sizes, bool a)
: this(level, sizes)
{
MathSymbol s = new SimpleSymbol('?', (byte)FormulaConstants.Number, false);
s.Append(this);
First.BoolValue = a;
}
private static ISymbolicExpressionGrammar CreateTestGrammar3()
{
var grammar = new SimpleSymbolicExpressionGrammar();
var x = new SimpleSymbol("<x>", 1);
grammar.AddSymbol(x);
grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
grammar.AddAllowedChildSymbol(x, x);
return(grammar);
}
/// <summary>
/// Detects operation
/// </summary>
/// <param name="s">First symbol of the formula</param>
/// <returns>Acceptor of operation</returns>
public IOperationAcceptor Detect(MathSymbol s)
{
if (s is SimpleSymbol)
{
SimpleSymbol sym = s as SimpleSymbol;
if ((sym.Bold == bold) & (sym.Italic == italic) & (sym.SymbolType == type))
{
return(new StringOperationAcceptor(s.String));
}
}
return(null);
}
private ISymbolicExpressionTreeGrammar GenerateSimpleGrammar()
{
var branch = new SimpleSymbol("branch", "", 2, 2);
var leaf = new SimpleSymbol("leaf", "", 0, 0);
var grammar = new SimpleSymbolicExpressionGrammar();
grammar.AddSymbol(branch);
grammar.AddSymbol(leaf);
grammar.AddAllowedChildSymbol(branch, leaf);
return(grammar.CreateExpressionTreeGrammar());;
}
/// <summary>
/// Detects operation
/// </summary>
/// <param name="s">First symbol of the formula</param>
/// <returns>Acceptor of operation</returns>
public IOperationAcceptor Detect(MathSymbol s)
{
if (s is SimpleSymbol)
{
SimpleSymbol ss = s as SimpleSymbol;
if (s.Symbol == '\u2211')
{
return(new ArraySingleOperationAcceptor(ArraySingleOperationType.Sum));
}
}
return(null);
}
/// <summary>
/// Creates formula
/// </summary>
/// <param name="tree">Operation tree</param>
/// <param name="level">Formula level</param>
/// <param name="sizes">Sizes of symbols</param>
/// <returns>The formula</returns>
public MathFormula CreateFormula(ObjectFormulaTree tree, byte level, int[] sizes)
{
MathFormula form = new MathFormula(level, sizes);
MathFormula f = new MathFormula(level, sizes);
MathSymbol sym = new SimpleSymbol('¬', (byte)FormulaConstants.Unary, false, "¬");
sym.Append(form);
sym = new BracketsSymbol();
sym.Append(form);
form.Last[0] = FormulaCreator.CreateFormula(tree[0], level, sizes);
return(form);
}
private void CcSymbolsAddClicked(object sender, EventArgs e)
{
ISymbol s = null;
SymbolType symbolType = Global.ParseEnum <SymbolType>(cmbSymbolType.SelectedIndex);
switch (symbolType)
{
case SymbolType.Simple:
s = new SimpleSymbol();
break;
case SymbolType.Character:
CharacterSymbol cs = new CharacterSymbol();
string fontFamily = Properties.Settings.Default.DetailedPointSymbolControlFontFamilyName;
if (!string.IsNullOrWhiteSpace(fontFamily))
{
cs.FontFamilyName = fontFamily;
}
s = cs;
break;
case SymbolType.Picture:
s = new PictureSymbol();
break;
case SymbolType.Custom:
MessageBox.Show("暂未实现");
return;
}
if (s != null)
{
double width = Properties.Settings.Default.DetailedPointSymbolControlSymbolWidth;
double height = Properties.Settings.Default.DetailedPointSymbolControlSymbolHeight;
if (width <= 0)
{
width = 10;
}
if (height <= 0)
{
height = 10;
}
s.Size = new Size2D(width, height);
s.SetColor(ccSymbols.SelectedSymbol.GetColor());
ccSymbols.Symbols.Add(s);
UpdatePreview();
}
}
/// <summary>
/// Creates formula
/// </summary>
/// <param name="tree">Operation tree</param>
/// <param name="level">Formula level</param>
/// <param name="sizes">Sizes of symbols</param>
/// <returns>The formula</returns>
public MathFormula CreateFormula(ObjectFormulaTree tree, byte level, int[] sizes)
{
MathFormula form = new MathFormula(level, sizes);
MathSymbol sym = null;
if (symbol is Char)
{
sym = new SimpleSymbol((char)symbol);
}
else if (symbol is StringPair)
{
StringPair sp = symbol as StringPair;
sym = new SubscriptedSymbol(sp.First, sp.Second);
}
sym.Append(form);
return(form);
}
IOperationAcceptor IOperationDetector.Detect(MathSymbol s)
{
if (!(s is SimpleSymbol))
{
return(null);
}
SimpleSymbol ss = s as SimpleSymbol;
if (ss.Italic | !ss.Bold)
{
return(null);
}
if (ss.Symbol == '\u0442')
{
return(this);
}
return(null);
}
private static ISymbolicExpressionGrammar CreateTestGrammar5()
{
var grammar = new SimpleSymbolicExpressionGrammar();
var x = new SimpleSymbol("<x>", 1);
var y = new SimpleSymbol("<y>", 1);
var _x = new SimpleSymbol("x", 0);
grammar.AddSymbol(x);
grammar.AddSymbol(y);
grammar.AddSymbol(_x);
grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
grammar.AddAllowedChildSymbol(x, x);
grammar.AddAllowedChildSymbol(x, y);
grammar.AddAllowedChildSymbol(y, x);
grammar.AddAllowedChildSymbol(y, y);
grammar.AddAllowedChildSymbol(y, _x);
return(grammar);
}
/// <summary>
/// Creates formula
/// </summary>
/// <param name="tree">Operation tree</param>
/// <param name="level">Formula level</param>
/// <param name="sizes">Sizes of symbols</param>
/// <returns>The formula</returns>
public MathFormula CreateFormula(ObjectFormulaTree tree, byte level, int[] sizes)
{
MathFormula form = new MathFormula(level, sizes);
MathFormula f = new MathFormula(level, sizes);
MathSymbol sym = null;
if (symbol == '-')
{
sym = new BinarySymbol('-');
}
else
{
sym = new SimpleSymbol(symbol, false, (byte)FormulaConstants.Unary);
}
sym.Append(form);
sym = new BracketsSymbol();
sym.Append(form);
form.Last.Children[0] = FormulaCreator.CreateFormula(tree[0], level, sizes);
form.Last.Children[1] = new MathFormula((byte)(level + 1), sizes);
return(form);
}
private static ISymbolicExpressionGrammar CreateTestGrammar6()
{
var grammar = new SimpleSymbolicExpressionGrammar();
var x = new SimpleSymbol("<x>", 1);
var s = new SimpleSymbol("<s>", 1);
var a = new SimpleSymbol("<a>", 1);
var b = new SimpleSymbol("<b>", 1);
var c = new SimpleSymbol("<c>", 1);
var d = new SimpleSymbol("<d>", 1);
var e = new SimpleSymbol("<e>", 1);
var _x = new SimpleSymbol("x", 0);
var _y = new SimpleSymbol("y", 0);
grammar.AddSymbol(x);
grammar.AddSymbol(s);
grammar.AddSymbol(a);
grammar.AddSymbol(b);
grammar.AddSymbol(c);
grammar.AddSymbol(d);
grammar.AddSymbol(e);
grammar.AddSymbol(_x);
grammar.AddSymbol(_y);
grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
grammar.AddAllowedChildSymbol(x, s);
grammar.AddAllowedChildSymbol(x, _x);
grammar.AddAllowedChildSymbol(s, a);
grammar.AddAllowedChildSymbol(a, b);
grammar.AddAllowedChildSymbol(a, c);
grammar.AddAllowedChildSymbol(b, x);
grammar.AddAllowedChildSymbol(c, d);
grammar.AddAllowedChildSymbol(d, e);
grammar.AddAllowedChildSymbol(e, _y);
return(grammar);
}
private ISymbolicExpressionTree GenerateSimpleTree(ISymbolicExpressionTreeGrammar grammar)
{
var branch = new SimpleSymbol("branch", "", 2, 2);
var leaf = new SimpleSymbol("leaf", "", 0, 0);
var root = new SymbolicExpressionTreeTopLevelNode(branch);
root.SetGrammar(grammar);
var branch0 = new SymbolicExpressionTreeNode(branch);
var branch1 = new SymbolicExpressionTreeNode(branch);
var leaf0 = new SymbolicExpressionTreeNode(leaf);
var leaf1 = new SymbolicExpressionTreeNode(leaf);
var leaf2 = new SymbolicExpressionTreeNode(leaf);
var leaf3 = new SymbolicExpressionTreeNode(leaf);
root.AddSubtree(branch0);
root.AddSubtree(branch1);
branch0.AddSubtree(leaf0);
branch0.AddSubtree(leaf1);
branch1.AddSubtree(leaf2);
branch1.AddSubtree(leaf3);
return(new SymbolicExpressionTree(root));
}
IOperationAcceptor IVariableDetector.Detect(MathSymbol sym)
{
string key = sym.String;
if (key.Length > 1)
{
return(null);
}
if (!(sym is SimpleSymbol))
{
return(null);
}
SimpleSymbol ss = sym as SimpleSymbol;
if (!ss.Italic)
{
return(null);
}
if (acc.ContainsKey(key))
{
return(acc[key]);
}
return(VariableDetector.Detect(sym, acc));
}
// initialize set of allowed symbols and define
// the allowed combinations of symbols
private void Initialize()
{
#region Symbols
var block = new SimpleSymbol("Block", "A group of statements", 1, byte.MaxValue);
var stat = new SimpleSymbol("Statement", "A statement.", 1, 1);
var ifThenElseStat = new SimpleSymbol("IfThenElseStat", "An if statement.", 2, 3);
var whileStat = new SimpleSymbol("WhileStat", "A while statement.", 2, 2);
whileStat.Enabled = false;
var boolExpr = new SimpleSymbol("BooleanExpression", "A Boolean expression.", 1, 1);
var numericalExpr = new SimpleSymbol("NumericalExpression", "A numerical expression.", 1, 1);
var equal = new SimpleSymbol("Equal", "Equal comparator.", 2, 2);
var lessThan = new SimpleSymbol("LessThan", "LessThan comparator.", 2, 2);
var lessThanOrEqual = new SimpleSymbol("LessThanOrEqual", "LessThanOrEqual comparator.", 2, 2);
var greaterThan = new SimpleSymbol("GreaterThan", "GreaterThan comparator.", 2, 2);
var greaterThanOrEqual = new SimpleSymbol("GreaterThanOrEqual", "GreaterThanOrEqual comparator.", 2, 2);
var conjunction = new SimpleSymbol("ConditionalAnd", "Conjunction comparator.", 2, byte.MaxValue);
var disjunction = new SimpleSymbol("ConditionalOr", "Disjunction comparator.", 2, byte.MaxValue);
var negation = new SimpleSymbol("Negation", "A negation.", 1, 1);
var addition = new SimpleSymbol("Addition", "Addition operator.", 2, byte.MaxValue);
var subtraction = new SimpleSymbol("Subtraction", "Subtraction operator.", 2, byte.MaxValue);
var multiplication = new SimpleSymbol("Multiplication", "Multiplication operator.", 2, byte.MaxValue);
var division = new SimpleSymbol("Division", "Division operator.", 2, byte.MaxValue);
var modulus = new SimpleSymbol("Modulus", "Modulus operator.", 2, byte.MaxValue);
var number = new Number();
var logicalVal = new BooleanValue();
var ahead = new SimpleSymbol("Ahead", "Immediately moves your robot ahead (forward) by distance measured in pixels.", 1, 1);
var back = new SimpleSymbol("Back", "Immediately moves your robot backward by distance measured in pixels.", 1, 1);
var fire = new SimpleSymbol("Fire", "Immediately fires a bullet.", 1, 1);
var shotPower = new ShotPower();
var getEnergy = new SimpleSymbol("GetEnergy", "Returns the robot's current energy.", 0, 0);
var getHeading = new SimpleSymbol("GetHeading", "Returns the direction that the robot's body is facing, in degrees.", 0, 0);
var getGunHeading = new SimpleSymbol("GetGunHeading", "Returns the direction that the robot's gun is facing, in degrees.", 0, 0);
var getRadarHeading = new SimpleSymbol("GetRadarHeading", "Returns the direction that the robot's radar is facing, in degrees.", 0, 0);
var getX = new SimpleSymbol("GetX", "Returns the X position of the robot. (0,0) is at the bottom left of the battlefield.", 0, 0);
var getY = new SimpleSymbol("GetY", "Returns the Y position of the robot. (0,0) is at the bottom left of the battlefield.", 0, 0);
var turnLeft = new SimpleSymbol("TurnLeft", "Immediately turns the robot's body to the left by degrees.", 1, 1);
var turnRight = new SimpleSymbol("TurnRight", "Immediately turns the robot's body to the right by degrees.", 1, 1);
var turnGunLeft = new SimpleSymbol("TurnGunLeft", "Immediately turns the robot's gun to the left by degrees.", 1, 1);
var turnGunRight = new SimpleSymbol("TurnGunRight", "Immediately turns the robot's gun to the right by degrees.", 1, 1);
var turnRadarLeft = new SimpleSymbol("TurnRadarLeft", "Immediately turns the robot's radar to the left by degrees.", 1, 1);
var turnRadarRight = new SimpleSymbol("TurnRadarRight", "Immediately turns the robot's radar to the right by degrees.", 1, 1);
var onBulletHit = new SimpleSymbol("OnBulletHit", "This method is called when one of your bullets hits another robot.", 2, 10);
var onBulletMissed = new SimpleSymbol("OnBulletMissed", "This method is called when one of your bullets misses, i.e. hits a wall.", 2, 10);
var onHitByBullet = new SimpleSymbol("OnHitByBullet", "This method is called when your robot is hit by a bullet.", 2, 10);
var onHitRobot = new SimpleSymbol("OnHitRobot", "This method is called when your robot collides with another robot.", 2, 10);
var onHitWall = new SimpleSymbol("OnHitWall", "This method is called when your robot collides with a wall.", 2, 10);
var onScannedRobot = new SimpleSymbol("OnScannedRobot", "This method is called when your robot sees another robot, i.e. when the robot's radar scan \"hits\" another robot.", 2, 10);
var run = new SimpleSymbol("Run", "The main method in every robot.", 1, 10);
var tank = new SimpleSymbol("Tank", "The root of a Robocode Tank program.", 2, 7);
var doNothing = new SimpleSymbol("DoNothing", "Do nothing this turn, meaning that the robot will skip its turn.", 0, 0);
var emptyEvent = new SimpleSymbol("EmptyEvent", "This is a placeholder for an empty event.", 0, 0);
#endregion
#region Symbol Collections
var controlSymbols = new ISymbol[] { ifThenElseStat, whileStat };
var actionSymbols = new ISymbol[] {
ahead, back, fire, turnGunLeft, turnGunRight, turnLeft, turnRadarLeft, turnRadarRight, turnRight
};
var functionSymbols = new ISymbol[] {
getEnergy, getGunHeading, getHeading, getRadarHeading, getX, getY
};
var events = new GroupSymbol(EventsName, new ISymbol[] { run, onScannedRobot, onBulletHit, onBulletMissed, onHitByBullet, onHitRobot, onHitWall });
var controlStatements = new GroupSymbol(ControlStatementsName, controlSymbols);
var expressions = new GroupSymbol(ExpressionsName, new ISymbol[] { boolExpr, numericalExpr });
var robocodeFunctions = new GroupSymbol(RobocodeFunctionsName, functionSymbols);
var robocodeActions = new GroupSymbol(RobocodeActionsName, actionSymbols);
var relationalOperators = new GroupSymbol(RelationalOperatorsName, new ISymbol[] { equal, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual });
var logicalOperators = new GroupSymbol(LogicalOperators, new ISymbol[] { conjunction, disjunction, negation });
var numericalOperators = new GroupSymbol(NumericalOperatorsName, new ISymbol[] { addition, subtraction, multiplication, division, modulus });
#endregion
#region Adding Symbols
AddSymbol(tank);
AddSymbol(stat);
AddSymbol(block);
AddSymbol(shotPower);
AddSymbol(number);
AddSymbol(logicalVal);
AddSymbol(events);
AddSymbol(expressions);
AddSymbol(controlStatements);
AddSymbol(robocodeFunctions);
AddSymbol(robocodeActions);
AddSymbol(relationalOperators);
AddSymbol(logicalOperators);
AddSymbol(numericalOperators);
AddSymbol(emptyEvent);
AddSymbol(doNothing);
#endregion
#region Grammar Definition
// StartSymbol
AddAllowedChildSymbol(StartSymbol, tank);
// Tank
AddAllowedChildSymbol(tank, run, 0);
AddAllowedChildSymbol(tank, onScannedRobot, 1);
AddAllowedChildSymbol(tank, onBulletHit, 2);
AddAllowedChildSymbol(tank, onBulletMissed, 3);
AddAllowedChildSymbol(tank, onHitByBullet, 4);
AddAllowedChildSymbol(tank, onHitRobot, 5);
AddAllowedChildSymbol(tank, onHitWall, 6);
// Events
AddAllowedChildSymbol(events, stat);
// Block
AddAllowedChildSymbol(block, stat);
// Stat
AddAllowedChildSymbol(stat, stat);
AddAllowedChildSymbol(stat, block);
AddAllowedChildSymbol(stat, controlStatements);
AddAllowedChildSymbol(stat, robocodeFunctions);
AddAllowedChildSymbol(stat, robocodeActions);
AddAllowedChildSymbol(stat, emptyEvent);
AddAllowedChildSymbol(stat, doNothing);
// IfStat
AddAllowedChildSymbol(ifThenElseStat, boolExpr, 0);
AddAllowedChildSymbol(ifThenElseStat, stat, 1);
AddAllowedChildSymbol(ifThenElseStat, emptyEvent, 1);
AddAllowedChildSymbol(ifThenElseStat, doNothing, 1);
AddAllowedChildSymbol(ifThenElseStat, stat, 2);
AddAllowedChildSymbol(ifThenElseStat, emptyEvent, 2);
AddAllowedChildSymbol(ifThenElseStat, doNothing, 2);
// WhileStat
AddAllowedChildSymbol(whileStat, boolExpr, 0);
AddAllowedChildSymbol(whileStat, stat, 1);
AddAllowedChildSymbol(whileStat, emptyEvent, 1);
AddAllowedChildSymbol(whileStat, doNothing, 1);
// Numerical Expressions
AddAllowedChildSymbol(numericalExpr, number);
AddAllowedChildSymbol(numericalExpr, robocodeFunctions);
AddAllowedChildSymbol(numericalExpr, numericalOperators);
AddAllowedChildSymbol(numericalOperators, number);
AddAllowedChildSymbol(numericalOperators, robocodeFunctions);
AddAllowedChildSymbol(numericalOperators, numericalOperators);
// Logical Expressions
AddAllowedChildSymbol(boolExpr, logicalVal);
AddAllowedChildSymbol(boolExpr, logicalOperators);
AddAllowedChildSymbol(logicalOperators, logicalVal);
AddAllowedChildSymbol(logicalOperators, logicalOperators);
AddAllowedChildSymbol(logicalOperators, relationalOperators);
AddAllowedChildSymbol(relationalOperators, numericalExpr);
// Functions and Actions
AddAllowedChildSymbol(robocodeFunctions, numericalExpr);
foreach (var a in robocodeActions.Symbols)
{
if (a.Name == fire.Name)
{
AddAllowedChildSymbol(a, shotPower);
}
else
{
AddAllowedChildSymbol(a, numericalExpr);
}
}
#endregion
}
/// <summary>
/// Converts math formula
/// </summary>
/// <param name="formula">Initial formula</param>
/// <returns>Conversion result</returns>
public MathFormula Convert(MathFormula formula)
{
MathFormula form = formula.Copy();
for (int i = 0; i < form.Count; i++)
{
List <MathFormula> ch = form[i].Children;
if (ch == null)
{
break;
}
List <MathFormula> nch = new List <MathFormula>();
foreach (MathFormula ff in ch)
{
MathFormula fch = Convert(ff);
if (fch == null)
{
break;
}
nch.Add(fch);
}
if (nch.Count > 0)
{
form[i].Children = nch;
}
}
MathFormula f = new MathFormula(0x0, form.Sizes);
SimpleSymbol sym = null;
MathSymbol symbol = form.First;
if (symbol == null)
{
return(null);
}
MathSymbol next;
while (true)
{
next = symbol.Next;
if (symbol is SimpleSymbol & !(symbol is FieldSymbol) & !(symbol is BinarySymbol)
& !(symbol is FractionSymbol) & !(symbol is BracketsSymbol) & !(symbol is RootSymbol) &
!(symbol is SeriesSymbol) & !(symbol is SubscriptedSymbol) & !(symbol is IndexedSymbol)
& !(symbol is PoweredIndexedSymbol))
{
SimpleSymbol ss = symbol as SimpleSymbol;
if ((ss.Bold == bold) & (ss.Italic == italic) & (ss.SymbolType == type)
& (ss.String.Length <= 1))
{
if (sym == null)
{
sym = ss.Clone() as SimpleSymbol;
}
else
{
string str = sym.String + ss.String;
sym = new SimpleSymbol(sym.Symbol, type, italic, bold, str);
}
}
else
{
if (sym != null)
{
sym.AppendWithChildren(f);
sym = null;
}
symbol.AppendWithChildren(f);
}
}
else
{
if (sym != null)
{
sym.AppendWithChildren(f);
sym = null;
}
symbol.AppendWithChildren(f);
}
symbol = next;
if (symbol == null)
{
if (sym != null)
{
sym.AppendWithChildren(f);
}
break;
}
}
return(f);
}
/// <summary>
/// Detects operation
/// </summary>
/// <param name="s">First symbol of the formula</param>
/// <returns>Acceptor of operation</returns>
public virtual IOperationAcceptor Detect(MathSymbol s)
{
if (s.Symbol == '~')
{
return(new BitwiseOperation());
}
if (s.Symbol == '¬')
{
return(NegationOperation.Object);
}
if (s.Symbol == '-')
{
return(Minus);
}
if (s is SeriesSymbol)
{
SeriesSymbol ss = s as SeriesSymbol;
if (ss.Acceptor is IUnary)
{
return(new ElementaryUnaryOperation(ss.Acceptor as IUnary, ss.Index));
}
return(ss.Acceptor);
}
if (s is BinaryFunctionSymbol)
{
return(ElementaryAtan2.Object);
}
if (s is RootSymbol)
{
return(new ElementaryRoot());
}
if (s is FractionSymbol)
{
return(ElementaryFraction.Object);
}
if (s is BracketsSymbol)
{
return(Brakets);
}
if (s is AbsSymbol)
{
return(new ElementaryAbs());
}
if (s.SymbolType == (byte)FormulaConstants.Variable)
{
if (s.Symbol == '%')
{
return(new TranscredentRealConstant('p'));
}
if (s.Symbol == 'e')
{
return(new TranscredentRealConstant('e'));
}
return(new ElementaryObjectVariable(s.Symbol));
}
if (s.SymbolType == (byte)FormulaConstants.Number)
{
return(new ElementaryRealConstant(s.DoubleValue));
}
if (s.SymbolType == (byte)FormulaConstants.Unary & s.Symbol != '\u2211' & !(s.Symbol + "").Equals("'"))
{
string str = s.Symbol + "";
if (str.Equals(str.ToLower()))
{
return(new ElementaryFunctionOperation(s.Symbol));
}
return(new ElementaryIntegerOperation(s.Symbol));
}
if (s is SimpleSymbol)
{
SimpleSymbol ss = s as SimpleSymbol;
if (!ss.Bold & !ss.Italic)
{
return(new StringOperationAcceptor(ss.String));
}
}
return(null);
}
private void CmbSymbolTypeSelectedIndexChanged(object sender, EventArgs e)
{
if (cmbSymbolType.SelectedItem.ToString() == "Simple")
{
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabSimple);
tabSymbolProperties.SelectedTab = tabSimple;
}
}
if (cmbSymbolType.SelectedItem.ToString() == "Character")
{
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabCharacter);
tabSymbolProperties.SelectedTab = tabCharacter;
}
}
if (cmbSymbolType.SelectedItem.ToString() == "Picture")
{
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabPicture) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabPicture);
tabSymbolProperties.SelectedTab = tabPicture;
}
}
if (_ignoreChanges)
{
return;
}
int index = ccSymbols.Symbols.IndexOf(ccSymbols.SelectedSymbol);
if (index == -1)
{
return;
}
ISymbol oldSymbol = ccSymbols.SelectedSymbol;
if (cmbSymbolType.SelectedItem.ToString() == "Simple")
{
SimpleSymbol ss = new SimpleSymbol();
if (oldSymbol != null)
{
ss.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = ss;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ss;
}
if (cmbSymbolType.SelectedItem.ToString() == "Character")
{
CharacterSymbol cs = new CharacterSymbol();
if (oldSymbol != null)
{
cs.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = cs;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = cs;
}
if (cmbSymbolType.SelectedItem.ToString() == "Picture")
{
PictureSymbol ps = new PictureSymbol();
if (oldSymbol != null)
{
ps.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = ps;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ps;
}
}
private void cmbSymbolType_SelectedIndexChanged(object sender, EventArgs e)
{
if (cmbSymbolType.SelectedItem.ToString() == "Simple")
{
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabSimple);
tabSymbolProperties.SelectedTab = tabSimple;
}
}
if (cmbSymbolType.SelectedItem.ToString() == "Character")
{
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabCharacter);
tabSymbolProperties.SelectedTab = tabCharacter;
}
}
if (cmbSymbolType.SelectedItem.ToString() == "Picture")
{
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabPicture) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabPicture);
tabSymbolProperties.SelectedTab = tabPicture;
}
}
if (_ignoreChanges) return;
int index = ccSymbols.Symbols.IndexOf(ccSymbols.SelectedSymbol);
if (index == -1) return;
ISymbol oldSymbol = ccSymbols.SelectedSymbol;
if (cmbSymbolType.SelectedItem.ToString() == "Simple")
{
SimpleSymbol ss = new SimpleSymbol();
if (oldSymbol != null) ss.CopyPlacement(oldSymbol);
ccSymbols.Symbols[index] = ss;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ss;
}
if (cmbSymbolType.SelectedItem.ToString() == "Character")
{
CharacterSymbol cs = new CharacterSymbol();
if (oldSymbol != null) cs.CopyPlacement(oldSymbol);
ccSymbols.Symbols[index] = cs;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = cs;
}
if (cmbSymbolType.SelectedItem.ToString() == "Picture")
{
PictureSymbol ps = new PictureSymbol();
if (oldSymbol != null) ps.CopyPlacement(oldSymbol);
ccSymbols.Symbols[index] = ps;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ps;
}
}
private void ccSymbols_AddClicked(object sender, EventArgs e)
{
ISymbol s = null;
string type = cmbSymbolType.SelectedItem.ToString();
switch (type)
{
case "Simple": s = new SimpleSymbol(); break;
case "Character": s = new CharacterSymbol(); break;
case "Picture": s = new PictureSymbol(); break;
}
if (s != null) ccSymbols.Symbols.Add(s);
ccSymbols.RefreshList();
UpdatePreview();
}
private void CmbSymbolTypeSelectedIndexChanged(object sender, EventArgs e)
{
SymbolType newSymbolType = Global.ParseEnum <SymbolType>(cmbSymbolType.SelectedIndex);
ISymbol oldSymbol = ccSymbols.SelectedSymbol;
switch (newSymbolType)
{
case SymbolType.Simple:
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabSimple);
tabSymbolProperties.SelectedTab = tabSimple;
}
break;
case SymbolType.Character:
if (tabSymbolProperties.TabPages.Contains(tabPicture))
{
tabSymbolProperties.TabPages.Remove(tabPicture);
}
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabCharacter);
tabSymbolProperties.SelectedTab = tabCharacter;
}
break;
case SymbolType.Picture:
if (tabSymbolProperties.TabPages.Contains(tabSimple))
{
tabSymbolProperties.TabPages.Remove(tabSimple);
}
if (tabSymbolProperties.TabPages.Contains(tabCharacter))
{
tabSymbolProperties.TabPages.Remove(tabCharacter);
}
if (tabSymbolProperties.TabPages.Contains(tabPicture) == false)
{
tabSymbolProperties.TabPages.Insert(0, tabPicture);
tabSymbolProperties.SelectedTab = tabPicture;
}
break;
case SymbolType.Custom:
MessageBox.Show("暂未实现");
if (oldSymbol != null)
{
SymbolType oldSymbolType = oldSymbol.SymbolType;
cmbSymbolType.SelectedIndex = Global.GetEnumIndex(oldSymbolType);
}
return;
}
if (_ignoreChanges)
{
return;
}
int index = ccSymbols.Symbols.IndexOf(ccSymbols.SelectedSymbol);
if (index == -1)
{
return;
}
ISymbol newSymbol = null;
switch (newSymbolType)
{
case SymbolType.Simple:
SimpleSymbol ss = new SimpleSymbol();
if (oldSymbol != null)
{
ss.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = ss;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ss;
newSymbol = ss;
break;
case SymbolType.Character:
CharacterSymbol cs = new CharacterSymbol();
if (!string.IsNullOrWhiteSpace(Properties.Settings.Default.DetailedPointSymbolControlFontFamilyName))
{
cs.FontFamilyName = Properties.Settings.Default.DetailedPointSymbolControlFontFamilyName;
}
if (oldSymbol != null)
{
cs.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = cs;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = cs;
newSymbol = cs;
break;
case SymbolType.Picture:
PictureSymbol ps = new PictureSymbol();
if (oldSymbol != null)
{
ps.CopyPlacement(oldSymbol);
}
ccSymbols.Symbols[index] = ps;
ccSymbols.RefreshList();
ccSymbols.SelectedSymbol = ps;
newSymbol = ps;
break;
case SymbolType.Custom:
break;
}
//if (newSymbol != null)
//{
// newSymbol.SetColor(oldSymbol.GetColor());
//}
}
/// <summary>
/// Creates symbol from string vector and sets it to formula
/// </summary>
/// <param name="f">the formula to set</param>
/// <param name="v">the string vector</param>
/// <param name="b">the begin position of symbol on string vector</param>
/// <param name="e">the end position of symbol on string vector</param>
/// <returns>The symbol</returns>
public static MathSymbol CreateSymbol(MathFormula f, List <byte[]> v, int b, int e)
{
char c = (char)GetByte(v, b);
byte by = GetByte(v, b + 1);
char cb = (char)by;
MathSymbol s = null;
switch (by)
{
case (byte)'1':
if (c == '%')
{
s = new SimpleSymbol('%', (byte)FormulaConstants.Variable, true, "\u03c0");
break;
}
s = new SimpleSymbol(c);
break;
case (byte)'2':
if (c == 'P')
{
s = new BracketsSymbol();
}
else if (c == 'F')
{
s = new FractionSymbol();
}
else if (c == 'A')
{
s = new BinaryFunctionSymbol('A', "atan2");
}
else if (c == 'M')
{
return(new AbsSymbol());
}
else
{
s = new RootSymbol();
}
break;
case (byte)'3':
string ss = "";
ss += c;
if (c == (byte)'*')
{
ss = "\u2219";
}
s = new BinarySymbol(c, false, ss);
break;
case (byte)'4':
s = new SimpleSymbol(c, false, (byte)FormulaConstants.Unary);
break;
case (byte)'5':
s = new SimpleSymbol(c, false, (byte)FormulaConstants.Number);
break;
case (byte)'7':
s = new SeriesSymbol(Int32.Parse(c + ""));
break;
}
s.Append(f);
MathSymbol symb = f.Last;
int j = b + SHIFT;
if (symb.Count > 0)
{
for (int i = 0; i < symb.Count; i++)
{
int m = 0;
for (int k = j; /*k <= e*/; k++)
{
byte bt = GetByte(v, k);
if (bt == BEGIN_SEPARATOR)
{
m++;
}
else if (bt == END_SEPARATOR)
{
m--;
}
if (m == 0)
{
if (symb[i] != null)
{
MathFormula formula = new MathFormula(symb[i].Level,
f.Sizes, v, j + 1, k - 1);
symb[i] = formula;
j = k + 1;
break;
}
}
}
}
}
return(symb);
}
private void Initialize()
{
#region Symbols
//var ifThenElseStat = new SimpleSymbol("IfThenElseStat", "An if statement.", 2, 3);
//var boolExpr = new SimpleSymbol("BooleanExpression", "A Boolean expression.", 1, 1);
var numericalExpr = new SimpleSymbol("NumericalExpression", "A numerical expression.", 1, 1);
//var equal = new SimpleSymbol("Equal", "Equal comparator.", 2, 2);
//var lessThan = new SimpleSymbol("LessThan", "LessThan comparator.", 2, 2);
//var lessThanOrEqual = new SimpleSymbol("LessThanOrEqual", "LessThanOrEqual comparator.", 2, 2);
//var greaterThan = new SimpleSymbol("GreaterThan", "GreaterThan comparator.", 2, 2);
//var greaterThanOrEqual = new SimpleSymbol("GreaterThanOrEqual", "GreaterThanOrEqual comparator.", 2, 2);
//var conjunction = new SimpleSymbol("ConditionalAnd", "Conjunction comparator.", 2, byte.MaxValue);
//var disjunction = new SimpleSymbol("ConditionalOr", "Disjunction comparator.", 2, byte.MaxValue);
var multiplication = new SimpleSymbol("Multiplication", "Multiplication operator.", 2, 2);
var number = new Number();
//var logicalVal = new BooleanValue();
var feature = new Feature();
#endregion
#region Symbol Collections
//var numericalOperators = new GroupSymbol(NumericalOperatorsName, new ISymbol[] { multiplication });
var numericalStatements = new GroupSymbol(StatementsName, new ISymbol[] { /*ifThenElseStat,*/ number, multiplication, feature });
//var controlStatements = new GroupSymbol(ControlStatementsName, new ISymbol[] { ifThenElseStat });
var expressions = new GroupSymbol(ExpressionsName, new ISymbol[] { /*boolExpr,*/ numericalExpr });
//var relationalOperators = new GroupSymbol(RelationalOperatorsName, new ISymbol[] { equal, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual });
//var logicalOperators = new GroupSymbol(LogicalOperators, new ISymbol[] { conjunction, disjunction });
var leaves = new GroupSymbol("leaves", new ISymbol[] { feature, number });
#endregion
#region Adding Symbols
AddSymbol(feature);
AddSymbol(number);
//AddSymbol(logicalVal);
AddSymbol(expressions);
//AddSymbol(controlStatements);
//AddSymbol(relationalOperators);
//AddSymbol(logicalOperators);
AddSymbol(multiplication);
#endregion
#region Grammar Definition
// StartSymbol
AddAllowedChildSymbol(StartSymbol, numericalExpr);
// IfStat
//AddAllowedChildSymbol(ifThenElseStat, boolExpr, 0);
//AddAllowedChildSymbol(ifThenElseStat, numericalExpr, 1);
//AddAllowedChildSymbol(ifThenElseStat, numericalExpr, 2);
// Numerical Expressions
//AddAllowedChildSymbol(numericalExpr, number);
//AddAllowedChildSymbol(numericalExpr, feature);
AddAllowedChildSymbol(numericalExpr, multiplication);
//AddAllowedChildSymbol(numericalExpr, ifThenElseStat);
AddAllowedChildSymbol(multiplication, feature);
AddAllowedChildSymbol(multiplication, number);
// Logical Expressions
//AddAllowedChildSymbol(boolExpr, logicalVal);
//AddAllowedChildSymbol(boolExpr, logicalOperators);
//AddAllowedChildSymbol(logicalOperators, logicalOperators);
//AddAllowedChildSymbol(logicalOperators, relationalOperators);
//AddAllowedChildSymbol(relationalOperators, feature, 0);
//AddAllowedChildSymbol(relationalOperators, leaves, 1);
#endregion
}
