plcopeneditor_history: comparison Viewer.py

equal deleted inserted replaced

-:04a02b4b2a57
+:dd6f693e46a1
 #
 #You should have received a copy of the GNU 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 *
 import wx
 from plcopen.structures import *
 from Dialogs import *
 #-------------------------------------------------------------------------------
 #                       Graphic elements Viewer base class
 #-------------------------------------------------------------------------------
 # ID Constants for menu items
-[wxID_FBDVIEWERCONTEXTUALMENUITEMS0, wxID_FBDVIEWERCONTEXTUALMENUITEMS1,
+[ID_FBDVIEWERCONTEXTUALMENUITEMS0, ID_FBDVIEWERCONTEXTUALMENUITEMS1,
-wxID_FBDVIEWERCONTEXTUALMENUITEMS2, wxID_FBDVIEWERCONTEXTUALMENUITEMS3,
+ID_FBDVIEWERCONTEXTUALMENUITEMS2, ID_FBDVIEWERCONTEXTUALMENUITEMS3,
-wxID_FBDVIEWERCONTEXTUALMENUITEMS5, wxID_FBDVIEWERCONTEXTUALMENUITEMS6,
+ID_FBDVIEWERCONTEXTUALMENUITEMS5, ID_FBDVIEWERCONTEXTUALMENUITEMS6,
-wxID_FBDVIEWERCONTEXTUALMENUITEMS8, wxID_FBDVIEWERCONTEXTUALMENUITEMS9,
+ID_FBDVIEWERCONTEXTUALMENUITEMS8, ID_FBDVIEWERCONTEXTUALMENUITEMS9,
-wxID_FBDVIEWERCONTEXTUALMENUITEMS11,
+ID_FBDVIEWERCONTEXTUALMENUITEMS11,
 ] = [wx.NewId() for _init_coll_ContextualMenu_Items in range(9)]
 class ViewerDropTarget(wx.TextDropTarget):
 self.Parent.RefreshScrollBars()
 self.Parent.Refresh()
 """
-Class that implements a Viewer based on a wxScrolledWindow for drawing and
+Class that implements a Viewer based on a wx.ScrolledWindow for drawing and
 manipulating graphic elements
 """
 class Viewer(wx.ScrolledWindow):
 # Create Contextual Menu items
 def _init_coll_ContextualMenu_Items(self, parent):
 # Create menu items
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS0,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS0,
 kind=wx.ITEM_RADIO, text=u'No Modifier')
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS1,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS1,
 kind=wx.ITEM_RADIO, text=u'Negated')
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS2,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS2,
 kind=wx.ITEM_RADIO, text=u'Rising Edge')
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS3,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS3,
 kind=wx.ITEM_RADIO, text=u'Falling Edge')
 parent.AppendSeparator()
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS5,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS5,
 kind=wx.ITEM_NORMAL, text=u'Add Wire Segment')
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS6,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS6,
 kind=wx.ITEM_NORMAL, text=u'Delete Wire Segment')
 parent.AppendSeparator()
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS8,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS8,
 kind=wx.ITEM_NORMAL, text=u'Add Divergence Branch')
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS9,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS9,
 kind=wx.ITEM_NORMAL, text=u'Delete Divergence Branch')
 parent.AppendSeparator()
-parent.Append(help='', id=wxID_FBDVIEWERCONTEXTUALMENUITEMS11,
+parent.Append(help='', id=ID_FBDVIEWERCONTEXTUALMENUITEMS11,
 kind=wx.ITEM_NORMAL, text=u'Delete')
 # Link menu event to corresponding called functions
 self.Bind(wx.EVT_MENU, self.OnNoModifierMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS0)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS0)
 self.Bind(wx.EVT_MENU, self.OnNegatedMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS1)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS1)
 self.Bind(wx.EVT_MENU, self.OnRisingEdgeMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS2)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS2)
 self.Bind(wx.EVT_MENU, self.OnFallingEdgeMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS3)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS3)
 self.Bind(wx.EVT_MENU, self.OnAddSegmentMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS5)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS5)
 self.Bind(wx.EVT_MENU, self.OnDeleteSegmentMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS6)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS6)
 self.Bind(wx.EVT_MENU, self.OnAddBranchMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS8)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS8)
 self.Bind(wx.EVT_MENU, self.OnDeleteBranchMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS9)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS9)
 self.Bind(wx.EVT_MENU, self.OnDeleteMenu,
-id=wxID_FBDVIEWERCONTEXTUALMENUITEMS11)
+id=ID_FBDVIEWERCONTEXTUALMENUITEMS11)
 # Create and initialize Contextual Menu
 def _init_menus(self):
 self.ContextualMenu = wx.Menu(title='')
 def __init__(self, parent, window, controler):
 wx.ScrolledWindow.__init__(self, parent, style=wx.SUNKEN_BORDER | wx.HSCROLL | wx.VSCROLL)
 self._init_menus()
 # Adding a rubberband to Viewer
 self.rubberBand = RubberBand(drawingSurface=self)
