//删除
private void btnDel_Click(object sender, EventArgs e)
{
int idx = dataGridView1.CurrentRow.Index;
if (idx < 0)
{
return;
}
string code = this.dataGridView1["code", idx].Value.ToString();
if (code == currOprt.Code)
{
MessageBox.Show("该用户正在使用中！");
return;
}
if (code == "admin")
{
MessageBox.Show("超级管理员不允许被删除！");
return;
}
COperator oprt = oprts.Find(o => o.Code == code);
if (oprt != null)
{
int rit = Program.mng.DeleteOprt(code);
if (rit == 100)
{
oprts.Remove(oprt);
updateDataGridView();
}
}
}
COperator CreateOperator()
{
string name = _lexer.Token;
COperator op = OpCodes.OperatorFromName(name);
return(CreateOperator(op));
}
public Cycle(string code)
{
int end = code.BlockBeetweenEnd('(', ')') + 1;
_operator = new COperator(OperatorType.Cycle,code.Substring(0, end));
code = code.Substring(end).BlockBeetween('{','}');
_operator.PDown = CPPFileAnalyzer.AnalyzeBlock(code);
}
void OnTriggerEnter2D(Collider2D collider)
{
if (collider.tag == SenderTagName)
{
GameObject temp = GameObject.Find(collider.gameObject.name);
float temp_Damage = temp.GetComponent <TriggerDamageSender2D>().DamageValue;
bool temp_destroy = temp.GetComponent <TriggerDamageSender2D>().DestroyAfterCollision;
COperator temp_operator = (COperator)temp.GetComponent <TriggerDamageSender2D>().DamageOperator;
DamageReceived = temp_Damage;
if (isEnabled)
{
if (temp_operator == COperator.AddValue)
{
FloatVariable.AddToCurrentValue(DamageReceived);
DamageReceived = 0;
}
if (temp_operator == COperator.SetValue)
{
FloatVariable.SetCurrentValue(DamageReceived);
DamageReceived = 0;
}
if (temp_operator == COperator.SubValue)
{
FloatVariable.SubToCurrentValue(DamageReceived);
DamageReceived = 0;
}
if (temp_destroy)
{
Destroy(temp);
}
}
}
}
COperator CreateOperator(OpCodeName nameop)
{
string name = nameop.ToString();
COperator op = OpCodes.OperatorFromName(name);
return(CreateOperator(op));
}
private void _parseCases()
{
var t = oprtr.Beetween("{", "}");
var operators = t.Split(new string[] { "default:" }, StringSplitOptions.RemoveEmptyEntries);
if(operators.Length>1)
_operator.PDefault = CPPFileAnalyzer.AnalyzeBlock(operators[1]);
else
{
_operator.PDefault = new List<COperator>();
}
_operator.LeftText = operators[0];
_operator.PDown = new List<COperator>();
var cases = operators[0].Split(new string[] { "case "}, StringSplitOptions.RemoveEmptyEntries);
foreach (var o in cases)
{
var parts = o.Split(':');
if(parts.Length<2) continue;
COperator c = new COperator(OperatorType.Case, parts[0])
{
PLeft = CPPFileAnalyzer.AnalyzeBlock(parts[1])
};
_operator.PDown.Add(c);
}
}
private void ExtractTextFromOperator(COperator obj, StringBuilder target)
{
if (obj.OpCode.OpCodeName == OpCodeName.Tf)
{
var fontName = obj.Operands.OfType <CName>().FirstOrDefault();
if (fontName != null)
{
//This is likely the wrong way to do this
CurrentFont = fontName.Name;
// Debug.WriteLine($"Selecting Font {fontName.Name}");
}
else
{
Debug.WriteLine("Can't parse font name");
}
}
if (obj.OpCode.OpCodeName == OpCodeName.Tj || obj.OpCode.OpCodeName == OpCodeName.TJ)
{
foreach (var element in obj.Operands)
{
ExtractText(element, target);
}
}
// if(obj.OpCode.OpCodeName == OpCodeName.ET){
// target.Append("\n");
// }
}
private void FrmOperator_Load(object sender, EventArgs e)
{
currOprt = Program.currOpr;
comboBox1.SelectedIndex = 0;
oprts = Program.mng.SelectAllOperators().ToList();
updateDataGridView();
}
private static void Write(COperator obj)
{
Console.Write("op:{0}(", obj.Name);
foreach (var op in obj.Operands)
{
Write(op);
Console.Write(", ");
}
Console.Write(")");
}
private static void ExtractText(COperator obj, StringBuilder target)
{
if (obj.OpCode.OpCodeName == OpCodeName.Tj || obj.OpCode.OpCodeName == OpCodeName.TJ)
{
foreach (var element in obj.Operands)
{
ExtractText(element, target);
}
target.Append(" ");
}
}
/// <summary>
/// Reads the passed operator, identifies the associated implementation object
/// and requests an operation object to be used in evaluating the equation.
/// </summary>
/// <param name="operatorToken">Token object representing the operator in question.</param>
/// <param name="value1">The first value object to be operated on.</param>
/// <param name="value2">The second value object to be operated on.</param>
/// <returns>CValue object representing an operation.</returns>
private CValue GetOperator(Token operatorToken, CValue value1, CValue value2)
{
if (_operators.ContainsKey(operatorToken.ToString()))
{
COperator op = _operators[operatorToken.ToString()];
return(op.SetParameters(value1, value2));
}
throw new InvalidEquationException("Invalid operator found in equation: " + operatorToken.ToString());
}
static void Main(String[] args)
{
//Lav to instanser af COperatorClass
COperator myObjy = new COperator(3);
COperator myObjz = new COperator(4);
COperator myObjx = myObjy + myObjz;
++myObjx;
Console.WriteLine("myObjx = {0}", myObjx.GetValue());//Output : myObjx = 8
}
public If(string oprtr)
{
this.oprtr = oprtr;
_operator = new COperator(OperatorType.If, GetCondition(oprtr));
_operator.LeftText = "Да";
_operator.RightText = "Нет";
oprtr = oprtr.Substring(oprtr.BlockBeetweenEnd('(', ')')+1);
oprtr = oprtr.Beetween("{","}");
_operator.PLeft = CPPFileAnalyzer.AnalyzeBlock(oprtr);
}
public CaseBlock(COperator ooperator)
{
Height = 2;
Width = 4;
_operator = ooperator;
Blocks = new List<Block>();
foreach (var o in _operator.PLeft)
{
Blocks.Add(new GraphicOperator(o){Text = o.Text, X = Width});
Width += Blocks.Last().Width + 2;
}
}
static void Main(String[] args)
{
//Lav to instanser af COperatorClass
COperator myObjy = new COperator(3);
COperator myObjz = new COperator(4);
COperator myObjx = myObjy + myObjz;
++myObjx;
Console.WriteLine("myObjx = {0}", myObjx.GetValue());//Output : myObjx = 8
}
private void btnUCon_Click(object sender, EventArgs e)
{
if (txtUCode.Text.Trim() == "" || txtUPwdCon.Text.Trim() == "")
{
MessageBox.Show("用户名或密码不允许为空！");
return;
}
if (comboBox1.SelectedIndex == -1)
{
MessageBox.Show("请选择用户权限！");
return;
}
COperator opt = oprts.Find(p => p.Code == txtUCode.Text.Trim());
if (opt != null)
{
MessageBox.Show("当前用户名已存在，请输入别的！");
txtUCode.Text = "";
return;
}
COperator oprt = new COperator();
oprt.Code = txtUCode.Text.Trim();
oprt.Password = txtUPwdCon.Text.Trim();
if (txtUName.Text.Trim() != "")
{
oprt.Name = txtUName.Text.Trim();
}
if (comboBox1.SelectedIndex == 0)
{
oprt.Type = EnmOperatorType.Operator;
}
else
{
oprt.Type = EnmOperatorType.Manager;
}
int rit = Program.mng.InsertOperator(oprt);
if (rit == 100)
{
oprts.Add(oprt);
MessageBox.Show("添加管理员完成！");
txtUCode.Clear();
txtUPwdCon.Clear();
updateDataGridView();
}
}
/// <summary>
/// Operators from name.
/// </summary>
/// <param name="name">The name.</param>
public static COperator OperatorFromName(string name)
{
COperator op = null;
OpCode opcode = StringToOpCode[name];
if (opcode != null)
{
op = new COperator(opcode);
}
else
{
Debug.Assert(false, "Unknown operator in PDF content stream.");
}
return(op);
}
public override Result Apply(Scope scope, Result argument)
{
int number = int.Parse(argument.Get().ToString());
Solvable expresion = new Variable("x");
for (int i = 0; i < number; i++)
{
expresion = new COperator(new Variable("f"), expresion);
}
expresion = new Abstraction("x", expresion);
expresion = new Abstraction("f", expresion);
return(expresion.Solve(scope));
}
/// <summary>
/// 添加操作员信息
/// </summary>
/// <param name="opr"></param>
/// <returns></returns>
public int InsertNewOperator(COperator opr)
{
try
{
COperator oprt = new COperator();
oprt.Code = opr.Code;
oprt.Name = opr.Name;
oprt.Password = opr.Password;
oprt.Type = opr.Type;
CWData.myDB.InsertOperator(oprt);
return(100);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Process an operator. If this is font selection (tf) set the current font used for text extraction, if it is a text showing operator (tj)
/// then recursively process the object
/// </summary>
/// <param name="obj"></param>
/// <param name="target"></param>
private void ExtractTextFromOperator(COperator obj, StringBuilder target)
{
if (obj.OpCode.OpCodeName == OpCodeName.Tf)
{
var fontName = obj.Operands.OfType <CName>().FirstOrDefault();
if (fontName != null)
{
//This is likely the wrong way to do this
CurrentFont = fontName.Name;
}
}
if (obj.OpCode.OpCodeName == OpCodeName.Tj || obj.OpCode.OpCodeName == OpCodeName.TJ)
{
foreach (var element in obj.Operands)
{
ExtractText(element, target);
}
}
}
bool CheckKey(string keyName, string pNum, COperator op)
{
float keyCheck;
if (USE_KEYBOARD)
{
if (pNum == "1" || KEYBOARD_ALL)
{
// if the keyboard is in use, shift controllers down
if (keyName == "XBoxPassTurn")
{
keyCheck = Input.GetAxisRaw("KeyPass");
}
else if (keyName == "XBoxAction")
{
keyCheck = Input.GetAxisRaw("KeyAction");
}
else if (keyName == "XBoxHoriz")
{
keyCheck = Input.GetAxisRaw("Horizontal");
}
else
{
Debug.LogError($"CheckKey recieved unknown key '{keyName}' with keyboard enabled!");
return(false);
}
}
else
{
int num = int.Parse(pNum) - 1;
keyCheck = Input.GetAxisRaw($"{keyName}{num}");
}
}
else // shows as unreachable if USE_KEYBOARD is true
{
keyCheck = Input.GetAxisRaw($"{keyName}{pNum}");
}
if (op(keyCheck, 0))
{
return(true);
}
return(false);
}
private float[] GetFloatArray(COperator op, int count)
{
var outp = new float[count];
if (op.Operands[0] is CArray arr && arr.Count != 1)
{
var least = Math.Min(arr.Count, count); // anything not supplied should be zero?
for (int i = 0; i < least; i++)
{
if (arr[i] is CReal real)
{
outp[i] = (float)real.Value;
}
else if (arr[i] is CInteger integer)
{
outp[i] = integer.Value;
}
}
}
COperator CreateOperator(COperator op)
{
if (op.OpCode.OpCodeName == OpCodeName.BI)
{
_lexer.ScanInlineImage();
}
#if DEBUG
if (op.OpCode.Operands != -1 && op.OpCode.Operands != _operands.Count)
{
if (op.OpCode.OpCodeName != OpCodeName.ID)
{
GetType();
Debug.Assert(false, "Invalid number of operands.");
}
}
#endif
op.Operands.Add(_operands);
_operands.Clear();
return(op);
}
public GraphicOperator(COperator c)
{
Width = 10;
Height = 2;
Blocks = new List<Block>();
switch (c.Type)
{
case OperatorType.Switch:
Blocks.Add(new ConditionalBlock(c));
break;
case OperatorType.Case:
Blocks.Add(new CaseBlock(c));
break;
case OperatorType.StartEnd:
Blocks.Add(new EntryBlock {Text = c.Text});
break;
case OperatorType.Output:
Blocks.Add(new OutputBlock() {Text = c.Text});
break;
case OperatorType.Input:
Blocks.Add(new InputBlock() {Text = c.Text});
break;
case OperatorType.Cycle:
Blocks.Add(new CycleBlock(c));
break;
case OperatorType.If:
Blocks.Add(new ConditionalBlock(c));
break;
case OperatorType.Action:
Blocks.Add(new ActionBlock() {Text = c.Text});
break;
default:
throw new ArgumentOutOfRangeException();
}
Width = Blocks.First().Width;
Height = Blocks.First().Height;
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (txtUser.Text.Trim() != "" && txtPassword.Text.Trim() != "")
{
COperator user = Program.mng.CheckPassword(txtUser.Text.Trim(), txtPassword.Text.Trim());
if (user != null)
{
Program.currOpr = user;
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
MessageBox.Show("用户名或密码输入有误，请重试！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
txtPassword.Text = "";
txtPassword.Focus();
}
}
else
{
MessageBox.Show("请输入正确的用户名及密码！");
}
}
COperator CreateOperator()
{
string name = lexer.Token;
COperator op = OpCodes.OperatorFromName(name);
if (op.OpCode.OpCodeName == OpCodeName.ID)
{
lexer.ScanInlineImage();
}
#if DEBUG
if (op.OpCode.Operands != -1 && op.OpCode.Operands != operands.Count)
{
if (op.OpCode.OpCodeName != OpCodeName.ID)
{
GetType();
Debug.Assert(false, "Invalid number of operands.");
}
}
#endif
op.Operands.Add(operands);
return(op);
}
void OnTriggerEnter(Collider collider)
{
bool isHit = false;
if (DamagerType == CDamageType.DamageSender) // check receiver
{
isHit = false;
for (int i = 0; i < DamageSender.DamageReceiverTag.Count; i++)
{
if (DamageSender.DamageReceiverTag[i] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
}
if (isHit)
{
if (DamageSender.usingFinishSound)
{
DamageSender.AudioSFX.clip = DamageSender.FinishSound;
DamageSender.AudioSFX.Play();
}
if (DamageSender.usingFinishSFX)
{
if (DamageSender.FinishSFX.SFXType == CSFXType.Instantiate)
{
GameObject temp = GameObject.Instantiate(DamageSender.FinishSFX.TargetSFX, CurrentDamageController.transform.position, CurrentDamageController.transform.rotation);
if (DamageSender.FinishSFX.usingDestroySettings)
{
Destroy(temp, DamageSender.FinishSFX.DestroyTime);
}
}
}
if (DamageSender.DestroyAfterCollision)
{
if (CurrentDamageController.gameObject.HasComponent <Renderer>())
{
CurrentDamageController.GetComponent <Renderer>().enabled = false;
Destroy(this.gameObject);
}
}
else
{
//Destroy(this.gameObject, 5);
}
}
}
if (DamagerType == CDamageType.DamageReceiver || DamagerType == CDamageType.AIDamageReceiver) // check sender
{
isHit = false;
//******************************************************************************* HEALTH RECEIVER
if (DamageReceiver.usingVarHealth)
{
for (int x = 0; x < DamageReceiver.HealthSenderTag.Count; x++)
{
if (DamageReceiver.HealthSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarHealthReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarHealthReceiver[x].AddToCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarHealthReceiver[x].SetCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarHealthReceiver[x].SubFromCurrentValue(TriggerReceived);
}
}
}
}
}
//******************************************************************************* MANA RECEIVER
if (DamageReceiver.usingVarMana)
{
for (int x = 0; x < DamageReceiver.ManaSenderTag.Count; x++)
{
if (DamageReceiver.ManaSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarManaReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarManaReceiver[x].AddToCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarManaReceiver[x].SetCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarManaReceiver[x].SubtractFromCurrentValue(TriggerReceived);
}
}
}
}
}
//******************************************************************************* EXP RECEIVER
if (DamageReceiver.usingVarExp)
{
for (int x = 0; x < DamageReceiver.ExpSenderTag.Count; x++)
{
if (DamageReceiver.ExpSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarExpReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarExpReceiver[x].AddToCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarExpReceiver[x].SetCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarExpReceiver[x].SubtractFromCurrentValue(TriggerReceived);
}
}
}
}
}
//******************************************************************************* TIME RECEIVER
if (DamageReceiver.usingVarTime)
{
for (int x = 0; x < DamageReceiver.TimeSenderTag.Count; x++)
{
if (DamageReceiver.TimeSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarTimeReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarTimeReceiver[x].AddToCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarTimeReceiver[x].SetCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarTimeReceiver[x].SubFromCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
}
}
}
}
//******************************************************************************* SCORE RECEIVER
if (DamageReceiver.usingVarScore)
{
for (int x = 0; x < DamageReceiver.ScoreSenderTag.Count; x++)
{
if (DamageReceiver.ScoreSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarScoreReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarScoreReceiver[x].AddToCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarScoreReceiver[x].SetCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarScoreReceiver[x].SubtractFromCurrentValue(TriggerReceived);
}
}
}
}
}
//******************************************************************************* INTEGER RECEIVER
if (DamageReceiver.usingVarInteger)
{
for (int x = 0; x < DamageReceiver.IntegerSenderTag.Count; x++)
{
if (DamageReceiver.IntegerSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarIntegerReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarIntegerReceiver[x].AddToCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarIntegerReceiver[x].SetCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarIntegerReceiver[x].SubtractFromCurrentValue(Mathf.RoundToInt(TriggerReceived));
}
}
}
}
}
//******************************************************************************* FLOAT RECEIVER
if (DamageReceiver.usingVarFloat)
{
for (int x = 0; x < DamageReceiver.FloatSenderTag.Count; x++)
{
if (DamageReceiver.FloatSenderTag[x] == collider.gameObject.tag)
{
isHit = true;
if (collider.gameObject.HasComponent <DamageController>())
{
TriggerReceived = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderDamageValue;
TriggerOperator = collider.gameObject.GetComponent <DamageController>().DamageSender.SenderOperator;
TriggerTag = collider.gameObject.tag;
}
}
if (isHit)
{
for (int j = 0; j < DamageReceiver.VarFloatReceiver.Count; j++)
{
if (TriggerOperator == COperator.AddValue)
{
DamageReceiver.VarFloatReceiver[x].AddToCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SetValue)
{
DamageReceiver.VarFloatReceiver[x].SetCurrentValue(TriggerReceived);
}
if (TriggerOperator == COperator.SubValue)
{
DamageReceiver.VarFloatReceiver[x].SubFromCurrentValue(TriggerReceived);
}
}
}
}
}
if (DamageReceiver.usingEventSettings)
{
DamageReceiver.EventSettings.Invoke();
}
ExecuteActionAnimation();
}
}
private void ExtractText(COperator obj, StringBuilder target)
{
if (obj.OpCode.OpCodeName == OpCodeName.QuoteSingle || obj.OpCode.OpCodeName == OpCodeName.QuoteDbl || obj.OpCode.OpCodeName == OpCodeName.Tj || obj.OpCode.OpCodeName == OpCodeName.TJ)
{
if (obj.OpCode.OpCodeName == OpCodeName.QuoteSingle || obj.OpCode.OpCodeName == OpCodeName.QuoteDbl)
{
target.Append("\n");
}
if (obj.Operands.Count == 1)
{
if (obj.Operands[0] is CArray)
{
foreach (var elem in ((CArray)(obj.Operands[0])))
{
if (elem is CString)
{
ExtractText(elem as CString, target);
}
else
{
if ((elem is CNumber) && (obj.OpCode.OpCodeName == OpCodeName.Tj))
{
if (GetNumberValue((CNumber)elem) > 750)
{
target.Append(" ");
}
}
}
}
}
else
{
ExtractText(obj.Operands[0], target);
}
}
else
{
Console.WriteLine("Error TJ!");
}
}
else
if ((obj.OpCode.OpCodeName == OpCodeName.Tx) || (obj.OpCode.OpCodeName == OpCodeName.TD) || (obj.OpCode.OpCodeName == OpCodeName.Td))
{
target.Append("\n");
}
else
if (obj.OpCode.OpCodeName == OpCodeName.Tm)
{
// TODO: check if position shifts enough (sometimes Tm is used in word parts)
target.Append(" ");
}
else
if (obj.OpCode.OpCodeName == OpCodeName.Tf)
{
if (obj.Operands.Count == 2)
{
//if (obj.Operands[0] is CString)
{
string nF = obj.Operands[0].ToString();
curr_font = fonts[nF];
//font = page.Resources.Elements["/Font"];
}
}
else
{
Console.WriteLine("Error in Tf operator");
}
}
}
public void AddText(COperator element)
{
Text = element.Operands[0].ToString();
Text = Text.Substring(1, Text.Length - 2).Replace("\\", "");
}
public void AddPos(COperator element)
{
X = Double.Parse(element.Operands[0].ToString());
Y = Double.Parse(element.Operands[1].ToString());
}
public ConditionalBlock(COperator o)
{
_operator = o;
_findRelativePositions();
}
/// <summary>
/// Parses whatever comes until the specified stop symbol is reached.
/// </summary>
void ParseObject(CSequence sequence, CSymbol stop)
{
CSymbol symbol;
while ((symbol = ScanNextToken()) != CSymbol.Eof)
{
if (symbol == stop)
{
return;
}
switch (symbol)
{
case CSymbol.Comment:
// ignore comments
break;
case CSymbol.Integer:
CInteger n = new CInteger();
n.Value = lexer.TokenToInteger;
operands.Add(n);
break;
case CSymbol.Real:
CReal r = new CReal();
r.Value = lexer.TokenToReal;
operands.Add(r);
break;
case CSymbol.String:
case CSymbol.HexString:
case CSymbol.UnicodeString:
case CSymbol.UnicodeHexString:
CString s = new CString();
s.Value = lexer.Token;
operands.Add(s);
break;
case CSymbol.Name:
CName name = new CName();
name.Name = lexer.Token;
operands.Add(name);
break;
case CSymbol.Operator:
COperator op = CreateOperator();
operands.Clear();
sequence.Add(op);
break;
case CSymbol.BeginArray:
CArray array = new CArray();
Debug.Assert(operands.Count == 0, "Array within array...");
ParseObject(array, CSymbol.EndArray);
array.Add(operands);
operands.Clear();
operands.Add((CObject)array);
break;
case CSymbol.EndArray:
throw new ContentReaderException("Unexpected: ']'");
}
}
}
public CycleBlock(COperator c)
{
_operator = c;
_draw();
}
