public void VisualInstruction_KeyDown(object sender, KeyEventArgs e)
{
VisualInstructionUserControl visualInstruction = (VisualInstructionUserControl)sender;
switch (visualInstruction.OpCode)
{
case OperationCode.None:
/// Tive que colocar aqui esta opcao de NENHUM para evitar que
/// a execucao passasse duas vezes em apagar
break;
case OperationCode.LineBegin:
break;
default:
if (e.KeyCode == Keys.Delete)
{
if (visualInstruction != null && SelectedVisualLine != null)
{
if (!visualInstruction.IsDisposed)
{
SuspendLayout();
SelectNextControl(visualInstruction, false, true, false, false);
SelectedVisualLine.RemoveVisualInstruction(visualInstruction);
ReorganizeLines();
ResumeLayout();
SelectedVisualLine.BackgroundLine.Invalidate();
}
}
}
break;
}
}
private void InsertInstruction(VisualLine.LocalToInsertInstruction localToInsertInstruction, params OperationCode[] opCodes)
{
if (!IsLadderFormOpen())
{
return;
}
if (projectForm.LadderForm.VisualInstruction.IsDisposed)
{
return;
}
if (btnSimulateLadder.Checked)
{
btnSimulateLadder.Checked = false;
Thread.Sleep(100);
}
VisualInstructionUserControl visualInstruction = projectForm.LadderForm.VisualInstruction;
VisualLine visualLine = projectForm.LadderForm.SelectedVisualLine;
visualInstruction = visualLine.InsertInstruction(localToInsertInstruction, visualInstruction, opCodes);
projectForm.LadderForm.ReorganizeLines();
visualInstruction.Select();
}
public void InsertAddressAtInstruction(VisualInstructionUserControl visualInstruction, Address address)
{
if (!visualInstruction.IsDisposed)
{
visualInstruction.SetOperand(0, address);
visualInstruction.Refresh();
}
}
public void OutputTypeBox_MouseHover(object sender, EventArgs e)
{
VisualInstructionUserControl visualInstruction = (VisualInstructionUserControl)sender;
if (visualInstruction.Tag != null && (String)visualInstruction.Tag != "")
{
toolTipOutputBox.Show((String)visualInstruction.Tag, visualInstruction, 3000);
}
}
public void VisualInstruction_AskToChangeAddress(VisualInstructionUserControl sender)
{
if (!sender.IsAllOperandsOk())
{
MessageBox.Show("Please, assign an address first!", "Change configuration", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
ChangeTimerCounterParametersForm changeTimerCounterParametersForm = new ChangeTimerCounterParametersForm(sender.OpCode);
OutputBoxInstruction outputBox = ((OutputBoxInstruction)sender.Instruction);
changeTimerCounterParametersForm.Type = outputBox.GetBoxType();
changeTimerCounterParametersForm.Preset = outputBox.GetPreset();
changeTimerCounterParametersForm.Accumulated = outputBox.GetAccumulated();
if (sender.OpCode.Equals(OperationCode.Timer))
{
changeTimerCounterParametersForm.TimeBase = ((TimerInstruction)outputBox).GetTimeBase();
}
DialogResult result = changeTimerCounterParametersForm.ShowDialog();
if (result == DialogResult.OK)
{
outputBox = (OutputBoxInstruction)sender.Instruction;
outputBox.setBoxType(changeTimerCounterParametersForm.Type);
outputBox.setPreset(changeTimerCounterParametersForm.Preset);
outputBox.setAccumulated(changeTimerCounterParametersForm.Accumulated);
switch (sender.OpCode)
{
case OperationCode.Timer:
((TimerInstruction)outputBox).SetTimeBase(changeTimerCounterParametersForm.TimeBase);
sender.GetAddress().Timer.Type = changeTimerCounterParametersForm.Type;
sender.GetAddress().Timer.Preset = changeTimerCounterParametersForm.Preset;
sender.GetAddress().Timer.Accumulated = changeTimerCounterParametersForm.Accumulated;
sender.GetAddress().Timer.TimeBase = changeTimerCounterParametersForm.TimeBase;
break;
case OperationCode.Counter:
CounterInstruction counter = ((CounterInstruction)outputBox);
counter.Counter.Type = changeTimerCounterParametersForm.Type;
counter.Counter.Preset = changeTimerCounterParametersForm.Preset;
counter.Counter.Accumulated = changeTimerCounterParametersForm.Accumulated;
break;
}
sender.Invalidate();
}
}
public List <Instruction> VariosSelecionados(VisualInstructionUserControl visualInstruction)
{
OperationCode opCode = visualInstruction.OpCode;
List <Instruction> instructions = new List <Instruction>();
List <VisualInstructionUserControl> visualInstructions;
switch (opCode)
{
case OperationCode.ParallelBranchBegin:
case OperationCode.ParallelBranchNext:
case OperationCode.ParallelBranchEnd:
int initialPositionIndex;
int finalPositionIndex;
if (SelectedVisualLine.visualInstructions.Contains(visualInstruction))
{
visualInstructions = SelectedVisualLine.visualInstructions;
}
else if (SelectedVisualLine.visualOutputInstructions.Contains(visualInstruction))
{
visualInstructions = SelectedVisualLine.visualOutputInstructions;
}
else
{
return(instructions);
}
initialPositionIndex = visualInstructions.IndexOf(visualInstruction);
if (opCode == OperationCode.ParallelBranchEnd)
{
finalPositionIndex = initialPositionIndex;
initialPositionIndex = visualInstructions.IndexOf(visualInstruction.PointToParallelBegin);
}
else
{
finalPositionIndex = visualInstructions.IndexOf(visualInstruction.PointToNextParallelPoint);
}
for (int i = initialPositionIndex; i <= finalPositionIndex; i++)
{
instructions.Add(visualInstructions[i].Instruction);
}
break;
default:
instructions.Add(visualInstruction.Instruction);
break;
}
return(instructions);
}
private static int VerifyPositionToInsert(bool after, VisualInstructionUserControl visualInstruction, List <VisualInstructionUserControl> visualInstructions)
{
int index = visualInstructions.IndexOf(visualInstruction);
if (index < 0)
{
index = 0;
}
else
if (after)
{
index++;
}
return(index);
}
public void VisualInstruction_Selected(VisualInstructionUserControl visualInstruction, VisualLine visualLine)
{
if (VisualInstruction != null)
{
if (!VisualInstruction.IsDisposed)
{
if (!VisualInstruction.Equals(visualInstruction))
{
VisualInstruction.Selected = false;
VisualInstruction.Refresh();
}
}
}
VisualInstruction = visualInstruction;
SelectedVisualLine = visualLine;
}
public void LineBeginVisualInstruction_ChangeLine(VisualInstructionUserControl sender, Keys e)
{
if (e == Keys.Up)
{
if ((int)sender.VisualLine.LineNumber != 0)
{
sender.VisualLine.PreviousLine.LineBegin.Select();
}
}
else if (e == Keys.Down)
{
if ((int)sender.VisualLine.NextLine.LineNumber != 0)
{
sender.VisualLine.NextLine.LineBegin.Select();
}
}
}
private void PasteToolStripMenuItem_Click(object sender, EventArgs e)
{
if (IsLadderFormOpen())
{
if (projectForm.LadderForm.VisualInstruction != null)
{
if (!projectForm.LadderForm.VisualInstruction.IsDisposed)
{
DataFormats.Format myFormat = DataFormats.GetFormat("List<SimboloBasico>");
Object returnObject = null;
List <Instruction> instructionsSource = new List <Instruction>();
InstructionList instructionsDestination = new InstructionList();
IDataObject iData = Clipboard.GetDataObject();
// Determines whether the data is in a format you can use.
if (iData.GetDataPresent(myFormat.Name))
{
try
{
returnObject = iData.GetData(myFormat.Name);
}
catch
{
MessageBox.Show("Error");
}
}
instructionsSource = (List <Instruction>)returnObject;
instructionsDestination.InsertAllWithClearBefore(instructionsSource);
VisualInstructionUserControl visualInstruction = projectForm.LadderForm.SelectedVisualLine.InsertInstructionAtLocalToBeDefined(true, projectForm.LadderForm.VisualInstruction, instructionsDestination);
projectForm.LadderForm.ReorganizeLines();
visualInstruction.Select();
}
}
}
}
void LineBeginVisualInstruction_Click(object sender, MouseEventArgs e)
{
if (!e.Button.Equals(MouseButtons.Right))
{
return;
}
VisualInstructionUserControl visualInstruction = (VisualInstructionUserControl)sender;
if (visualInstruction.OpCode == OperationCode.LineBegin)
{
ladderForm.mnuAddressing.Enabled = false;
ladderForm.mnuInsertLadderLine.Enabled = true;
ladderForm.mnuExtendParallelBranchAbove.Enabled = false;
ladderForm.mnuExtendParallelBranchAbove.Visible = false;
ladderForm.mnuExtendParallelBranchBelow.Enabled = false;
ladderForm.mnuExtendParallelBranchBelow.Visible = false;
ladderForm.mnuContextAtInstruction.Show(visualInstruction.PointToScreen(e.Location));
}
}
void VisualInstruction_Click(object sender, MouseEventArgs e)
{
if (!e.Button.Equals(MouseButtons.Right))
{
return;
}
VisualInstructionUserControl visualInstruction = (VisualInstructionUserControl)sender;
OperationCode opCode = visualInstruction.OpCode;
if (opCode != OperationCode.LineBegin)
{
ladderForm.mnuInsertLadderLine.Enabled = false;
ladderForm.mnuToggleBit.Enabled = false;
if (opCode == OperationCode.ParallelBranchBegin ||
opCode == OperationCode.ParallelBranchEnd ||
opCode == OperationCode.ParallelBranchNext)
{
ladderForm.mnuAddressing.Enabled = false;
ladderForm.mnuAddressing.Visible = false;
ladderForm.mnuExtendParallelBranchAbove.Enabled = true;
ladderForm.mnuExtendParallelBranchAbove.Visible = true;
ladderForm.mnuExtendParallelBranchBelow.Enabled = true;
ladderForm.mnuExtendParallelBranchBelow.Visible = true;
}
else
{
ladderForm.mnuAddressing.Enabled = true;
ladderForm.mnuAddressing.Visible = true;
if (visualInstruction.IsAllOperandsOk())
{
ladderForm.mnuToggleBit.Enabled = true;
}
else
{
ladderForm.mnuToggleBit.Enabled = false;
}
ProjectForm projectForm = ladderForm.projectForm;
TreeNode addressingNode = projectForm.tvnProjectTree.Nodes["tvnProjectNode"].Nodes["tvnAddressingNode"];
foreach (TreeNode eachAddressTypeNode in addressingNode.Nodes)
{
ToolStripMenuItem menu = null;
switch (eachAddressTypeNode.Text)
{
case "Memories":
menu = ladderForm.mnuMemory;
break;
case "Timer":
menu = ladderForm.mnuTimer;
break;
case "Counter":
menu = ladderForm.mnuCounter;
break;
case "Input":
menu = ladderForm.mnuInput;
break;
case "Output":
menu = ladderForm.mnuOutput;
break;
}
Address address = null;
if (visualInstruction.IsAllOperandsOk())
{
Object obj = visualInstruction.GetOperand(0);
if (obj is Address)
{
address = (Address)obj;
}
}
menu.DropDownItems.Clear();
foreach (TreeNode eachAddressNode in eachAddressTypeNode.Nodes)
{
menu.DropDownItems.Add(eachAddressNode.Text);
if (address != null)
{
if (address.GetName() == eachAddressNode.Text)
{
menu.DropDownItems[menu.DropDownItems.Count - 1].Select();
}
}
menu.DropDownItems[menu.DropDownItems.Count - 1].Name = eachAddressNode.Text;
menu.DropDownItems[menu.DropDownItems.Count - 1].Tag = eachAddressNode.Tag;
menu.DropDownItems[menu.DropDownItems.Count - 1].Click += new EventHandler(MenuContextAddress_Click);
}
}
}
}
ladderForm.mnuContextAtInstruction.Show(visualInstruction.PointToScreen(e.Location));
}
public VisualInstructionUserControl InsertInstruction(LocalToInsertInstruction localToInsertInstruction, VisualInstructionUserControl visualInstruction, params OperationCode[] opCodes)
{
return(InsertInstruction(true, localToInsertInstruction, visualInstruction, opCodes));
}
public VisualInstructionUserControl InsertInstruction(bool after, LocalToInsertInstruction localToInsertInstruction, VisualInstructionUserControl visualInstruction, params OperationCode[] opCodes)
{
InstructionList instructions = new InstructionList();
instructions.InsertAllWithClearBefore(opCodes);
switch (localToInsertInstruction)
{
case LocalToInsertInstruction.Undefined:
visualInstruction = InsertInstructionAtLocalToBeDefined(after, visualInstruction, instructions);
break;
case LocalToInsertInstruction.ConditionsAtLeft:
visualInstruction = InsertConditionInstructionAtLeft(after, visualInstruction, instructions);
break;
case LocalToInsertInstruction.OutputsAtRight:
visualInstruction = InsertOutputInstructionAtRight(after, visualInstruction, instructions);
break;
}
return(visualInstruction);
}
public VisualInstructionUserControl InsertInstructionAtLocalToBeDefined(bool after, VisualInstructionUserControl visualInstruction, InstructionList instructions)
{
instructions.ValidateOperands();
if (!instructions.Contains(OperationCode.OutputCoil) &&
!instructions.Contains(OperationCode.Timer) &&
!instructions.Contains(OperationCode.Counter))
{
return(InsertConditionInstructionAtLeft(after, visualInstruction, instructions));
}
else
{
return(InsertOutputInstructionAtRight(after, visualInstruction, instructions));
}
}
private VisualInstructionUserControl InsertConditionInstructionAtLeft(bool after, VisualInstructionUserControl visualInstruction, InstructionList instructions)
{
int index = VerifyPositionToInsert(after, visualInstruction, this.visualInstructions);
foreach (Instruction instruction in instructions)
{
line.Instructions.Insert(index, instruction);
InsertVisualInstructionAt(index, this.visualInstructions, instruction);
index++;
}
return(this.visualInstructions[index - 1]);
}
private VisualInstructionUserControl InsertOutputInstructionAtRight(bool after, VisualInstructionUserControl visualInstruction, InstructionList instructions)
{
int index = 0;
int autToRetornInsertedInstruction = 0;
switch (visualOutputInstructions.Count)
{
case 0:
index = 0;
if (instructions.Count > 1)
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchCompleted);
autToRetornInsertedInstruction = -1;
}
break;
case 1:
index = VerifyPositionToInsert(after, visualInstruction, this.visualOutputInstructions);
if (index == 0)
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchNext));
InsertVisualInstructionAt(0, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchNext));
line.Outputs.Insert(this.visualOutputInstructions.Count, InstructionFactory.createInstruction(OperationCode.ParallelBranchEnd));
InsertVisualInstructionAt(this.visualOutputInstructions.Count, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchEnd));
}
else
{
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchFinalized);
autToRetornInsertedInstruction = -1;
line.Outputs.Insert(0, InstructionFactory.createInstruction(OperationCode.ParallelBranchBegin));
InsertVisualInstructionAt(0, this.visualOutputInstructions, InstructionFactory.createInstruction(OperationCode.ParallelBranchBegin));
index++;
}
break;
default:
index = VerifyPositionToInsert(false, visualInstruction, this.visualOutputInstructions);
switch (this.visualOutputInstructions[index].OpCode)
{
case OperationCode.ParallelBranchBegin:
instructions.InsertParallelBranch(InstructionList.ParallelBranchInsertionType.ParallelBranchInitialized);
line.Outputs[0].OpCode = OperationCode.ParallelBranchNext;
this.visualOutputInstructions[0].OpCode = OperationCode.ParallelBranchNext;
break;
case OperationCode.ParallelBranchNext:
instructions.InsertParallelBranchNext();
break;
case OperationCode.ParallelBranchEnd:
instructions.InsertParallelBranchNext();
break;
default:
instructions.InsertParallelBranchNext();
index++;
break;
}
break;
}
foreach (Instruction instruction in instructions)
{
line.Outputs.Insert(index, instruction);
InsertVisualInstructionAt(index, this.visualOutputInstructions, instruction);
index++;
}
return(this.visualOutputInstructions[index - 1 + autToRetornInsertedInstruction]);
}
public void AdjustPositioning()
{
VisualInstructionUserControl visualInstructionAux = null;
int biggerX = 0;
int countInstructions = 0;
int accumulatedXAtFirstOutputInstruction = 0;
int accumulatedXAtBiggerOutputInstruction = 0;
int outputSize = 0;
VisualParallelBranch parallelBranch = null;
List <VisualParallelBranch> visualParallelBranches = new List <VisualParallelBranch>();
int lastSizeOfYToFinalParallelBranch = 0;
int sizeOfYToBackgroundDraw = 0;
int xPosition = XPosition;
int yPosition = YPosition;
int xSize = XSize;
int ySize = YSize;
int xSizeAccumulated = XSize;
int ySizeAccumulated = YSize;
visualInstructions.AddRange(visualOutputInstructions);
foreach (VisualInstructionUserControl visualInstruction in visualInstructions)
{
countInstructions++;
if (visualParallelBranches.Count == 0)
{
if (biggerX > 0)
{
xPosition = biggerX;
}
biggerX = 0;
}
else
{
if (biggerX < (xPosition + xSize))
{
biggerX = xPosition + xSize;
}
}
switch (visualInstruction.OpCode)
{
case OperationCode.ParallelBranchBegin:
ySize = YSize; // restaura tamanho Y base
xPosition = xSizeAccumulated;
xSize = this.XSize / 3;
parallelBranch = new VisualParallelBranch();
visualParallelBranches.Add(parallelBranch);
parallelBranch.accumulatedY = yPosition;
parallelBranch.biggerY = yPosition;
parallelBranch.biggerX = biggerX;
parallelBranch.parallelBranchBegin = visualInstruction;
xSizeAccumulated = xPosition + xSize;
break;
case OperationCode.ParallelBranchEnd:
xSize = this.XSize / 3;
ySize = parallelBranch.lastParallelBranchNext.XYPosition.Y - parallelBranch.parallelBranchBegin.XYPosition.Y + parallelBranch.lastParallelBranchNext.XYSize.Height; // _ultTamY2ParaleloFinal;
yPosition = parallelBranch.parallelBranchBegin.XYPosition.Y;
if (biggerX > parallelBranch.biggerX)
{
parallelBranch.biggerX = biggerX;
}
xPosition = parallelBranch.biggerX;
if (lastSizeOfYToFinalParallelBranch > sizeOfYToBackgroundDraw)
{
sizeOfYToBackgroundDraw = lastSizeOfYToFinalParallelBranch;
}
visualInstruction.AssociateParallelBranchList(parallelBranch.parallelBranchList);
visualInstruction.PointToParallelBegin = parallelBranch.parallelBranchBegin;
parallelBranch.parallelBranchBegin.PointToParallelEnd = visualInstruction;
parallelBranch.lastParallelBranchNext.PointToNextParallelPoint = visualInstruction;
parallelBranch.lastParallelBranchNext.LastParallelBranchEnd = true;
parallelBranch = null;
visualParallelBranches.RemoveAt(visualParallelBranches.Count - 1);
if (visualParallelBranches.Count > 0)
{
parallelBranch = visualParallelBranches[visualParallelBranches.Count - 1];
}
if (visualParallelBranches.Count > 0)
{
if (lastSizeOfYToFinalParallelBranch > parallelBranch.biggerY)
{
parallelBranch.biggerY = lastSizeOfYToFinalParallelBranch;
}
}
xSizeAccumulated = xPosition + xSize;
break;
case OperationCode.ParallelBranchNext:
ySize = YSize;
xSize = this.XSize / 3;
if (biggerX > parallelBranch.biggerX)
{
parallelBranch.biggerX = biggerX;
}
biggerX = 0;
xPosition = parallelBranch.parallelBranchBegin.XYPosition.X;
parallelBranch.accumulatedY = parallelBranch.biggerY;
yPosition = parallelBranch.biggerY + (YSize * (parallelBranch.numberOfParallelBranchNext + 1));
if (parallelBranch.numberOfParallelBranchNext > 0)
{
visualInstructionAux = parallelBranch.lastParallelBranchNext;
visualInstructionAux.LastParallelBranchEnd = false;
}
else
{
visualInstructionAux = parallelBranch.parallelBranchBegin;
}
visualInstructionAux.XYSize = new Size(visualInstructionAux.XYSize.Width, yPosition - visualInstructionAux.XYPosition.Y);
visualInstructionAux.PointToNextParallelPoint = visualInstruction;
parallelBranch.numberOfParallelBranchNext += 1;
parallelBranch.lastParallelBranchNext = visualInstruction;
lastSizeOfYToFinalParallelBranch = yPosition;
parallelBranch.parallelBranchList.Add(visualInstruction);
xSizeAccumulated = xPosition + xSize;
break;
default:
ySize = YSize;
xSize = XSize;
xPosition = xSizeAccumulated;
xSizeAccumulated += xSize;
break;
}
visualInstruction.XYPosition = new Point(xPosition, yPosition);
visualInstruction.XYSize = new Size(xSize, ySize);
if ((visualOutputInstructions.Count > 0) && (countInstructions >= (visualInstructions.Count - visualOutputInstructions.Count)))
{
if (countInstructions == (visualInstructions.Count - visualOutputInstructions.Count))
{
accumulatedXAtFirstOutputInstruction = xSizeAccumulated;
}
if (accumulatedXAtBiggerOutputInstruction < xSizeAccumulated)
{
accumulatedXAtBiggerOutputInstruction = xSizeAccumulated;
}
}
}
outputSize = (accumulatedXAtBiggerOutputInstruction - accumulatedXAtFirstOutputInstruction);// -this.tamX;
if (outputSize == 0)
{
outputSize = XSize;
}
visualInstructions.RemoveRange((visualInstructions.Count - visualOutputInstructions.Count), visualOutputInstructions.Count);
sizeOfYToBackgroundDraw += YSize;
if ((YPosition > YSize) && (sizeOfYToBackgroundDraw > YPosition))
{
sizeOfYToBackgroundDraw -= YPosition;
}
LineBegin.XYPosition = new Point(XPosition, YPosition);
LineBegin.XYSize = new Size(this.XSize, sizeOfYToBackgroundDraw);
LineBegin.Location = new Point(XPosition, YPosition);
LineBegin.Size = new Size(this.XSize, sizeOfYToBackgroundDraw);
if (xSizeAccumulated < (ladderForm.Width - this.XSize))
{
xSizeAccumulated = (ladderForm.Width - this.XSize);
}
if (PreviousLine != null)
{
if (xSizeAccumulated < PreviousLine.LineEnd.XYPosition.X)
{
xSizeAccumulated = PreviousLine.LineEnd.XYPosition.X;
}
}
XPositionToFirstOutputVisualInstruction = xSizeAccumulated - accumulatedXAtFirstOutputInstruction - (outputSize);
LineEnd.XYPosition = new Point(xSizeAccumulated, YPosition);
LineEnd.XYSize = new Size(this.XSize, sizeOfYToBackgroundDraw);
LineEnd.Location = new Point(xSizeAccumulated, YPosition);
LineEnd.Size = new Size(this.XSize, sizeOfYToBackgroundDraw);
BackgroundLine.XYPosition = new Point(XPosition, YPosition);
BackgroundLine.XYSize = new Size(xSizeAccumulated, sizeOfYToBackgroundDraw);
BackgroundLine.Location = new Point(XPosition, YPosition);
BackgroundLine.Size = new Size(xSizeAccumulated, sizeOfYToBackgroundDraw);
ResizeVisualInstructions();
}
public bool RemoveInstruction(List <VisualInstructionUserControl> visualInstructions, List <Instruction> instructions, VisualInstructionUserControl visulInstructionToBeRemoved)
{
int index = visualInstructions.IndexOf(visulInstructionToBeRemoved);
visualInstructions.RemoveAt(index);
instructions.RemoveAt(index);
visulInstructionToBeRemoved.VisualInstructionSelectedEvent -= new VisualInstructionSelectedEventHandler(ladderForm.VisualInstruction_Selected);
visulInstructionToBeRemoved.MouseClick -= new MouseEventHandler(VisualInstruction_Click);
visulInstructionToBeRemoved.KeyDown -= new KeyEventHandler(ladderForm.VisualInstruction_KeyDown);
visulInstructionToBeRemoved.Instruction.Dispose();
visulInstructionToBeRemoved.Dispose();
return(true);
}
public bool RemoveVisualInstruction(VisualInstructionUserControl visualInstructionToBeRemoved)
{
int initialPositionIndex = 0;
int finalPositionIndex = 0;
int outputIndex = 0;
List <VisualInstructionUserControl> visualInstructionsToRemove = new List <VisualInstructionUserControl>();
List <VisualInstructionUserControl> visualInstructionsAux = null;
List <Instruction> instructions = null;
VisualInstructionUserControl visualInstructionToChangeOpCode = null;
if (!visualInstructions.Contains(visualInstructionToBeRemoved))
{
if (!visualOutputInstructions.Contains(visualInstructionToBeRemoved))
{
return(false);
}
else
{
visualInstructionsAux = visualOutputInstructions;
instructions = line.Outputs;
switch (visualInstructionToBeRemoved.OpCode)
{
case OperationCode.ParallelBranchBegin:
case OperationCode.ParallelBranchEnd:
case OperationCode.ParallelBranchNext:
break;
default:
if (this.visualOutputInstructions.Count > 1)
{
outputIndex = this.visualOutputInstructions.IndexOf(visualInstructionToBeRemoved);
visualInstructionToBeRemoved = this.visualOutputInstructions[outputIndex - 1];
}
break;
}
}
}
else
{
visualInstructionsAux = visualInstructions;
instructions = line.Instructions;
}
switch (visualInstructionToBeRemoved.OpCode)
{
case OperationCode.ParallelBranchBegin:
case OperationCode.ParallelBranchNext:
initialPositionIndex = visualInstructionsAux.IndexOf(visualInstructionToBeRemoved);
finalPositionIndex = visualInstructionsAux.IndexOf(visualInstructionToBeRemoved.PointToNextParallelPoint);
finalPositionIndex--;
switch (visualInstructionToBeRemoved.OpCode)
{
case OperationCode.ParallelBranchBegin:
if (visualInstructionToBeRemoved.PointToNextParallelPoint.PointToNextParallelPoint.PointToParallelBegin != null)
{
visualInstructionsToRemove.Add(visualInstructionToBeRemoved.PointToNextParallelPoint.PointToNextParallelPoint);
finalPositionIndex++;
}
else
{
visualInstructionToChangeOpCode = visualInstructionToBeRemoved.PointToNextParallelPoint;
}
break;
case OperationCode.ParallelBranchNext:
if (visualInstructionToBeRemoved.PointToNextParallelPoint.PointToParallelBegin != null)
{
if (visualInstructionToBeRemoved.PointToNextParallelPoint.PointToParallelBegin.PointToNextParallelPoint.Equals(visualInstructionToBeRemoved))
{
visualInstructionsToRemove.Add(visualInstructionToBeRemoved.PointToNextParallelPoint.PointToParallelBegin);
finalPositionIndex++;
}
}
break;
}
break;
case OperationCode.ParallelBranchEnd:
finalPositionIndex = visualInstructionsAux.IndexOf(visualInstructionToBeRemoved);
initialPositionIndex = visualInstructionsAux.IndexOf(visualInstructionToBeRemoved.PointToParallelBegin);
break;
default:
initialPositionIndex = visualInstructionsAux.IndexOf(visualInstructionToBeRemoved);
finalPositionIndex = initialPositionIndex;
break;
}
for (int i = initialPositionIndex; i <= finalPositionIndex; i++)
{
visualInstructionsToRemove.Add(visualInstructionsAux[i]);
}
foreach (VisualInstructionUserControl eachVisualInstructionToBeRemoved in visualInstructionsToRemove)
{
RemoveInstruction(visualInstructionsAux, instructions, eachVisualInstructionToBeRemoved);
}
if (visualInstructionToChangeOpCode != null)
{
visualInstructionToChangeOpCode.OpCode = OperationCode.ParallelBranchBegin;
}
return(true);
}
public VisualInstructionUserControl InsertInstructionDirect(List <VisualInstructionUserControl> visualInstructions, VisualInstructionUserControl visualInstruction, List <Instruction> instructions)
{
int index = visualInstructions.IndexOf(visualInstruction);
if (index < 0)
{
index = 0;
}
else
{
index++;
}
if (instructions.Count > 0)
{
foreach (Instruction instruction in instructions)
{
InsertVisualInstructionAt(index, visualInstructions, instruction);
index++;
}
return(visualInstructions[index - 1]);
}
return(null);
}