-self.SetBackgroundColour(wxColour(255,255,255))
+self.SetBackgroundColour(wx.Colour(255,255,255))
 self.ResetView()
 self.Scaling = None
 #self.Scaling = (8, 8)
 self.DrawGrid = True
 self.current_id = 0
 self.Controler = controler
 self.SetDropTarget(ViewerDropTarget(self))
 # Link Viewer event to corresponding methods
-EVT_PAINT(self, self.OnPaint)
+self.Bind(wx.EVT_PAINT, self.OnPaint)
-EVT_LEFT_DOWN(self, self.OnViewerLeftDown)
+self.Bind(wx.EVT_LEFT_DOWN, self.OnViewerLeftDown)
-EVT_LEFT_UP(self, self.OnViewerLeftUp)
+self.Bind(wx.EVT_LEFT_UP, self.OnViewerLeftUp)
-EVT_LEFT_DCLICK(self, self.OnViewerLeftDClick)
+self.Bind(wx.EVT_LEFT_DCLICK, self.OnViewerLeftDClick)
-EVT_RIGHT_UP(self, self.OnViewerRightUp)
+self.Bind(wx.EVT_RIGHT_UP, self.OnViewerRightUp)
-EVT_MOTION(self, self.OnViewerMotion)
+self.Bind(wx.EVT_MOTION, self.OnViewerMotion)
-EVT_CHAR(self, self.OnChar)
+self.Bind(wx.EVT_CHAR, self.OnChar)
-EVT_SCROLLWIN(self, self.OnMoveWindow)
+self.Bind(wx.EVT_SCROLLWIN, self.OnMoveWindow)
-EVT_SIZE(self, self.OnMoveWindow)
+self.Bind(wx.EVT_SIZE, self.OnMoveWindow)
 # Returns a new id
 def GetNewId(self):
 self.current_id += 1
 return self.current_id
 # Destructor
 def __del__(self):
 self.ResetView()
 def GetLogicalDC(self):
