--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SFCViewer.py Wed Jan 31 16:31:39 2007 +0100
@@ -0,0 +1,1604 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
+#based on the plcopen standard.
+#
+#Copyright (C): Edouard TISSERANT and Laurent BESSARD
+#
+#See COPYING file for copyrights details.
+#
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+#
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+#Lesser General Public License for more details.
+#
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+from wxPython.wx import *
+from wxPython.grid import *
+import wx
+from types import *
+
+from plcopen.structures import *
+from graphics.GraphicCommons import *
+from graphics.SFC_Objects import *
+from Viewer import *
+
+class SFC_Viewer(Viewer):
+
+ def __init__(self, parent, window, controler):
+ Viewer.__init__(self, parent, window, controler)
+
+ def ConnectConnectors(self, start, end):
+ startpoint = [start.GetPosition(False), start.GetDirection()]
+ endpoint = [end.GetPosition(False), end.GetDirection()]
+ wire = Wire(self, startpoint, endpoint)
+ self.Wires.append(wire)
+ self.Elements.append(wire)
+ start.Connect((wire, 0), False)
+ end.Connect((wire, -1), False)
+ wire.ConnectStartPoint(None, start)
+ wire.ConnectEndPoint(None, end)
+ return wire
+
+ def CreateTransition(self, connector, next = None):
+ previous = connector.GetParentBlock()
+ id = self.GetNewId()
+ transition = SFC_Transition(self, "reference", "", id)
+ pos = connector.GetPosition(False)
+ transition.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)
+ transition_connectors = transition.GetConnectors()
+ wire = self.ConnectConnectors(transition_connectors["input"], connector)
+ if isinstance(previous, SFC_Divergence):
+ previous.RefreshConnectedPosition(connector)
+ else:
+ previous.RefreshOutputPosition()
+ wire.SetPoints([wxPoint(pos.x, pos.y + GetWireSize(previous)), wxPoint(pos.x, pos.y)])
+ self.Blocks.append(transition)
+ self.Elements.append(transition)
+ self.Controler.AddCurrentElementEditingTransition(id)
+ self.RefreshTransitionModel(transition)
+ if next:
+ wire = self.ConnectConnectors(next, transition_connectors["output"])
+ pos = transition_connectors["output"].GetPosition(False)
+ next_block = next.GetParentBlock()
+ next_pos = next.GetPosition(False)
+ transition.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ if isinstance(next_block, SFC_Divergence):
+ next_block.RefreshPosition()
+ next_block.RefreshModel()
+ return transition
+
+ def RemoveTransition(self, transition):
+ connectors = transition.GetConnectors()
+ input_wires = connectors["input"].GetWires()
+ if len(input_wires) != 1:
+ return
+ input_wire = input_wires[0][0]
+ previous = input_wire.EndConnected
+ input_wire.Clean()
+ self.Wires.remove(input_wire)
+ self.Elements.remove(input_wire)
+ output_wires = connectors["output"].GetWires()
+ if len(output_wires) != 1:
+ return
+ output_wire = output_wires[0][0]
+ next = output_wire.StartConnected
+ output_wire.Clean()
+ self.Wires.remove(output_wire)
+ self.Elements.remove(output_wire)
+ transition.Clean()
+ self.Blocks.remove(transition)
+ self.Elements.remove(transition)
+ self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())
+ wire = self.ConnectConnectors(next, previous)
+ return wire
+
+ def CreateStep(self, name, connector, next = None):
+ previous = connector.GetParentBlock()
+ id = self.GetNewId()
+ step = SFC_Step(self, name, False, id)
+ if next:
+ step.AddOutput()
+ min_width, min_height = step.GetMinSize()
+ pos = connector.GetPosition(False)
+ step.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)
+ step.SetSize(min_width, min_height)
+ step_connectors = step.GetConnectors()
+ wire = self.ConnectConnectors(step_connectors["input"], connector)
+ if isinstance(previous, SFC_Divergence):
+ previous.RefreshConnectedPosition(connector)
+ else:
+ previous.RefreshOutputPosition()
+ wire.SetPoints([wxPoint(pos.x, pos.y + GetWireSize(previous)), wxPoint(pos.x, pos.y)])
+ self.Blocks.append(step)
+ self.Elements.append(step)
+ self.Controler.AddCurrentElementEditingStep(id)
+ self.RefreshStepModel(step)
+ if next:
+ wire = self.ConnectConnectors(next, step_connectors["output"])
+ pos = step_connectors["output"].GetPosition(False)
+ next_block = next.GetParentBlock()
+ next_pos = next.GetPosition(False)
+ step.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ if isinstance(next_block, SFC_Divergence):
+ next_block.RefreshPosition()
+ next_block.RefreshModel()
+ return step
+
+ def RemoveStep(self, step):
+ connectors = step.GetConnectors()
+ if connectors["input"]:
+ input_wires = connectors["input"].GetWires()
+ if len(input_wires) != 1:
+ return
+ input_wire = input_wires[0][0]
+ previous = input_wire.EndConnected
+ input_wire.Clean()
+ self.Wires.remove(input_wire)
+ self.Elements.remove(input_wire)
+ else:
+ previous = None
+ if connectors["output"]:
+ output_wires = connectors["output"].GetWires()
+ if len(output_wires) != 1:
+ return
+ output_wire = output_wires[0][0]
+ next = output_wire.StartConnected
+ output_wire.Clean()
+ self.Wires.remove(output_wire)
+ self.Elements.remove(output_wire)
+ else:
+ next = None
+ action = step.GetActionConnector()
+ if action:
+ self.DeleteActionBlock(action.GetParentBlock())
+ step.Clean()
+ self.Blocks.remove(step)
+ self.Elements.remove(step)
+ self.Controler.RemoveCurrentElementEditingInstance(step.GetId())
+ if next and previous:
+ wire = self.ConnectConnectors(next, previous)
+ return wire
+ else:
+ return None
+
+#-------------------------------------------------------------------------------
+# Mouse event functions
+#-------------------------------------------------------------------------------
+
+ def OnViewerLeftDown(self, event):
+ if self.Mode == MODE_SELECTION:
+ pos = event.GetPosition()
+ if event.ControlDown():
+ element = self.FindElement(pos, True)
+ if element and element not in self.Wires:
+ if isinstance(self.SelectedElement, Graphic_Group):
+ self.SelectedElement.SelectElement(element)
+ else:
+ group = Graphic_Group(self)
+ self.SelectedElement.SetSelected(False)
+ group.SelectElement(self.SelectedElement)
+ group.SelectElement(element)
+ self.SelectedElement = group
+ elements = self.SelectedElement.GetElements()
+ if len(elements) == 0:
+ self.SelectedElement = element
+ elif len(elements) == 1:
+ self.SelectedElement = elements[0]
+ else:
+ element = self.FindElement(pos)
+ if self.SelectedElement and self.SelectedElement != element:
+ if self.SelectedElement in self.Wires:
+ self.SelectedElement.SetSelectedSegment(None)
+ else:
+ self.SelectedElement.SetSelected(False)
+ self.SelectedElement = None
+ self.Refresh()
+ if element:
+ self.SelectedElement = element
+ self.SelectedElement.OnLeftDown(event, self.Scaling)
+ self.Refresh()
+ else:
+ self.rubberBand.Reset()
+ self.rubberBand.OnLeftDown(event, self.Scaling)
+ elif self.Mode == MODE_COMMENT:
+ self.rubberBand.Reset()
+ self.rubberBand.OnLeftDown(event, self.Scaling)
+ elif self.Mode == MODE_WIRE:
+ pos = GetScaledEventPosition(event, self.Scaling)
+ wire = Wire(self, [wxPoint(pos.x, pos.y), SOUTH], [wxPoint(pos.x, pos.y), NORTH])
+ wire.oldPos = pos
+ wire.Handle = (HANDLE_POINT, 0)
+ wire.ProcessDragging(0, 0)
+ wire.Handle = (HANDLE_POINT, 1)
+ self.Wires.append(wire)
+ self.Elements.append(wire)
+ if self.SelectedElement:
+ self.SelectedElement.SetSelected(False)
+ self.SelectedElement = wire
+ self.Refresh()
+ event.Skip()
+
+ def OnViewerLeftUp(self, event):
+ if self.rubberBand.IsShown():
+ if self.Mode == MODE_SELECTION:
+ elements = self.SearchElements(self.rubberBand.GetCurrentExtent())
+ self.rubberBand.OnLeftUp(event, self.Scaling)
+ if len(elements) > 0:
+ self.SelectedElement = Graphic_Group(self)
+ self.SelectedElement.SetElements(elements)
+ self.SelectedElement.SetSelected(True)
+ self.Refresh()
+ elif self.Mode == MODE_COMMENT:
+ bbox = self.rubberBand.GetCurrentExtent()
+ self.rubberBand.OnLeftUp(event, self.Scaling)
+ wxCallAfter(self.AddComment, bbox)
+ elif self.Mode == MODE_INITIAL_STEP:
+ wxCallAfter(self.AddInitialStep, GetScaledEventPosition(event, self.Scaling))
+ elif self.Mode == MODE_SELECTION and self.SelectedElement:
+ if self.SelectedElement in self.Wires:
+ self.SelectedElement.SetSelectedSegment(0)
+ else:
+ self.SelectedElement.OnLeftUp(event, self.Scaling)
+ wxCallAfter(self.SetCursor, wxNullCursor)
+ self.ReleaseMouse()
+ self.Refresh()
+ elif self.Mode == MODE_WIRE and self.SelectedElement:
+ self.SelectedElement.ResetPoints()
+ self.SelectedElement.OnMotion(event, self.Scaling)
+ self.SelectedElement.GeneratePoints()
+ self.SelectedElement.RefreshModel()
+ self.SelectedElement.SetSelected(True)
+ self.Refresh()
+ event.Skip()
+
+ def OnViewerRightUp(self, event):
+ pos = event.GetPosition()
+ element = self.FindElement(pos)
+ if element:
+ if self.SelectedElement and self.SelectedElement != element:
+ self.SelectedElement.SetSelected(False)
+ self.SelectedElement = element
+ if self.SelectedElement in self.Wires:
+ self.SelectedElement.SetSelectedSegment(0)
+ else:
+ self.SelectedElement.SetSelected(True)
+ self.SelectedElement.OnRightUp(event, self.Scaling)
+ wxCallAfter(self.SetCursor, wxNullCursor)
+ self.ReleaseMouse()
+ self.Refresh()
+ event.Skip()
+
+ def OnViewerLeftDClick(self, event):
+ if self.Mode == MODE_SELECTION and self.SelectedElement:
+ self.SelectedElement.OnLeftDClick(event, self.Scaling)
+ self.Refresh()
+ event.Skip()
+
+ def OnViewerMotion(self, event):
+ if self.rubberBand.IsShown():
+ self.rubberBand.OnMotion(event, self.Scaling)
+ elif self.Mode == MODE_SELECTION and self.SelectedElement:
+ if self.SelectedElement not in self.Wires:
+ self.SelectedElement.OnMotion(event, self.Scaling)
+ self.Refresh()
+ elif self.Mode == MODE_WIRE and self.SelectedElement:
+ self.SelectedElement.ResetPoints()
+ self.SelectedElement.OnMotion(event, self.Scaling)
+ self.SelectedElement.GeneratePoints()
+ self.Refresh()
+ event.Skip()
+
+#-------------------------------------------------------------------------------
+# Keyboard event functions
+#-------------------------------------------------------------------------------
+
+ def OnChar(self, event):
+ keycode = event.GetKeyCode()
+ if self.Scaling:
+ scaling = self.Scaling
+ else:
+ scaling = (8, 8)
+ if keycode == WXK_DELETE and self.SelectedElement:
+ self.SelectedElement.Delete()
+ self.SelectedElement = None
+ elif keycode == WXK_LEFT and self.SelectedElement:
+ self.SelectedElement.Move(-scaling[0], 0)
+ elif keycode == WXK_RIGHT and self.SelectedElement:
+ self.SelectedElement.Move(scaling[0], 0)
+ elif keycode == WXK_UP and self.SelectedElement:
+ self.SelectedElement.Move(0, -scaling[1])
+ elif keycode == WXK_DOWN and self.SelectedElement:
+ self.SelectedElement.Move(0, scaling[1])
+ self.Refresh()
+ event.Skip()
+
+#-------------------------------------------------------------------------------
+# Adding element functions
+#-------------------------------------------------------------------------------
+
+ def AddInitialStep(self, pos):
+ dialog = wxTextEntryDialog(self.Parent, "Add a new initial step", "Please enter step name", "", wxOK|wxCANCEL)
+ if dialog.ShowModal() == wxID_OK:
+ id = self.GetNewId()
+ name = dialog.GetValue()
+ step = SFC_Step(self, name, True, id)
+ min_width, min_height = step.GetMinSize()
+ step.SetPosition(pos.x, pos.y)
+ width, height = step.GetSize()
+ step.SetSize(max(min_width, width), max(min_height, height))
+ self.Blocks.append(step)
+ self.Elements.append(step)
+ self.Controler.AddCurrentElementEditingStep(id)
+ self.RefreshStepModel(step)
+ self.Parent.RefreshProjectTree()
+ self.Refresh()
+ dialog.Destroy()
+
+ def AddStep(self):
+ if self.SelectedElement in self.Wires or isinstance(self.SelectedElement, SFC_Step):
+ dialog = wxTextEntryDialog(self.Parent, "Add a new step", "Please enter step name", "", wxOK|wxCANCEL)
+ if dialog.ShowModal() == wxID_OK:
+ name = dialog.GetValue()
+ if self.SelectedElement in self.Wires:
+ self.SelectedElement.SetSelectedSegment(None)
+ previous = self.SelectedElement.EndConnected
+ next = self.SelectedElement.StartConnected
+ self.SelectedElement.Clean()
+ self.Wires.remove(self.SelectedElement)
+ self.Elements.remove(self.SelectedElement)
+ else:
+ connectors = self.SelectedElement.GetConnectors()
+ if connectors["output"]:
+ previous = connectors["output"]
+ wires = previous.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ next = wire.StartConnected
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ else:
+ self.SelectedElement.AddOutput()
+ connectors = self.SelectedElement.GetConnectors()
+ self.RefreshStepModel(self.SelectedElement)
+ previous = connectors["output"]
+ next = None
+ previous_block = previous.GetParentBlock()
+ if isinstance(previous_block, SFC_Step) or isinstance(previous_block, SFC_Divergence) and previous_block.GetType() in [SELECTION_DIVERGENCE, SELECTION_CONVERGENCE]:
+ transition = self.CreateTransition(previous)
+ transition_connectors = transition.GetConnectors()
+ step = self.CreateStep(name, transition_connectors["output"], next)
+ else:
+ step = self.CreateStep(name, previous)
+ step.AddOutput()
+ step.RefreshModel()
+ step_connectors = step.GetConnectors()
+ transition = self.CreateTransition(step_connectors["output"], next)
+ if self.SelectedElement in self.Wires:
+ self.SelectedElement = wire
+ self.SelectedElement.SetSelectedSegment(0)
+ else:
+ self.SelectedElement.SetSelected(False)
+ self.SelectedElement = step
+ self.SelectedElement.SetSelected(True)
+ self.Parent.RefreshProjectTree()
+ self.Refresh()
+ dialog.Destroy()
+
+ def AddStepAction(self):
+ if isinstance(self.SelectedElement, SFC_Step):
+ connectors = self.SelectedElement.GetConnectors()
+ if not connectors["action"]:
+ dialog = ActionBlockDialog(self.Parent)
+ dialog.SetQualifierList(self.Controler.GetQualifierTypes())
+ dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
+ dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
+ if dialog.ShowModal() == wxID_OK:
+ actions = dialog.GetValues()
+ self.SelectedElement.AddAction()
+ self.RefreshStepModel(self.SelectedElement)
+ connectors = self.SelectedElement.GetConnectors()
+ pos = connectors["action"].GetPosition(False)
+ id = self.GetNewId()
+ actionblock = SFC_ActionBlock(self, [], id)
+ actionblock.SetPosition(pos.x + SFC_WIRE_MIN_SIZE, pos.y - SFC_STEP_DEFAULT_SIZE[1] / 2)
+ actionblock_connector = actionblock.GetConnector()
+ wire = self.ConnectConnectors(actionblock_connector, connectors["action"])
+ wire.SetPoints([wxPoint(pos.x + SFC_WIRE_MIN_SIZE, pos.y), wxPoint(pos.x, pos.y)])
+ actionblock.SetActions(actions)
+ self.Blocks.append(actionblock)
+ self.Elements.append(actionblock)
+ self.Controler.AddCurrentElementEditingActionBlock(id)
+ self.RefreshActionBlockModel(actionblock)
+ self.Refresh()
+ dialog.Destroy()
+
+ def AddDivergence(self):
+ if self.SelectedElement in self.Wires or isinstance(self.SelectedElement, Graphic_Group) or isinstance(self.SelectedElement, SFC_Step):
+ dialog = DivergenceCreateDialog(self.Parent)
+ if dialog.ShowModal() == wxID_OK:
+ value = dialog.GetValues()
+ if value["type"] == SELECTION_DIVERGENCE:
+ if self.SelectedElement in self.Wires and isinstance(self.SelectedElement.EndConnected.GetParentBlock(), SFC_Step):
+ self.SelectedElement.SetSelectedSegment(None)
+ previous = self.SelectedElement.EndConnected
+ next = self.SelectedElement.StartConnected
+ self.SelectedElement.Clean()
+ self.Wires.remove(self.SelectedElement)
+ self.Elements.remove(self.SelectedElement)
+ self.SelectedElement = None
+ elif isinstance(self.SelectedElement, SFC_Step):
+ connectors = self.SelectedElement.GetConnectors()
+ if connectors["output"]:
+ previous = connectors["output"]
+ wires = previous.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ next = wire.StartConnected
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ else:
+ self.SelectedElement.AddOutput()
+ connectors = self.SelectedElement.GetConnectors()
+ self.RefreshStepModel(self.SelectedElement)
+ previous = connectors["output"]
+ next = None
+ else:
+ return
+ id = self.GetNewId()
+ divergence = SFC_Divergence(self, SELECTION_DIVERGENCE, value["number"], id)
+ pos = previous.GetPosition(False)
+ previous_block = previous.GetParentBlock()
+ wire_size = GetWireSize(previous_block)
+ divergence.SetPosition(pos.x, pos.y + wire_size)
+ divergence_connectors = divergence.GetConnectors()
+ wire = self.ConnectConnectors(divergence_connectors["inputs"][0], previous)
+ previous_block.RefreshOutputPosition()
+ wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])
+ self.Blocks.append(divergence)
+ self.Elements.append(divergence)
+ self.Controler.AddCurrentElementEditingDivergence(id, value["type"])
+ self.RefreshDivergenceModel(divergence)
+ for index, connector in enumerate(divergence_connectors["outputs"]):
+ if next:
+ wire = self.ConnectConnectors(next, connector)
+ pos = connector.GetPosition(False)
+ next_pos = next.GetPosition(False)
+ next_block = next.GetParentBlock()
+ divergence.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))
+ divergence.RefreshConnectedPosition(connector)
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ next_block.RefreshModel()
+ next = None
+ else:
+ transition = self.CreateTransition(connector)
+ transition_connectors = transition.GetConnectors()
+ step = self.CreateStep("Step", transition_connectors["output"])
+ elif value["type"] == SIMULTANEOUS_DIVERGENCE:
+ if self.SelectedElement in self.Wires and isinstance(self.SelectedElement.EndConnected.GetParentBlock(), SFC_Transition):
+ self.SelectedElement.SetSelectedSegment(None)
+ previous = self.SelectedElement.EndConnected
+ next = self.SelectedElement.StartConnected
+ self.SelectedElement.Clean()
+ self.Wires.remove(self.SelectedElement)
+ self.Elements.remove(self.SelectedElement)
+ self.SelectedElement = None
+ elif isinstance(self.SelectedElement, SFC_Step):
+ connectors = self.SelectedElement.GetConnectors()
+ if connectors["output"]:
+ previous = connectors["output"]
+ wires = previous.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ next = wire.StartConnected
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ else:
+ self.SelectedElement.AddOutput()
+ connectors = self.SelectedElement.GetConnectors()
+ self.RefreshStepModel(self.SelectedElement)
+ previous = connectors["output"]
+ next = None
+ transition = self.CreateTransition(previous)
+ transition_connectors = transition.GetConnectors()
+ previous = transition_connectors["output"]
+ else:
+ return
+ id = self.GetNewId()
+ divergence = SFC_Divergence(self, SIMULTANEOUS_DIVERGENCE, value["number"], id)
+ pos = previous.GetPosition(False)
+ previous_block = previous.GetParentBlock()
+ wire_size = GetWireSize(previous_block)
+ divergence.SetPosition(pos.x, pos.y + wire_size)
+ divergence_connectors = divergence.GetConnectors()
+ wire = self.ConnectConnectors(divergence_connectors["inputs"][0], previous)
+ previous_block.RefreshOutputPosition()
+ wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])
+ self.Blocks.append(divergence)
+ self.Elements.append(divergence)
+ self.Controler.AddCurrentElementEditingDivergence(id, value["type"])
+ self.RefreshDivergenceModel(divergence)
+ for index, connector in enumerate(divergence_connectors["outputs"]):
+ if next:
+ wire = self.ConnectConnectors(next, connector)
+ pos = connector.GetPosition(False)
+ next_pos = next.GetPosition(False)
+ next_block = next.GetParentBlock()
+ divergence.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))
+ divergence.RefreshConnectedPosition(connector)
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ next_block.RefreshModel()
+ next = None
+ else:
+ step = self.CreateStep("Step", connector)
+ elif isinstance(self.SelectedElement, Graphic_Group) and len(self.SelectedElement.GetElements()) > 1:
+ next = None
+ for element in self.SelectedElement.GetElements():
+ connectors = element.GetConnectors()
+ if not isinstance(element, SFC_Step) or connectors["output"] and next:
+ return
+ elif connectors["output"] and not next:
+ wires = connectors["output"].GetWires()
+ if len(wires) != 1:
+ return
+ if value["type"] == SELECTION_CONVERGENCE:
+ transition = wires[0][0].StartConnected.GetParentBlock()
+ transition_connectors = transition.GetConnectors()
+ wires = transition_connectors["output"].GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ next = wire.StartConnected
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ inputs = []
+ for input in self.SelectedElement.GetElements():
+ input_connectors = input.GetConnectors()
+ if not input_connectors["output"]:
+ input.AddOutput()
+ input.RefreshModel()
+ input_connectors = input.GetConnectors()
+ if value["type"] == SELECTION_CONVERGENCE:
+ transition = self.CreateTransition(input_connectors["output"])
+ transition_connectors = transition.GetConnectors()
+ inputs.append(transition_connectors["output"])
+ else:
+ inputs.append(input_connectors["output"])
+ elif value["type"] == SELECTION_CONVERGENCE:
+ wires = input_connectors["output"].GetWires()
+ transition = wires[0][0].StartConnected.GetParentBlock()
+ transition_connectors = transition.GetConnectors()
+ inputs.append(transition_connectors["output"])
+ else:
+ inputs.append(input_connectors["output"])
+ id = self.GetNewId()
+ divergence = SFC_Divergence(self, value["type"], len(inputs), id)
+ pos = inputs[0].GetPosition(False)
+ divergence.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)
+ divergence_connectors = divergence.GetConnectors()
+ for i, input in enumerate(inputs):
+ pos = input.GetPosition(False)
+ wire = self.ConnectConnectors(divergence_connectors["inputs"][i], input)
+ wire_size = GetWireSize(input)
+ wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])
+ input_block = input.GetParentBlock()
+ input_block.RefreshOutputPosition()
+ divergence.RefreshPosition()
+ pos = divergence_connectors["outputs"][0].GetRelPosition()
+ divergence.MoveConnector(divergence_connectors["outputs"][0], - pos.x)
+ self.Blocks.append(divergence)
+ self.Elements.append(divergence)
+ self.Controler.AddCurrentElementEditingDivergence(id, value["type"])
+ self.RefreshDivergenceModel(divergence)
+ if next:
+ wire = self.ConnectConnectors(next, divergence_connectors["outputs"][0])
+ pos = divergence_connectors["outputs"][0].GetPosition(False)
+ next_pos = next.GetPosition(False)
+ next_block = next.GetParentBlock()
+ divergence.RefreshOutputPosition((0, pos.y + SFC_WIRE_MIN_SIZE - next_pos.y))
+ divergence.RefreshConnectedPosition(divergence_connectors["outputs"][0])
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ next_block.RefreshModel()
+ else:
+ if value["type"] == SELECTION_CONVERGENCE:
+ previous = divergence_connectors["outputs"][0]
+ else:
+ transition = self.CreateTransition(divergence_connectors["outputs"][0])
+ transition_connectors = transition.GetConnectors()
+ previous = transition_connectors["output"]
+ self.CreateStep("Step", previous)
+ self.Refresh()
+ dialog.Destroy()
+
+ def AddDivergenceBranch(self, divergence):
+ if isinstance(divergence, SFC_Divergence):
+ type = divergence.GetType()
+ if type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
+ divergence.AddBranch()
+ divergence_connectors = divergence.GetConnectors()
+ if type == SELECTION_DIVERGENCE:
+ transition = self.CreateTransition(divergence_connectors["outputs"][-1])
+ transition_connectors = transition.GetConnectors()
+ previous = transition_connectors["output"]
+ else:
+ previous = divergence_connectors["outputs"][-1]
+ step = self.CreateStep("Step", previous)
+ self.Refresh()
+
+ def AddJump(self):
+ if isinstance(self.SelectedElement, SFC_Step) and not self.SelectedElement.Output:
+ choices = []
+ for block in self.Blocks:
+ if isinstance(block, SFC_Step):
+ choices.append(block.GetName())
+ dialog = wxSingleChoiceDialog(self.Parent, "Add a new jump", "Please choose a target", choices, wxOK|wxCANCEL)
+ if dialog.ShowModal() == wxID_OK:
+ value = dialog.GetStringSelection()
+ self.SelectedElement.AddOutput()
+ self.RefreshStepModel(self.SelectedElement)
+ step_connectors = self.SelectedElement.GetConnectors()
+ transition = self.CreateTransition(step_connectors["output"])
+ transition_connectors = transition.GetConnectors()
+ id = self.GetNewId()
+ jump = SFC_Jump(self, value, id)
+ pos = transition_connectors["output"].GetPosition(False)
+ jump.SetPosition(pos.x, pos.y + SFC_WIRE_MIN_SIZE)
+ self.Blocks.append(jump)
+ self.Elements.append(jump)
+ self.Controler.AddCurrentElementEditingJump(id)
+ jump_connector = jump.GetConnector()
+ wire = self.ConnectConnectors(jump_connector, transition_connectors["output"])
+ transition.RefreshOutputPosition()
+ wire.SetPoints([wxPoint(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wxPoint(pos.x, pos.y)])
+ self.RefreshJumpModel(jump)
+ self.Refresh()
+ dialog.Destroy()
+
+ def AddComment(self, bbox):
+ dialog = wxTextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wxOK|wxCANCEL|wxTE_MULTILINE)
+ if dialog.ShowModal() == wxID_OK:
+ value = dialog.GetValue()
+ id = self.GetNewId()
+ comment = Comment(self, value, id)
+ comment.SetPosition(bbox.x, bbox.y)
+ min_width, min_height = comment.GetMinSize()
+ comment.SetSize(max(min_width,bbox.width),max(min_height,bbox.height))
+ self.Elements.append(comment)
+ self.Controler.AddCurrentElementEditingComment(id)
+ self.RefreshCommentModel(comment)
+ self.Refresh()
+ dialog.Destroy()
+
+ def EditStepContent(self, step):
+ dialog = wxTextEntryDialog(self.Parent, "Edit step name", "Please enter step name", step.GetName(), wxOK|wxCANCEL)
+ if dialog.ShowModal() == wxID_OK:
+ value = dialog.GetValue()
+ step.SetName(value)
+ min_size = step.GetMinSize()
+ size = step.GetSize()
+ step.UpdateSize(max(min_size[0], size[0]), max(min_size[1], size[1]))
+ step.RefreshModel()
+ self.Refresh()
+ dialog.Destroy()
+
+ def EditTransitionContent(self, transition):
+ dialog = TransitionContentDialog(self.Parent)
+ dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
+ dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition()})
+ if dialog.ShowModal() == wxID_OK:
+ values = dialog.GetValues()
+ transition.SetType(values["type"])
+ transition.SetCondition(values["value"])
+ transition.RefreshModel()
+ self.Refresh()
+ dialog.Destroy()
+
+ def EditJumpContent(self, jump):
+ choices = []
+ for block in self.Blocks:
+ if isinstance(block, SFC_Step):
+ choices.append(block.GetName())
+ dialog = wxSingleChoiceDialog(self.Parent, "Edit jump target", "Please choose a target", choices, wxOK|wxCANCEL)
+ dialog.SetSelection(choices.index(jump.GetTarget()))
+ if dialog.ShowModal() == wxID_OK:
+ value = dialog.GetStringSelection()
+ jump.SetTarget(value)
+ jump.RefreshModel()
+ self.Refresh()
+ dialog.Destroy()
+
+ def EditActionBlockContent(self, actionblock):
+ dialog = ActionBlockDialog(self.Parent)
+ dialog.SetQualifierList(self.Controler.GetQualifierTypes())
+ dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
+ dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
+ dialog.SetValues(actionblock.GetActions())
+ if dialog.ShowModal() == wxID_OK:
+ actions = dialog.GetValues()
+ actionblock.SetActions(actions)
+ actionblock.RefreshModel()
+ self.Refresh()
+ dialog.Destroy()
+
+
+#-------------------------------------------------------------------------------
+# Delete element functions
+#-------------------------------------------------------------------------------
+
+ def DeleteStep(self, step):
+ step_connectors = step.GetConnectors()
+ if not step.GetInitial() or not step_connectors["output"]:
+ previous = step.GetPreviousConnector()
+ if previous:
+ previous_block = previous.GetParentBlock()
+ else:
+ previous_block = None
+ next = step.GetNextConnector()
+ if next:
+ next_block = next.GetParentBlock()
+ else:
+ next_block = None
+ if isinstance(next_block, SFC_Transition):
+ self.RemoveTransition(next_block)
+ next = step.GetNextConnector()
+ if next:
+ next_block = next.GetParentBlock()
+ else:
+ next_block = None
+ elif isinstance(previous_block, SFC_Transition):
+ self.RemoveTransition(previous_block)
+ previous = step.GetPreviousConnector()
+ if previous:
+ previous_block = previous.GetParentBlock()
+ else:
+ previous_block = None
+ wire = self.RemoveStep(step)
+ self.SelectedElement = None
+ if next_block:
+ if isinstance(next_block, SFC_Divergence) and next_block.GetType() == SIMULTANEOUS_CONVERGENCE and isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SIMULTANEOUS_DIVERGENCE:
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ next_block.RemoveBranch(next)
+ if next_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(next_block)
+ else:
+ next_block.RefreshModel()
+ previous_block.RemoveBranch(previous)
+ if previous_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(previous_block)
+ else:
+ previous_block.RefreshModel()
+ else:
+ pos = previous.GetPosition(False)
+ next_pos = next.GetPosition(False)
+ wire_size = GetWireSize(previous_block)
+ previous_block.RefreshOutputPosition((0, pos.y + wire_size - next_pos.y))
+ wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])
+ if isinstance(next_block, SFC_Divergence):
+ next_block.RefreshPosition()
+ next_block.RefreshModel()
+ else:
+ if isinstance(previous_block, SFC_Step):
+ previous_block.RemoveOutput()
+ self.RefreshStepModel(previous_block)
+ elif isinstance(previous_block, SFC_Divergence):
+ if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
+ self.DeleteDivergence(previous_block)
+ else:
+ previous_block.RemoveBranch(previous)
+ if previous_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(previous_block)
+ else:
+ self.RefreshDivergenceModel(previous_block)
+
+ def DeleteTransition(self, transition):
+ previous = transition.GetPreviousConnector()
+ previous_block = previous.GetParentBlock()
+ next = transition.GetNextConnector()
+ next_block = next.GetParentBlock()
+ if isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SELECTION_DIVERGENCE and isinstance(next_block, SFC_Divergence) and next_block.GetType() == SELECTION_CONVERGENCE:
+ wires = previous.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ wires = next.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ transition.Clean()
+ self.Blocks.remove(transition)
+ self.Elements.remove(transition)
+ self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())
+ previous_block.RemoveBranch(previous)
+ if previous_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(previous_block)
+ else:
+ self.RefreshDivergenceModel(previous_block)
+ next_block.RemoveBranch(next)
+ if next_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(next_block)
+ else:
+ self.RefreshDivergenceModel(next_block)
+ self.Parent.RefreshProjectTree()
+
+ def DeleteDivergence(self, divergence):
+ connectors = divergence.GetConnectors()
+ type = divergence.GetType()
+ if type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
+ wires = connectors["outputs"][0].GetWires()
+ if len(wires) > 1:
+ return
+ elif len(wires) == 1:
+ next = wires[0][0].StartConnected
+ next_block = next.GetParentBlock()
+ wire = wires[0][0]
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ else:
+ next = None
+ next_block = None
+ for index, connector in enumerate(connectors["inputs"]):
+ if next and index == 0:
+ wires = connector.GetWires()
+ wire = wires[0][0]
+ previous = wires[0][0].EndConnected
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ else:
+ if type == SELECTION_CONVERGENCE:
+ wires = connector.GetWires()
+ previous_block = wires[0][0].EndConnected.GetParentBlock()
+ self.RemoveTransition(previous_block)
+ wires = connector.GetWires()
+ wire = wires[0][0]
+ previous_connector = wire.EndConnected
+ previous_block = previous_connector.GetParentBlock()
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ if isinstance(previous_block, SFC_Step):
+ previous_block.RemoveOutput()
+ self.RefreshStepModel(previous_block)
+ elif isinstance(previous_block, SFC_Divergence):
+ if previous_block.GetType() in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:
+ previous_block.RemoveBranch(previous_connector)
+ if previous_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(previous_block)
+ else:
+ self.RefreshDivergenceModel(previous_block)
+ else:
+ self.DeleteDivergence(previous_block)
+ divergence.Clean()
+ self.Blocks.remove(divergence)
+ self.Elements.remove(divergence)
+ self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())
+ if next:
+ wire = self.ConnectConnectors(next, previous)
+ previous_block = previous.GetParentBlock()
+ pos = previous.GetPosition(False)
+ next_pos = next.GetPosition(False)
+ wire_size = GetWireSize(previous_block)
+ previous_block.RefreshOutputPosition((0, previous_pos.y + wire_size - next_pos.y))
+ wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size),
+ wxPoint(previous_pos.x, previous_pos.y)])
+ if isinstance(next_block, SFC_Divergence):
+ next_block.RefreshPosition()
+ next_block.RefreshModel()
+ elif divergence.GetBranchNumber() == 1:
+ wires = connectors["inputs"][0].GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ previous = wire.EndConnected
+ previous_block = previous.GetParentBlock()
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ wires = connectors["outputs"][0].GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ next = wire.StartConnected
+ next_block = next.GetParentBlock()
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ divergence.Clean()
+ self.Blocks.remove(divergence)
+ self.Elements.remove(divergence)
+ self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())
+ wire = self.ConnectConnectors(next, previous)
+ previous_pos = previous.GetPosition(False)
+ next_pos = next.GetPosition(False)
+ wire_size = GetWireSize(previous_block)
+ previous_block.RefreshOutputPosition((previous_pos.x - next_pos.x, previous_pos.y + wire_size - next_pos.y))
+ wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size),
+ wxPoint(previous_pos.x, previous_pos.y)])
+ if isinstance(next_block, SFC_Divergence):
+ next_block.RefreshPosition()
+ next_block.RefreshModel()
+ self.Parent.RefreshProjectTree()
+
+ def DeleteJump(self, jump):
+ previous = jump.GetPreviousConnector()
+ previous_block = previous.GetParentBlock()
+ if isinstance(previous_block, SFC_Transition):
+ self.RemoveTransition(previous_block)
+ previous = jump.GetPreviousConnector()
+ if previous:
+ previous_block = previous.GetParentBlock()
+ else:
+ previous_block = None
+ wires = previous.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ jump.Clean()
+ self.Blocks.remove(jump)
+ self.Elements.remove(jump)
+ self.Controler.RemoveCurrentElementEditingInstance(jump.GetId())
+ if isinstance(previous_block, SFC_Step):
+ previous_block.RemoveOutput()
+ self.RefreshStepModel(previous_block)
+ elif isinstance(previous_block, SFC_Divergence):
+ if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:
+ self.DeleteDivergence(previous_block)
+ else:
+ previous_block.RemoveBranch(previous)
+ if previous_block.GetBranchNumber() < 2:
+ self.DeleteDivergence(previous_block)
+ else:
+ previous_block.RefreshModel()
+ self.Parent.RefreshProjectTree()
+
+ def DeleteActionBlock(self, actionblock):
+ connector = actionblock.GetConnector()
+ wires = connector.GetWires()
+ if len(wires) != 1:
+ return
+ wire = wires[0][0]
+ step = wire.EndConnected.GetParentBlock()
+ wire.Clean()
+ self.Wires.remove(wire)
+ self.Elements.remove(wire)
+ actionblock.Clean()
+ self.Blocks.remove(actionblock)
+ self.Elements.remove(actionblock)
+ self.Controler.RemoveCurrentElementEditingInstance(actionblock.GetId())
+ step.RemoveAction()
+ self.RefreshStepModel(step)
+ step.RefreshOutputPosition()
+ step.RefreshOutputModel(True)
+ self.Parent.RefreshProjectTree()
+
+ def DeleteComment(self, comment):
+ self.Elements.remove(self.SelectedElement)
+ self.Controler.RemoveCurrentElementEditingInstance(comment.GetId())
+
+ def DeleteWire(self, wire):
+ pass
+
+
+#-------------------------------------------------------------------------------
+# Edit Transition Content Dialog
+#-------------------------------------------------------------------------------
+
+[wxID_TRANSITIONCONTENTDIALOG, wxID_TRANSITIONCONTENTDIALOGMAINPANEL,
+ wxID_TRANSITIONCONTENTDIALOGREFERENCE, wxID_TRANSITIONCONTENTDIALOGINLINE,
+ wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON1, wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON2,
+] = [wx.NewId() for _init_ctrls in range(6)]
+
+class TransitionContentDialog(wx.Dialog):
+ def _init_coll_flexGridSizer1_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.MainPanel, 0, border=0, flag=0)
+
+ def _init_sizers(self):
+ # generated method, don't edit
+ self.flexGridSizer1 = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)
+
+ self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)
+
+ self.SetSizer(self.flexGridSizer1)
+
+ def _init_ctrls(self, prnt):
+ # generated method, don't edit
+ wx.Dialog.__init__(self, id=wxID_TRANSITIONCONTENTDIALOG,
+ name='ProjectDialog', parent=prnt, pos=wx.Point(376, 223),
+ size=wx.Size(300, 200), style=wx.DEFAULT_DIALOG_STYLE,
+ title='Edit transition')
+ self.SetClientSize(wx.Size(300, 200))
+
+ self.MainPanel = wx.Panel(id=wxID_TRANSITIONCONTENTDIALOGMAINPANEL,
+ name='MainPanel', parent=self, pos=wx.Point(0, 0),
+ size=wx.Size(300, 200), style=wx.TAB_TRAVERSAL)
+ self.MainPanel.SetAutoLayout(True)
+
+ self.radioButton1 = wx.RadioButton(id=wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON1,
+ label='Reference', name='radioButton1', parent=self.MainPanel,
+ pos=wx.Point(24, 24), size=wx.Size(114, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON1, self.OnTypeChanged)
+ self.radioButton1.SetValue(True)
+
+ self.Reference = wx.Choice(id=wxID_TRANSITIONCONTENTDIALOGREFERENCE,
+ name='Reference', parent=self.MainPanel, pos=wx.Point(48, 48),
+ size=wx.Size(200, 24), style=0)
+
+ self.radioButton2 = wx.RadioButton(id=wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON2,
+ label='Inline', name='radioButton2', parent=self.MainPanel,
+ pos=wx.Point(24, 72), size=wx.Size(114, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_TRANSITIONCONTENTDIALOGRADIOBUTTON2, self.OnTypeChanged)
+ self.radioButton2.SetValue(False)
+
+ self.Inline = wx.TextCtrl(id=wxID_TRANSITIONCONTENTDIALOGINLINE,
+ name='Inline', parent=self.MainPanel, pos=wx.Point(48, 96),
+ size=wx.Size(200, 24), style=0)
+
+ self._init_sizers()
+
+ def __init__(self, parent):
+ self._init_ctrls(parent)
+ self.ButtonSizer = self.CreateButtonSizer(wxOK|wxCANCEL)
+ self.flexGridSizer1.Add(self.ButtonSizer, 1, wxALIGN_RIGHT)
+
+ EVT_BUTTON(self, self.ButtonSizer.GetAffirmativeButton().GetId(), self.OnOK)
+
+ def OnOK(self, event):
+ error = []
+ if self.radioButton1.GetValue() and self.Reference.GetStringSelection() == "":
+ error.append("Reference")
+ if self.radioButton2.GetValue() and self.Inline.GetValue() == "":
+ error.append("Inline")
+ if len(error) > 0:
+ text = ""
+ for i, item in enumerate(error):
+ if i == 0:
+ text += item
+ elif i == len(error) - 1:
+ text += " and %s"%item
+ else:
+ text += ", %s"%item
+ message = wxMessageDialog(self, "Form isn't complete. %s must be filled!"%text, "Error", wxOK|wxICON_ERROR)
+ message.ShowModal()
+ message.Destroy()
+ else:
+ self.EndModal(wxID_OK)
+
+ def OnTypeChanged(self, event):
+ if self.radioButton1.GetValue():
+ self.Reference.Enable(True)
+ self.Inline.Enable(False)
+ else:
+ self.Reference.Enable(False)
+ self.Inline.Enable(True)
+ event.Skip()
+
+ def SetTransitions(self, transitions):
+ for transition in transitions:
+ self.Reference.Append(transition)
+
+ def SetValues(self, values):
+ if values["type"] == "reference":
+ self.radioButton1.SetValue(True)
+ self.radioButton2.SetValue(False)
+ self.Reference.Enable(True)
+ self.Inline.Enable(False)
+ self.Reference.SetStringSelection(values["value"])
+ elif values["type"] == "inline":
+ self.radioButton1.SetValue(False)
+ self.radioButton2.SetValue(True)
+ self.Reference.Enable(False)
+ self.Inline.Enable(True)
+ self.Inline.SetValue(values["value"])
+
+ def GetValues(self):
+ values = {}
+ if self.radioButton1.GetValue():
+ values["type"] = "reference"
+ values["value"] = self.Reference.GetStringSelection()
+ else:
+ values["type"] = "inline"
+ values["value"] = self.Inline.GetValue()
+ return values
+
+#-------------------------------------------------------------------------------
+# Create New Divergence Dialog
+#-------------------------------------------------------------------------------
+
+[wxID_DIVERGENCECREATEDIALOG, wxID_DIVERGENCECREATEDIALOGMAINPANEL,
+ wxID_DIVERGENCECREATEDIALOGRADIOBUTTON1, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON2,
+ wxID_DIVERGENCECREATEDIALOGRADIOBUTTON3, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON4,
+ wxID_DIVERGENCECREATEDIALOGSEQUENCES, wxID_DIVERGENCECREATEDIALOGPREVIEW,
+ wxID_DIVERGENCECREATEDIALOGSTATICTEXT1, wxID_DIVERGENCECREATEDIALOGSTATICTEXT2,
+ wxID_DIVERGENCECREATEDIALOGSTATICTEXT3,
+] = [wx.NewId() for _init_ctrls in range(11)]
+
+class DivergenceCreateDialog(wx.Dialog):
+ def _init_coll_flexGridSizer1_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.MainPanel, 0, border=0, flag=0)
+
+ def _init_sizers(self):
+ # generated method, don't edit
+ self.flexGridSizer1 = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)
+
+ self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)
+
+ self.SetSizer(self.flexGridSizer1)
+
+ def _init_ctrls(self, prnt):
+ # generated method, don't edit
+ wx.Dialog.__init__(self, id=wxID_DIVERGENCECREATEDIALOG,
+ name='DivergencePropertiesDialog', parent=prnt, pos=wx.Point(376, 223),
+ size=wx.Size(500, 300), style=wx.DEFAULT_DIALOG_STYLE,
+ title='Create a new divergence or convergence')
+ self.SetClientSize(wx.Size(500, 260))
+
+ self.MainPanel = wx.Panel(id=wxID_DIVERGENCECREATEDIALOGMAINPANEL,
+ name='MainPanel', parent=self, pos=wx.Point(0, 0),
+ size=wx.Size(600, 220), style=wx.TAB_TRAVERSAL)
+ self.MainPanel.SetAutoLayout(True)
+
+ self.staticText1 = wx.StaticText(id=wxID_DIVERGENCECREATEDIALOGSTATICTEXT1,
+ label='Type:', name='staticText1', parent=self.MainPanel,
+ pos=wx.Point(24, 24), size=wx.Size(200, 17), style=0)
+
+ self.radioButton1 = wx.RadioButton(id=wxID_DIVERGENCECREATEDIALOGRADIOBUTTON1,
+ label='Selection Divergence', name='radioButton1', parent=self.MainPanel,
+ pos=wx.Point(24, 48), size=wx.Size(200, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON1, self.OnTypeChanged)
+ self.radioButton1.SetValue(True)
+
+ self.radioButton2 = wx.RadioButton(id=wxID_DIVERGENCECREATEDIALOGRADIOBUTTON2,
+ label='Selection Convergence', name='radioButton2', parent=self.MainPanel,
+ pos=wx.Point(24, 72), size=wx.Size(200, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON2, self.OnTypeChanged)
+ self.radioButton2.SetValue(False)
+
+ self.radioButton3 = wx.RadioButton(id=wxID_DIVERGENCECREATEDIALOGRADIOBUTTON3,
+ label='Simultaneous Divergence', name='radioButton3', parent=self.MainPanel,
+ pos=wx.Point(24, 96), size=wx.Size(200, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON3, self.OnTypeChanged)
+ self.radioButton3.SetValue(False)
+
+ self.radioButton4 = wx.RadioButton(id=wxID_DIVERGENCECREATEDIALOGRADIOBUTTON4,
+ label='Simultaneous Convergence', name='radioButton4', parent=self.MainPanel,
+ pos=wx.Point(24, 120), size=wx.Size(200, 24), style=0)
+ EVT_RADIOBUTTON(self, wxID_DIVERGENCECREATEDIALOGRADIOBUTTON4, self.OnTypeChanged)
+ self.radioButton4.SetValue(False)
+
+ self.staticText2 = wx.StaticText(id=wxID_DIVERGENCECREATEDIALOGSTATICTEXT2,
+ label='Number of sequences:', name='staticText2', parent=self.MainPanel,
+ pos=wx.Point(24, 150), size=wx.Size(200, 17), style=0)
+
+ self.Sequences = wx.SpinCtrl(id=wxID_DIVERGENCECREATEDIALOGSEQUENCES,
+ name='Sequences', parent=self.MainPanel, pos=wx.Point(24, 174),
+ size=wx.Size(200, 24), style=0, min=2, max=20)
+ EVT_SPINCTRL(self, wxID_DIVERGENCECREATEDIALOGSEQUENCES, self.OnSequencesChanged)
+
+ self.staticText3 = wx.StaticText(id=wxID_DIVERGENCECREATEDIALOGSTATICTEXT3,
+ label='Preview:', name='staticText3', parent=self.MainPanel,
+ pos=wx.Point(250, 24), size=wx.Size(100, 17), style=0)
+
+ self.Preview = wx.Panel(id=wxID_DIVERGENCECREATEDIALOGPREVIEW,
+ name='Preview', parent=self.MainPanel, pos=wx.Point(250, 48),
+ size=wx.Size(225, 150), style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)
+ self.Preview.SetBackgroundColour(wxColour(255,255,255))
+
+ self._init_sizers()
+
+ def __init__(self, parent):
+ self._init_ctrls(parent)
+ self.ButtonSizer = self.CreateButtonSizer(wxOK|wxCANCEL)
+ self.flexGridSizer1.Add(self.ButtonSizer, 1, wxALIGN_RIGHT)
+
+ self.Divergence = None
+
+ EVT_PAINT(self, self.OnPaint)
+
+ def GetValues(self):
+ values = {}
+ if self.radioButton1.GetValue():
+ values["type"] = SELECTION_DIVERGENCE
+ elif self.radioButton2.GetValue():
+ values["type"] = SELECTION_CONVERGENCE
+ elif self.radioButton3.GetValue():
+ values["type"] = SIMULTANEOUS_DIVERGENCE
+ else:
+ values["type"] = SIMULTANEOUS_CONVERGENCE
+ values["number"] = self.Sequences.GetValue()
+ return values
+
+ def OnTypeChanged(self, event):
+ self.RefreshPreview()
+ event.Skip()
+
+ def OnSequencesChanged(self, event):
+ self.RefreshPreview()
+ event.Skip()
+
+ def RefreshPreview(self):
+ dc = wxClientDC(self.Preview)
+ dc.Clear()
+ if self.radioButton1.GetValue():
+ self.Divergence = SFC_Divergence(self.Preview, SELECTION_DIVERGENCE, self.Sequences.GetValue())
+ elif self.radioButton2.GetValue():
+ self.Divergence = SFC_Divergence(self.Preview, SELECTION_CONVERGENCE, self.Sequences.GetValue())
+ elif self.radioButton3.GetValue():
+ self.Divergence = SFC_Divergence(self.Preview, SIMULTANEOUS_DIVERGENCE, self.Sequences.GetValue())
+ else:
+ self.Divergence = SFC_Divergence(self.Preview, SIMULTANEOUS_CONVERGENCE, self.Sequences.GetValue())
+ width, height = self.Divergence.GetSize()
+ clientsize = self.Preview.GetClientSize()
+ x = (clientsize.width - width) / 2
+ y = (clientsize.height - height) / 2
+ self.Divergence.SetPosition(x, y)
+ self.Divergence.Draw(dc)
+
+ def OnPaint(self, event):
+ self.RefreshPreview()
+
+
+#-------------------------------------------------------------------------------
+# Action Block Dialog
+#-------------------------------------------------------------------------------
+
+class ActionTable(wxPyGridTableBase):
+
+ """
+ A custom wxGrid Table using user supplied data
+ """
+ def __init__(self, parent, data, colnames):
+ # The base class must be initialized *first*
+ wxPyGridTableBase.__init__(self)
+ self.data = data
+ self.colnames = colnames
+ self.Parent = parent
+ # XXX
+ # we need to store the row length and collength to
+ # see if the table has changed size
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+
+ def GetNumberCols(self):
+ return len(self.colnames)
+
+ def GetNumberRows(self):
+ return len(self.data)
+
+ def GetColLabelValue(self, col):
+ if col < len(self.colnames):
+ return self.colnames[col]
+
+ def GetRowLabelValues(self, row):
+ return row
+
+ def GetValue(self, row, col):
+ if row < self.GetNumberRows():
+ name = str(self.data[row].get(self.GetColLabelValue(col), ""))
+ return name
+
+ def GetValueByName(self, row, colname):
+ return self.data[row].get(colname)
+
+ def SetValue(self, row, col, value):
+ if col < len(self.colnames):
+ self.data[row][self.GetColLabelValue(col)] = value
+
+ def ResetView(self, grid):
+ """
+ (wxGrid) -> Reset the grid view. Call this to
+ update the grid if rows and columns have been added or deleted
+ """
+ grid.BeginBatch()
+ for current, new, delmsg, addmsg in [
+ (self._rows, self.GetNumberRows(), wxGRIDTABLE_NOTIFY_ROWS_DELETED, wxGRIDTABLE_NOTIFY_ROWS_APPENDED),
+ (self._cols, self.GetNumberCols(), wxGRIDTABLE_NOTIFY_COLS_DELETED, wxGRIDTABLE_NOTIFY_COLS_APPENDED),
+ ]:
+ if new < current:
+ msg = wxGridTableMessage(self,delmsg,new,current-new)
+ grid.ProcessTableMessage(msg)
+ elif new > current:
+ msg = wxGridTableMessage(self,addmsg,new-current)
+ grid.ProcessTableMessage(msg)
+ self.UpdateValues(grid)
+ grid.EndBatch()
+
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+ # update the column rendering scheme
+ self._updateColAttrs(grid)
+
+ # update the scrollbars and the displayed part of the grid
+ grid.AdjustScrollbars()
+ grid.ForceRefresh()
+
+ def UpdateValues(self, grid):
+ """Update all displayed values"""
+ # This sends an event to the grid table to update all of the values
+ msg = wxGridTableMessage(self, wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)
+ grid.ProcessTableMessage(msg)
+
+ def _updateColAttrs(self, grid):
+ """
+ wxGrid -> update the column attributes to add the
+ appropriate renderer given the column name.
+
+ Otherwise default to the default renderer.
+ """
+
+ for col in range(self.GetNumberCols()):
+ attr = wxGridCellAttr()
+ attr.SetAlignment(self.Parent.ColAlignements[col], wxALIGN_CENTRE)
+ grid.SetColAttr(col, attr)
+ grid.SetColSize(col, self.Parent.ColSizes[col])
+
+ typelist = None
+ accesslist = None
+ for row in range(self.GetNumberRows()):
+ for col in range(self.GetNumberCols()):
+ editor = None
+ renderer = None
+ readonly = False
+ colname = self.GetColLabelValue(col)
+ if colname == "Qualifier":
+ editor = wxGridCellChoiceEditor()
+ editor.SetParameters(self.Parent.QualifierList)
+ if colname == "Duration":
+ editor = wxGridCellTextEditor()
+ renderer = wxGridCellStringRenderer()
+ if self.Parent.DurationList[self.data[row]["Qualifier"]]:
+ readonly = False
+ else:
+ readonly = True
+ self.data[row]["Duration"] = ""
+ elif colname == "Type":
+ editor = wxGridCellChoiceEditor()
+ editor.SetParameters(self.Parent.TypeList)
+ elif colname == "Value":
+ type = self.data[row]["Type"]
+ if type == "Action":
+ editor = wxGridCellChoiceEditor()
+ editor.SetParameters(self.Parent.ActionList)
+ elif type == "Variable":
+ editor = wxGridCellChoiceEditor()
+ editor.SetParameters(self.Parent.VariableList)
+ elif type == "Inline":
+ editor = wxGridCellTextEditor()
+ renderer = wxGridCellStringRenderer()
+ elif colname == "Indicator":
+ editor = wxGridCellChoiceEditor()
+ editor.SetParameters(self.Parent.VariableList)
+
+ grid.SetCellEditor(row, col, editor)
+ grid.SetCellRenderer(row, col, renderer)
+ grid.SetReadOnly(row, col, readonly)
+
+ grid.SetCellBackgroundColour(row, col, wxWHITE)
+
+ def SetData(self, data):
+ self.data = data
+
+ def GetData(self):
+ return self.data
+
+ def GetCurrentIndex(self):
+ return self.CurrentIndex
+
+ def SetCurrentIndex(self, index):
+ self.CurrentIndex = index
+
+ def AppendRow(self, row_content):
+ self.data.append(row_content)
+
+ def RemoveRow(self, row_index):
+ self.data.pop(row_index)
+
+ def MoveRow(self, row_index, move, grid):
+ new_index = max(0, min(row_index + move, len(self.data) - 1))
+ if new_index != row_index:
+ self.data.insert(new_index, self.data.pop(row_index))
+ grid.SetGridCursor(new_index, grid.GetGridCursorCol())
+
+ def Empty(self):
+ self.data = []
+ self.editors = []
+
+[wxID_ACTIONBLOCKDIALOG, wxID_ACTIONBLOCKDIALOGMAINPANEL,
+ wxID_ACTIONBLOCKDIALOGVARIABLESGRID, wxID_ACTIONBLOCKDIALOGSTATICTEXT1,
+ wxID_ACTIONBLOCKDIALOGADDBUTTON,wxID_ACTIONBLOCKDIALOGDELETEBUTTON,
+ wxID_ACTIONBLOCKDIALOGUPBUTTON, wxID_ACTIONBLOCKDIALOGDOWNBUTTON,
+] = [wx.NewId() for _init_ctrls in range(8)]
+
+class ActionBlockDialog(wx.Dialog):
+ def _init_coll_flexGridSizer1_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.MainPanel, 0, border=0, flag=0)
+
+ def _init_sizers(self):
+ # generated method, don't edit
+ self.flexGridSizer1 = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)
+
+ self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)
+
+ self.SetSizer(self.flexGridSizer1)
+
+ def _init_ctrls(self, prnt):
+ # generated method, don't edit
+ wx.Dialog.__init__(self, id=wxID_ACTIONBLOCKDIALOG,
+ name='ActionBlockDialog', parent=prnt, pos=wx.Point(376, 223),
+ size=wx.Size(500, 300), style=wx.DEFAULT_DIALOG_STYLE,
+ title='Edit action block properties')
+ self.SetClientSize(wx.Size(500, 300))
+
+ self.MainPanel = wx.Panel(id=wxID_ACTIONBLOCKDIALOGMAINPANEL,
+ name='MainPanel', parent=self, pos=wx.Point(0, 0),
+ size=wx.Size(500, 300), style=wx.TAB_TRAVERSAL)
+ self.MainPanel.SetAutoLayout(True)
+
+ self.staticText1 = wx.StaticText(id=wxID_ACTIONBLOCKDIALOGSTATICTEXT1,
+ label='Actions:', name='staticText1', parent=self.MainPanel,
+ pos=wx.Point(24, 24), size=wx.Size(95, 17), style=0)
+
+ self.ActionsGrid = wx.grid.Grid(id=wxID_ACTIONBLOCKDIALOGVARIABLESGRID,
+ name='ActionsGrid', parent=self.MainPanel, pos=wx.Point(24, 44),
+ size=wx.Size(450, 150), style=wxVSCROLL)
+ self.ActionsGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,
+ 'Sans'))
+ self.ActionsGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,
+ False, 'Sans'))
+ self.ActionsGrid.DisableDragGridSize()
+ self.ActionsGrid.EnableScrolling(False, True)
+ EVT_GRID_CELL_CHANGE(self.ActionsGrid, self.OnActionsGridCellChange)
+
+ self.AddButton = wx.Button(id=wxID_ACTIONBLOCKDIALOGADDBUTTON, label='Add',
+ name='AddButton', parent=self.MainPanel, pos=wx.Point(245, 204),
+ size=wx.Size(72, 32), style=0)
+ EVT_BUTTON(self, wxID_ACTIONBLOCKDIALOGADDBUTTON, self.OnAddButton)
+
+ self.DeleteButton = wx.Button(id=wxID_ACTIONBLOCKDIALOGDELETEBUTTON, label='Delete',
+ name='DeleteButton', parent=self.MainPanel, pos=wx.Point(325, 204),
+ size=wx.Size(72, 32), style=0)
+ EVT_BUTTON(self, wxID_ACTIONBLOCKDIALOGDELETEBUTTON, self.OnDeleteButton)
+
+ self.UpButton = wx.Button(id=wxID_ACTIONBLOCKDIALOGUPBUTTON, label='^',
+ name='UpButton', parent=self.MainPanel, pos=wx.Point(405, 204),
+ size=wx.Size(32, 32), style=0)
+ EVT_BUTTON(self, wxID_ACTIONBLOCKDIALOGUPBUTTON, self.OnUpButton)
+
+ self.DownButton = wx.Button(id=wxID_ACTIONBLOCKDIALOGDOWNBUTTON, label='v',
+ name='DownButton', parent=self.MainPanel, pos=wx.Point(445, 204),
+ size=wx.Size(32, 32), style=0)
+ EVT_BUTTON(self, wxID_ACTIONBLOCKDIALOGDOWNBUTTON, self.OnDownButton)
+
+ self._init_sizers()
+
+ def __init__(self, parent):
+ self._init_ctrls(parent)
+ self.ButtonSizer = self.CreateButtonSizer(wxOK|wxCANCEL)
+ self.flexGridSizer1.Add(self.ButtonSizer, 1, wxALIGN_RIGHT)
+
+ self.DefaultValue = {"Qualifier" : "N", "Duration" : "", "Type" : "Action", "Value" : "", "Indicator" : ""}
+ self.Table = ActionTable(self, [], ["Qualifier","Duration","Type","Value","Indicator"])
+ self.TypeList = "Action,Variable,Inline"
+ self.ColSizes = [60, 90, 80, 110, 80]
+ self.ColAlignements = [wxALIGN_LEFT, wxALIGN_LEFT, wxALIGN_LEFT, wxALIGN_LEFT, wxALIGN_LEFT]
+
+ self.ActionsGrid.SetTable(self.Table)
+ self.ActionsGrid.SetRowLabelSize(0)
+
+ self.Table.ResetView(self.ActionsGrid)
+
+ def OnAddButton(self, event):
+ self.Table.AppendRow(self.DefaultValue.copy())
+ self.Table.ResetView(self.ActionsGrid)
+ event.Skip()
+
+ def OnDeleteButton(self, event):
+ row = self.ActionsGrid.GetGridCursorRow()
+ self.Table.RemoveRow(row)
+ self.Table.ResetView(self.ActionsGrid)
+ event.Skip()
+
+ def OnUpButton(self, event):
+ row = self.ActionsGrid.GetGridCursorRow()
+ self.Table.MoveRow(row, -1, self.ActionsGrid)
+ self.Table.ResetView(self.ActionsGrid)
+ event.Skip()
+
+ def OnDownButton(self, event):
+ row = self.ActionsGrid.GetGridCursorRow()
+ self.Table.MoveRow(row, 1, self.ActionsGrid)
+ self.Table.ResetView(self.ActionsGrid)
+ event.Skip()
+
+ def OnActionsGridCellChange(self, event):
+ self.Table.ResetView(self.ActionsGrid)
+ event.Skip()
+
+ def SetQualifierList(self, list):
+ self.QualifierList = ""
+ sep = ""
+ for qualifier in list.keys():
+ self.QualifierList += "%s%s"%(sep, qualifier)
+ sep = ","
+ self.DurationList = list
+
+ def SetVariableList(self, list):
+ self.VariableList = ""
+ sep = ""
+ for variable in list:
+ self.VariableList += "%s%s"%(sep, variable["Name"])
+ sep = ","
+
+ def SetActionList(self, list):
+ self.ActionList = ""
+ sep = ""
+ for action in list:
+ self.ActionList += "%s%s"%(sep, action)
+ sep = ","
+
+ def SetValues(self, actions):
+ for action in actions:
+ row = {"Qualifier" : action["qualifier"], "Value" : action["value"],
+ "Indicator" : action["indicator"]}
+ if action["type"] == "reference":
+ if action["value"] in self.ActionList:
+ row["Type"] = "Action"
+ elif action["value"] in self.VariableList:
+ row["Type"] = "Variable"
+ else:
+ row["Type"] = "Inline"
+ else:
+ row["Type"] = "Inline"
+ if "duration" in action:
+ row["Duration"] = action["duration"]
+ self.Table.AppendRow(row)
+ self.Table.ResetView(self.ActionsGrid)
+
+ def GetValues(self):
+ values = []
+ for data in self.Table.GetData():
+ action = {"qualifier" : data["Qualifier"], "value" : data["Value"],
+ "indicator" : data["Indicator"]}
+ if data["Type"] in ["Action", "Variable"]:
+ action["type"] = "reference"
+ else:
+ action["type"] = "inline"
+ if data["Duration"] != "":
+ action["duration"] = data["Duration"]
+ values.append(action)
+ return values