plcopeneditor_history: comparison SFCViewer.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 types import *
 from Viewer import *
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + GetWireSize(previous)), wx.Point(pos.x, pos.y)])
 self.AddBlock(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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(pos.x, pos.y)])
 if isinstance(next_block, SFC_Divergence):
 next_block.RefreshPosition()
 transition.RefreshOutputModel(True)
 return transition
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + GetWireSize(previous)), wx.Point(pos.x, pos.y)])
 self.AddBlock(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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(pos.x, pos.y)])
 if isinstance(next_block, SFC_Divergence):
 next_block.RefreshPosition()
 step.RefreshOutputModel(True)
 return step
 elif self.Mode == MODE_COMMENT:
 self.rubberBand.Reset()
 self.rubberBand.OnLeftDown(event, self.GetLogicalDC(), self.Scaling)
 elif self.Mode == MODE_WIRE:
 pos = GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling)
-wire = Wire(self, [wxPoint(pos.x, pos.y), SOUTH], [wxPoint(pos.x, pos.y), NORTH])
+wire = Wire(self, [wx.Point(pos.x, pos.y), SOUTH], [wx.Point(pos.x, pos.y), NORTH])
 wire.oldPos = pos
 wire.Handle = (HANDLE_POINT, 0)
 wire.ProcessDragging(0, 0)
 wire.Handle = (HANDLE_POINT, 1)
 self.AddWire(wire)
 self.SelectedElement.SetSelected(True)
 self.Refresh()
 elif self.Mode == MODE_COMMENT:
 bbox = self.rubberBand.GetCurrentExtent()
 self.rubberBand.OnLeftUp(event, self.GetLogicalDC(), self.Scaling)
-wxCallAfter(self.AddComment, bbox)
+wx.CallAfter(self.AddComment, bbox)
 elif self.Mode == MODE_INITIALSTEP:
-wxCallAfter(self.AddInitialStep, GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling))
+wx.CallAfter(self.AddInitialStep, GetScaledEventPosition(event, self.GetLogicalDC(), self.Scaling))
 elif self.Mode == MODE_SELECTION and self.SelectedElement:
 if self.IsWire(self.SelectedElement):
 self.SelectedElement.SetSelectedSegment(0)
 else:
 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:
 self.SelectedElement.ResetPoints()
 self.SelectedElement.OnMotion(event, self.GetLogicalDC(), self.Scaling)
 if self.IsWire(self.SelectedElement):
 self.SelectedElement.SetSelectedSegment(0)
 else:
 self.SelectedElement.SetSelected(True)
 self.SelectedElement.OnRightUp(event, dc, self.Scaling)
-wxCallAfter(self.SetCursor, wxNullCursor)
+wx.CallAfter(self.SetCursor, wx.NullCursor)
 self.ReleaseMouse()
 self.Refresh()
 event.Skip()
 def OnViewerLeftDClick(self, event):
 #-------------------------------------------------------------------------------
 #                          Keyboard event functions
 #-------------------------------------------------------------------------------
 def OnChar(self, event):
+xpos, ypos = self.GetScrollPos(wx.HORIZONTAL), self.GetScrollPos(wx.VERTICAL)
+xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)
+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.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:
 #-------------------------------------------------------------------------------
 #                          Adding element functions
 #-------------------------------------------------------------------------------
 def AddInitialStep(self, pos):
-dialog = StepNameDialog(self.Parent, "Add a new initial step", "Please enter step name", "", wxOK|wxCANCEL)
+dialog = StepNameDialog(self.Parent, "Add a new initial step", "Please enter step name", "", wx.OK|wx.CANCEL)
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
 dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_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)
 self.Refresh()
 dialog.Destroy()
 def AddStep(self):
 if self.SelectedElement in self.Wires or isinstance(self.SelectedElement, SFC_Step):
-dialog = StepNameDialog(self.Parent, "Add a new step", "Please enter step name", "", wxOK|wxCANCEL)
+dialog = StepNameDialog(self.Parent, "Add a new step", "Please enter step name", "", wx.OK|wx.CANCEL)
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
 dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step)])
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 name = dialog.GetValue()
 if self.IsWire(self.SelectedElement):
 self.SelectedElement.SetSelectedSegment(None)
 previous = self.SelectedElement.EndConnected
 next = self.SelectedElement.StartConnected
 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:
+if dialog.ShowModal() == wx.ID_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)])
+wire.SetPoints([wx.Point(pos.x + SFC_WIRE_MIN_SIZE, pos.y), wx.Point(pos.x, pos.y)])
 actionblock.SetActions(actions)
 self.AddBlock(actionblock)
 self.Controler.AddCurrentElementEditingActionBlock(id)
 self.RefreshActionBlockModel(actionblock)
 self.RefreshBuffer()
 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:
+if dialog.ShowModal() == wx.ID_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
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + wire_size), wx.Point(pos.x, pos.y)])
 self.AddBlock(divergence)
 self.Controler.AddCurrentElementEditingDivergence(id, value["type"])
 self.RefreshDivergenceModel(divergence)
 for index, connector in enumerate(divergence_connectors["outputs"]):
 if next:
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(pos.x, pos.y)])
 next_block.RefreshModel()
 next = None
 else:
 transition = self.CreateTransition(connector)
 transition_connectors = transition.GetConnectors()
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + wire_size), wx.Point(pos.x, pos.y)])
 self.AddBlock(divergence)
 self.Controler.AddCurrentElementEditingDivergence(id, value["type"])
 self.RefreshDivergenceModel(divergence)
 for index, connector in enumerate(divergence_connectors["outputs"]):
 if next:
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(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:
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + wire_size), wx.Point(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)
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(pos.x, pos.y)])
 next_block.RefreshModel()
 else:
 if value["type"] == SELECTION_CONVERGENCE:
 previous = divergence_connectors["outputs"][0]
 else:
 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)
+dialog = wx.SingleChoiceDialog(self.Parent, "Add a new jump", "Please choose a target", choices, wx.OK|wx.CANCEL)
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_OK:
 value = dialog.GetStringSelection()
 self.SelectedElement.AddOutput()
 self.RefreshStepModel(self.SelectedElement)
 step_connectors = self.SelectedElement.GetConnectors()
 transition = self.CreateTransition(step_connectors["output"])
 self.AddBlock(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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + SFC_WIRE_MIN_SIZE), wx.Point(pos.x, pos.y)])
 self.RefreshJumpModel(jump)
 self.RefreshBuffer()
 self.RefreshScrollBars()
 self.Refresh()
 dialog.Destroy()
 def EditStepContent(self, step):
-dialog = StepNameDialog(self.Parent, "Edit step name", "Please enter step name", step.GetName(), wxOK|wxCANCEL)
+dialog = StepNameDialog(self.Parent, "Edit step name", "Please enter step name", step.GetName(), wx.OK|wx.CANCEL)
 dialog.SetPouNames(self.Controler.GetProjectPouNames())
 dialog.SetVariables(self.Controler.GetCurrentElementEditingInterfaceVars())
 dialog.SetStepNames([block.GetName() for block in self.Blocks if isinstance(block, SFC_Step) and block.GetName() != step.GetName()])
-if dialog.ShowModal() == wxID_OK:
+if dialog.ShowModal() == wx.ID_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.RefreshBuffer()
 self.RefreshScrollBars()
 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.RefreshBuffer()
-self.RefreshScrollBars()
-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.RefreshBuffer()
-self.RefreshScrollBars()
-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.RefreshBuffer()
-self.RefreshScrollBars()
-self.Refresh()
-dialog.Destroy()
 #-------------------------------------------------------------------------------
 #                          Delete element functions
 #-------------------------------------------------------------------------------
 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)])
+wire.SetPoints([wx.Point(pos.x, pos.y + wire_size), wx.Point(pos.x, pos.y)])
 if isinstance(next_block, SFC_Divergence):
 next_block.RefreshPosition()
 previous_block.RefreshOutputModel(True)
 else:
 if isinstance(previous_block, SFC_Step):
 previous_block = previous.GetParentBlock()
 previous_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),
+wire.SetPoints([wx.Point(previous_pos.x, previous_pos.y + wire_size),
-wxPoint(previous_pos.x, previous_pos.y)])
+wx.Point(previous_pos.x, previous_pos.y)])
 if isinstance(next_block, SFC_Divergence):
 next_block.RefreshPosition()
 previous_block.RefreshOutputModel(True)
 elif divergence.GetBranchNumber() == 1:
 wires = connectors["inputs"][0].GetWires()
 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),
+wire.SetPoints([wx.Point(previous_pos.x, previous_pos.y + wire_size),
-wxPoint(previous_pos.x, previous_pos.y)])
+wx.Point(previous_pos.x, previous_pos.y)])
 if isinstance(next_block, SFC_Divergence):
 next_block.RefreshPosition()
 previous_block.RefreshOutputModel(True)
 self.Parent.RefreshProjectTree()

changeset 64	dd6f693e46a1
parent 58	39cd981ff242
child 67	3a1b0afdaf84