-dc = wxClientDC(self)
+dc = wx.ClientDC(self)
 self.DoPrepareDC(dc)
 return dc
 #-------------------------------------------------------------------------------
 #                         Element management functions
 variable = FBD_Variable(self, INPUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
 self.AddBlock(variable)
 connectors = variable.GetConnectors()
-connectors["output"].SetPosition(wxPoint(*instance["connector"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connector"]["position"]))
 if instance["connector"]["negated"]:
 connectors["output"].SetNegated(True)
 if instance["connector"]["edge"]:
 connectors["output"].SetEdge(instance["connector"]["edge"])
 elif instance["type"] == "output":
 variable = FBD_Variable(self, OUTPUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
 self.AddBlock(variable)
 connectors = variable.GetConnectors()
-connectors["input"].SetPosition(wxPoint(*instance["connector"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connector"]["position"]))
 if instance["connector"]["negated"]:
 connectors["input"].SetNegated(True)
 if instance["connector"]["edge"]:
 connectors["input"].SetEdge(instance["connector"]["edge"])
 self.CreateWires(connectors["input"], instance["connector"]["links"], ids)
 variable = FBD_Variable(self, INOUT, instance["name"], instance["value_type"], instance["id"])
 variable.SetPosition(instance["x"], instance["y"])
 variable.SetSize(instance["width"], instance["height"])
 self.AddBlock(variable)
 connectors = variable.GetConnectors()
-connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))
-connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))
 if instance["connectors"]["output"]["negated"]:
 connectors["output"].SetNegated(True)
 if instance["connectors"]["output"]["edge"]:
 connectors["output"].SetEdge(instance["connectors"]["output"]["edge"])
 if instance["connectors"]["input"]["negated"]:
 connection = FBD_Connector(self, CONTINUATION, instance["name"], instance["id"])
 connection.SetPosition(instance["x"], instance["y"])
 connection.SetSize(instance["width"], instance["height"])
 self.AddBlock(connection)
 connector = connection.GetConnector()
-connector.SetPosition(wxPoint(*instance["connector"]["position"]))
+connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 elif instance["type"] == "connection":
 connection = FBD_Connector(self, CONNECTOR, instance["name"], instance["id"])
 connection.SetPosition(instance["x"], instance["y"])
 connection.SetSize(instance["width"], instance["height"])
 self.AddBlock(connection)
 connector = connection.GetConnector()
-connector.SetPosition(wxPoint(*instance["connector"]["position"]))
+connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 elif instance["type"] == "comment":
 comment = Comment(self, instance["content"], instance["id"])
 comment.SetPosition(instance["x"], instance["y"])
 comment.SetSize(instance["width"], instance["height"])
 leftpowerrail = LD_PowerRail(self, LEFTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])
 leftpowerrail.SetPosition(instance["x"], instance["y"])
 self.AddBlock(leftpowerrail)
 connectors = leftpowerrail.GetConnectors()
 for i, connector in enumerate(instance["connectors"]):
-connectors[i].SetPosition(wxPoint(*connector["position"]))
+connectors[i].SetPosition(wx.Point(*connector["position"]))
 elif instance["type"] == "rightPowerRail":
 rightpowerrail = LD_PowerRail(self, RIGHTRAIL, instance["id"], [True for i in range(len(instance["connectors"]))])
 rightpowerrail.SetPosition(instance["x"], instance["y"])
 self.AddBlock(rightpowerrail)
 connectors = rightpowerrail.GetConnectors()
 for i, connector in enumerate(instance["connectors"]):
-connectors[i].SetPosition(wxPoint(*connector["position"]))
+connectors[i].SetPosition(wx.Point(*connector["position"]))
 self.CreateWires(connectors[i], connector["links"], ids)
 elif instance["type"] == "contact":
 if instance["negated"]:
 negated = instance["negated"]
 else:
 contact_type = CONTACT_NORMAL
 contact = LD_Contact(self, contact_type, instance["name"], instance["id"])
 contact.SetPosition(instance["x"], instance["y"])
 self.AddBlock(contact)
 connectors = contact.GetConnectors()
-connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
-connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))
 elif instance["type"] == "coil":
 if instance["negated"]:
 negated = instance["negated"]
 else:
 negated = False
 coil_type = COIL_NORMAL
 coil = LD_Coil(self, coil_type, instance["name"], instance["id"])
 coil.SetPosition(instance["x"], instance["y"])
 self.AddBlock(coil)
 connectors = coil.GetConnectors()
-connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
-connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))
 elif instance["type"] == "step":
 if instance["initial"]:
 initial = instance["initial"]
 else:
 initial = False
 step.AddOutput()
 if "action" in instance["connectors"]:
 step.AddAction()
 connectors = step.GetConnectors()
 if connectors["input"]:
-connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
 if connectors["output"]:
-connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))
 if connectors["action"]:
-connectors["action"].SetPosition(wxPoint(*instance["connectors"]["action"]["position"]))
+connectors["action"].SetPosition(wx.Point(*instance["connectors"]["action"]["position"]))
 elif instance["type"] == "transition":
 transition = SFC_Transition(self, instance["condition_type"], instance["condition"], instance["id"])
 transition.SetPosition(instance["x"], instance["y"])
 self.AddBlock(transition)
 connectors = transition.GetConnectors()
-connectors["input"].SetPosition(wxPoint(*instance["connectors"]["input"]["position"]))
+connectors["input"].SetPosition(wx.Point(*instance["connectors"]["input"]["position"]))
 self.CreateWires(connectors["input"], instance["connectors"]["input"]["links"], ids)
-connectors["output"].SetPosition(wxPoint(*instance["connectors"]["output"]["position"]))
+connectors["output"].SetPosition(wx.Point(*instance["connectors"]["output"]["position"]))
+if instance["condition_type"] == "connection":
+self.CreateWires(connectors["connection"], instance["connectors"]["connection"]["links"], ids)
 elif instance["type"] in ["selectionDivergence", "selectionConvergence", "simultaneousDivergence", "simultaneousConvergence"]:
 if instance["type"] == "selectionDivergence":
 divergence = SFC_Divergence(self, SELECTION_DIVERGENCE,
 len(instance["connectors"]["outputs"]), instance["id"])
 elif instance["type"] == "selectionConvergence":
 divergence.SetSize(instance["width"], instance["height"])
 self.AddBlock(divergence)
 connectors = divergence.GetConnectors()
 for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 connector = connectors["inputs"][i]
-connector.SetPosition(wxPoint(*input_connector["position"]))
+connector.SetPosition(wx.Point(*input_connector["position"]))
 self.CreateWires(connector, input_connector["links"], ids)
 for i, output_connector in enumerate(instance["connectors"]["outputs"]):
 connector = connectors["outputs"][i]
-connector.SetPosition(wxPoint(*output_connector["position"]))
+connector.SetPosition(wx.Point(*output_connector["position"]))
 elif instance["type"] == "jump":
 jump = SFC_Jump(self, instance["target"], instance["id"])
 jump.SetPosition(instance["x"], instance["y"])
 self.AddBlock(jump)
 connector = jump.GetConnector()
-connector.SetPosition(wxPoint(*instance["connector"]["position"]))
+connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 elif instance["type"] == "actionBlock":
 actionBlock = SFC_ActionBlock(self, instance["actions"], instance["id"])
 actionBlock.SetPosition(instance["x"], instance["y"])
 actionBlock.SetSize(instance["width"], instance["height"])
 self.AddBlock(actionBlock)
 connector = actionBlock.GetConnector()
-connector.SetPosition(wxPoint(*instance["connector"]["position"]))
+connector.SetPosition(wx.Point(*instance["connector"]["position"]))
 self.CreateWires(connector, instance["connector"]["links"], ids)
 else:
 if instance["name"] != None:
 block = FBD_Block(self, instance["type"], instance["name"], instance["id"], len(instance["connectors"]["inputs"]))
 else:
 block.SetSize(instance["width"], instance["height"])
 self.AddBlock(block)
 connectors = block.GetConnectors()
 for i, input_connector in enumerate(instance["connectors"]["inputs"]):
 connector = connectors["inputs"][i]
-connector.SetPosition(wxPoint(*input_connector["position"]))
+connector.SetPosition(wx.Point(*input_connector["position"]))
 if input_connector["negated"]:
 connector.SetNegated(True)
 if input_connector["edge"]:
 connector.SetEdge(input_connector["edge"])
 self.CreateWires(connector, input_connector["links"], ids)
 connector = connectors["outputs"][i]
 if output_connector["negated"]:
 connector.SetNegated(True)
 if output_connector["edge"]:
 connector.SetEdge(output_connector["edge"])
-connector.SetPosition(wxPoint(*output_connector["position"]))
+connector.SetPosition(wx.Point(*output_connector["position"]))
 def CreateWires(self, start_connector, links, ids):
 for link in links:
 refLocalId = link["refLocalId"]
 if refLocalId != None:
 if new_instance:
 self.loadInstance(new_instance, ids)
 connected = self.FindElementById(refLocalId)
 if connected:
 points = link["points"]
-end_connector = connected.GetConnector(wxPoint(points[-1][0], points[-1][1]), link["formalParameter"])
+end_connector = connected.GetConnector(wx.Point(points[-1][0], points[-1][1]), link["formalParameter"])
 if end_connector:
 wire = Wire(self)
 wire.SetPoints(points)
 start_connector.Connect((wire, 0), False)
 end_connector.Connect((wire, -1), False)
 self.ContextualMenu.FindItemByPosition(8).Enable(False)
 self.ContextualMenu.FindItemByPosition(9).Enable(False)
 self.PopupMenu(self.ContextualMenu)
 def EditCommentContent(self, comment):
-dialog = wxTextEntryDialog(self.Parent, "Edit comment", "Please enter comment text", comment.GetContent(), wxOK|wxCANCEL|wxTE_MULTILINE)
+dialog = wx.TextEntryDialog(self.Parent, "Edit comment", "Please enter comment text", comment.GetContent(), wx.OK|wx.CANCEL|wx.TE_MULTILINE)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 value = dialog.GetValue()
 comment.SetContent(value)
 infos = {"content" : value}
 infos["width"], infos["height"] = comment.GetSize()
 self.Controler.SetCurrentElementEditingCommentInfos(comment.GetId(), infos)
 elif self.Mode == MODE_WIRE:
 pos = GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling)
 connector = self.FindBlockConnector(pos)
 if connector:
 if (connector.GetDirection() == EAST):
-wire = Wire(self, [wxPoint(pos.x, pos.y), EAST], [wxPoint(pos.x, pos.y), WEST])
+wire = Wire(self, [wx.Point(pos.x, pos.y), EAST], [wx.Point(pos.x, pos.y), WEST])
 else:
-wire = Wire(self, [wxPoint(pos.x, pos.y), WEST], [wxPoint(pos.x, pos.y), EAST])
+wire = Wire(self, [wx.Point(pos.x, pos.y), WEST], [wx.Point(pos.x, pos.y), EAST])
 wire.oldPos = pos
 wire.Handle = (HANDLE_POINT, 0)
 wire.ProcessDragging(0, 0)
 wire.Handle = (HANDLE_POINT, 1)
 self.AddWire(wire)
 self.Refresh()
 else:
 bbox = self.rubberBand.GetCurrentExtent()
 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
 if self.Mode == MODE_BLOCK:
-wxCallAfter(self.AddNewBlock, bbox)
+wx.CallAfter(self.AddNewBlock, bbox)
 elif self.Mode == MODE_VARIABLE:
-wxCallAfter(self.AddNewVariable, bbox)
+wx.CallAfter(self.AddNewVariable, bbox)
 elif self.Mode == MODE_CONNECTION:
-wxCallAfter(self.AddNewConnection, bbox)
+wx.CallAfter(self.AddNewConnection, bbox)
 elif self.Mode == MODE_COMMENT:
-wxCallAfter(self.AddNewComment, bbox)
+wx.CallAfter(self.AddNewComment, bbox)
 elif self.Mode == MODE_CONTACT:
-wxCallAfter(self.AddNewContact, bbox)
+wx.CallAfter(self.AddNewContact, bbox)
 elif self.Mode == MODE_COIL:
-wxCallAfter(self.AddNewContact, bbox)
+wx.CallAfter(self.AddNewContact, bbox)
 elif self.Mode == MODE_POWERRAIL:
-wxCallAfter(self.AddNewPowerRail, bbox)
+wx.CallAfter(self.AddNewPowerRail, bbox)
 elif self.Mode == MODE_INITIALSTEP:
-wxCallAfter(self.AddNewInitialStep, bbox)
+wx.CallAfter(self.AddNewInitialStep, bbox)
 elif self.Mode == MODE_STEP:
-wxCallAfter(self.AddNewStep, bbox)
+wx.CallAfter(self.AddNewStep, bbox)
 elif self.Mode == MODE_TRANSITION:
-wxCallAfter(self.AddNewTransition, bbox)
+wx.CallAfter(self.AddNewTransition, bbox)
 elif self.Mode == MODE_DIVERGENCE:
-wxCallAfter(self.AddNewDivergence, bbox)
+wx.CallAfter(self.AddNewDivergence, bbox)
 elif self.Mode == MODE_JUMP:
-wxCallAfter(self.AddNewJump, bbox)
+wx.CallAfter(self.AddNewJump, bbox)
 elif self.Mode == MODE_ACTION:
-wxCallAfter(self.AddNewActionBlock, bbox)
+wx.CallAfter(self.AddNewActionBlock, bbox)
 elif self.Mode == MODE_SELECTION and self.SelectedElement:
 self.SelectedElement.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
-wxCallAfter(self.SetCursor, wxNullCursor)
+wx.CallAfter(self.SetCursor, wx.NullCursor)
 self.ReleaseMouse()
 self.Refresh()
 elif self.Mode == MODE_WIRE and self.SelectedElement:
 if self.SelectedElement.EndConnected != None:
 self.SelectedElement.ResetPoints()
 else:
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.Refresh()
 if not self.SavedMode:
-wxCallAfter(self.Parent.ResetCurrentMode)
+wx.CallAfter(self.Parent.ResetCurrentMode)
 event.Skip()
 def OnViewerRightUp(self, event):
 pos = event.GetPosition()
 element = self.FindElement(pos)
 if self.SelectedElement and self.SelectedElement != element:
 self.SelectedElement.SetSelected(False)
 self.SelectedElement = element
 self.SelectedElement.SetSelected(True)
 self.SelectedElement.OnRightUp(event, self.GetLogicalDC(), self.Scaling)
-wxCallAfter(self.SetCursor, wxNullCursor)
+wx.CallAfter(self.SetCursor, wx.NullCursor)
 self.ReleaseMouse()
 self.Refresh()
 event.Skip()
 def OnViewerLeftDClick(self, event):
 self.SelectedElement.OnMotion(event, dc, self.Scaling)
 self.SelectedElement.GeneratePoints()
 self.Refresh()
 if (event.Dragging() and self.SelectedElement) or self.rubberBand.IsShown():
 position = event.GetPosition()
-move_window = wxPoint()
+move_window = wx.Point()
 window_size = self.GetClientSize()
 xstart, ystart = self.GetViewStart()
 if position.x < SCROLL_ZONE and xstart > 0:
 move_window.x = -1
 elif position.x > window_size[0] - SCROLL_ZONE:
 #-------------------------------------------------------------------------------
 #                          Keyboard event functions
 #-------------------------------------------------------------------------------
 def OnChar(self, event):
-xpos, ypos = self.GetScrollPos(wxHORIZONTAL), self.GetScrollPos(wxVERTICAL)
+xpos, ypos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)
-xmax = self.GetScrollRange(wxHORIZONTAL) - self.GetScrollThumb(wxHORIZONTAL)
+xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)
-ymax = self.GetScrollRange(wxVERTICAL) - self.GetScrollThumb(wxVERTICAL)
+ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)
 keycode = event.GetKeyCode()
 if self.Scaling:
 scaling = self.Scaling
 else:
 scaling = (8, 8)
-if keycode == WXK_DELETE and self.SelectedElement:
+if keycode == wx.WXK_DELETE and self.SelectedElement:
 self.SelectedElement.Clean()
 self.SelectedElement.Delete()
 self.SelectedElement = None
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
-elif keycode == WXK_LEFT:
+elif keycode == wx.WXK_LEFT:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(0, ypos)
 elif event.ControlDown():
 self.Scroll(max(0, xpos - 1), ypos)
 elif self.SelectedElement:
 self.SelectedElement.Move(-scaling[0], 0)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
-elif keycode == WXK_RIGHT:
+elif keycode == wx.WXK_RIGHT:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xmax, ypos)
 elif event.ControlDown():
 self.Scroll(min(xpos + 1, xmax), ypos)
 elif self.SelectedElement:
 self.SelectedElement.Move(scaling[0], 0)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
-elif keycode == WXK_UP:
+elif keycode == wx.WXK_UP:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xpos, 0)
 elif event.ControlDown():
 self.Scroll(xpos, max(0, ypos - 1))
 elif self.SelectedElement:
 self.SelectedElement.Move(0, -scaling[1])
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
-elif keycode == WXK_DOWN:
+elif keycode == wx.WXK_DOWN:
 if event.ControlDown() and event.ShiftDown():
 self.Scroll(xpos, ymax)
 elif event.ControlDown():
 self.Scroll(xpos, min(ypos + 1, ymax))
 elif self.SelectedElement:
 def AddNewBlock(self, bbox):
 dialog = BlockPropertiesDialog(self.Parent)
 dialog.SetBlockList(self.Controler.GetBlockTypes())
 dialog.SetMinBlockSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 if "name" in values:
 block = FBD_Block(self, values["type"], values["name"], id, values["extension"], values["inputs"])
 else:
 varlist.append((var["Name"], var["Class"], var["Type"]))
 returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()
 if returntype:
 varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))
 dialog.SetVariables(varlist)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)
 variable.SetPosition(bbox.x, bbox.y)
 variable.SetSize(values["width"], values["height"])
 dialog.Destroy()
 def AddNewConnection(self, bbox):
 dialog = ConnectionPropertiesDialog(self.Parent)
 dialog.SetMinConnectionSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 connection = FBD_Connector(self, values["type"], values["name"], id)
 connection.SetPosition(bbox.x, bbox.y)
 connection.SetSize(values["width"], values["height"])
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def AddNewComment(self, bbox):
-dialog = wxTextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wxOK|wxCANCEL|wxTE_MULTILINE)
+dialog = wx.TextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wx.OK|wx.CANCEL|wx.TE_MULTILINE)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 value = dialog.GetValue()
 id = self.GetNewId()
 comment = Comment(self, value, id)
 comment.SetPosition(bbox.x, bbox.y)
 min_width, min_height = comment.GetMinSize()
 if var["Class"] != "Output" and var["Type"] == "BOOL":
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 dialog.SetValues({"name":"","type":CONTACT_NORMAL})
 dialog.SetElementSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 contact = LD_Contact(self, values["type"], values["name"], id)
 contact.SetPosition(bbox.x, bbox.y)
 contact.SetSize(values["width"], values["height"])
 if returntype == "BOOL":
 varlist.append(self.Controler.GetCurrentElementEditingName())
 dialog.SetVariables(varlist)
 dialog.SetValues({"name":"","type":COIL_NORMAL})
 dialog.SetElementSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 coil = LD_Coil(self, values["type"], values["name"], id)
 coil.SetPosition(bbox.x, bbox.y)
 coil.SetSize(values["width"], values["height"])
 dialog.Destroy()
 def AddNewPowerRail(self, bbox):
 dialog = LDPowerRailDialog(self.Parent)
 dialog.SetMinSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])
 powerrail.SetPosition(bbox.x, bbox.y)
 powerrail.SetSize(values["width"], values["height"])
 dialog.Destroy()
 def AddNewTransition(self, bbox):
 dialog = TransitionContentDialog(self.Parent)
 dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 transition = SFC_Transition(self, values["type"], values["value"], id)
 transition.SetPosition(bbox.x, bbox.y)
 min_width, min_height = transition.GetMinSize()
 dialog.Destroy()
 def AddNewDivergence(self, bbox):
 dialog = DivergenceCreateDialog(self.Parent)
 dialog.SetMinSize((bbox.width, bbox.height))
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 id = self.GetNewId()
 values = dialog.GetValues()
 divergence = SFC_Divergence(self, values["type"], values["number"], id)
 divergence.SetPosition(bbox.x, bbox.y)
 min_width, min_height = divergence.GetMinSize()
 dialog.SetBlockList(self.Controler.GetBlockTypes())
 dialog.SetMinBlockSize(block.GetSize())
 values = {"name" : block.GetName(), "type" : block.GetType(), "inputs" : block.GetInputTypes()}
 values["extension"] = block.GetExtension()
 dialog.SetValues(values)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 if "name" in values:
 block.SetName(values["name"])
 block.SetSize(values["width"], values["height"])
 block.SetType(values["type"], values["extension"])
 if returntype:
 varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))
 dialog.SetVariables(varlist)
 values = {"name" : variable.GetName(), "type" : variable.GetType()}
 dialog.SetValues(values)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 old_type = variable.GetType()
 values = dialog.GetValues()
 variable.SetName(values["name"])
 variable.SetType(values["type"], values["value_type"])
 variable.SetSize(values["width"], values["height"])
 def EditConnectionContent(self, connection):
 dialog = ConnectionPropertiesDialog(self.Parent)
 dialog.SetMinConnectionSize(connection.GetSize())
 values = {"name" : connection.GetName(), "type" : connection.GetType()}
 dialog.SetValues(values)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 old_type = connection.GetType()
 values = dialog.GetValues()
 connection.SetName(values["name"])
 connection.SetType(values["type"])
 connection.SetSize(values["width"], values["height"])
 varlist.append(var["Name"])
 dialog.SetVariables(varlist)
 values = {"name" : contact.GetName(), "type" : contact.GetType()}
 dialog.SetValues(values)
 dialog.SetElementSize(contact.GetSize())
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 contact.SetName(values["name"])
 contact.SetType(values["type"])
 contact.SetSize(values["width"], values["height"])
 self.RefreshContactModel(contact)
 varlist.append(self.Controler.GetCurrentElementEditingName())
 dialog.SetVariables(varlist)
 values = {"name" : coil.GetName(), "type" : coil.GetType()}
 dialog.SetValues(values)
 dialog.SetElementSize(coil.GetSize())
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 coil.SetName(values["name"])
 coil.SetType(values["type"])
 coil.SetSize(values["width"], values["height"])
-self.RefreshContactModel(coil)
+self.RefreshCoilModel(coil)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditPowerRailContent(self, powerrail):
 dialog = LDPowerRailDialog(self.Parent, powerrail.GetType(), len(powerrail.GetConnectors()))
 dialog.SetMinSize(powerrail.GetSize())
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 old_type = powerrail.GetType()
 values = dialog.GetValues()
 powerrail.SetType(values["type"], [True for i in xrange(values["number"])])
 powerrail.SetSize(values["width"], values["height"])
 if old_type != values["type"]:
 self.RefreshPowerRailModel(powerrail)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
-##
-##
-##    def AddNewTransition(self, bbox):
+def EditTransitionContent(self, transition):
-##        dialog = TransitionContentDialog(self.Parent)
+dialog = TransitionContentDialog(self.Parent, self.GetDrawingMode() == FREEDRAWING_MODE)
-##        dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
+dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())
-##        if dialog.ShowModal() == wxID_OK:
+dialog.SetValues({"type":transition.GetType(),"value":transition.GetCondition()})
-##            id = self.GetNewId()
+dialog.SetElementSize(transition.GetSize())
-##            values = dialog.GetValues()
+if dialog.ShowModal() == wx.ID_OK:
-##            transition = SFC_Transition(self, values["type"], values["value"], id)
+values = dialog.GetValues()
-##            transition.SetPosition(bbox.x, bbox.y)
+transition.SetType(values["type"],values["value"])
-##            min_width, min_height = transition.GetMinSize()
+transition.RefreshModel()
-##            transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
+self.RefreshBuffer()
-##            self.Blocks.append(transition)
+self.RefreshScrollBars()
-##            self.Elements.append(transition)
+self.Refresh()
-##            self.Controler.AddCurrentElementEditingTransition(id)
+dialog.Destroy()
-##            self.RefreshTransitionModel(transition)
-##            self.RefreshScrollBars()
+def EditJumpContent(self, jump):
-##            self.Refresh()
+choices = []
-##        dialog.Destroy()
+for block in self.Blocks:
-##
+if isinstance(block, SFC_Step):
-##    def AddNewDivergence(self, bbox):
+choices.append(block.GetName())
-##        dialog = DivergenceCreateDialog(self.Parent)
+dialog = wx.SingleChoiceDialog(self.Parent, "Edit jump target", "Please choose a target", choices, wx.OK|wx.CANCEL)
-##        dialog.SetMinSize((bbox.width, bbox.height))
+dialog.SetSelection(choices.index(jump.GetTarget()))
-##        if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
-##            id = self.GetNewId()
+value = dialog.GetStringSelection()
-##            values = dialog.GetValues()
+jump.SetTarget(value)
-##            divergence = SFC_Divergence(self, values["type"], values["number"], id)
+jump.RefreshModel()
-##            divergence.SetPosition(bbox.x, bbox.y)
+self.RefreshBuffer()
-##            min_width, min_height = divergence.GetMinSize()
+self.RefreshScrollBars()
-##            divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))
+self.Refresh()
-##            self.Blocks.append(divergence)
+dialog.Destroy()
-##            self.Elements.append(divergence)
-##            self.Controler.AddCurrentElementEditingDivergence(id, values["type"])
+def EditActionBlockContent(self, actionblock):
-##            self.RefreshDivergenceModel(divergence)
+dialog = ActionBlockDialog(self.Parent)
-##            self.RefreshScrollBars()
+dialog.SetQualifierList(self.Controler.GetQualifierTypes())
-##            self.Refresh()
+dialog.SetActionList(self.Controler.GetCurrentElementEditingActions())
-##        dialog.Destroy()
+dialog.SetVariableList(self.Controler.GetCurrentElementEditingInterfaceVars())
+dialog.SetValues(actionblock.GetActions())
+if dialog.ShowModal() == wx.ID_OK:
+actions = dialog.GetValues()
+actionblock.SetActions(actions)
+actionblock.RefreshModel()
+self.RefreshBuffer()
+self.RefreshScrollBars()
+self.Refresh()
+dialog.Destroy()
 #-------------------------------------------------------------------------------
 #                          Model update functions
 #-------------------------------------------------------------------------------
 event.Skip()
 def OnPaint(self, event):
 dc = self.GetLogicalDC()
 dc.Clear()
-dc.SetPen(wxPen(wxColour(230, 230, 230)))
+dc.SetPen(wx.Pen(wx.Colour(230, 230, 230)))
 if self.Scaling and self.DrawGrid:
 width, height = dc.GetSize()
 for i in xrange(1, width / self.Scaling[0] + 1):
 dc.DrawLine(i * self.Scaling[0], 0, i * self.Scaling[0], height)
 for i in xrange(1, height / self.Scaling[1] + 1):

changeset 64	dd6f693e46a1
parent 61	dc7142ae9438
child 67	3a1b0afdaf84