770         step_connectors = step.GetConnectors()

   770         if self.GetDrawingMode() == FREEDRAWING_MODE:

   771         if not step.GetInitial() or not step_connectors["output"]:

   771             Viewer.DeleteStep(self, step)

   772             previous = step.GetPreviousConnector()

   772         else:

   773             if previous:

   773             step_connectors = step.GetConnectors()

   774                 previous_block = previous.GetParentBlock()

   774             if not step.GetInitial() or not step_connectors["output"]:

   775             else:

   775                 previous = step.GetPreviousConnector()

   776                 previous_block = None

   776                 if previous:

   777             next = step.GetNextConnector()

   777                     previous_block = previous.GetParentBlock()

   778             if next:

   778                 else:

   779                 next_block = next.GetParentBlock()

   779                     previous_block = None

   780             else:

   781                 next_block = None

   782             if isinstance(next_block, SFC_Transition):

   783                 self.RemoveTransition(next_block)

   789             elif isinstance(previous_block, SFC_Transition):

   785                 if isinstance(next_block, SFC_Transition):

   790                 self.RemoveTransition(previous_block)

   786                     self.RemoveTransition(next_block)

   791                 previous = step.GetPreviousConnector()

   787                     next = step.GetNextConnector()

   792                 if previous:

   788                     if next:

   793                     previous_block = previous.GetParentBlock()

   789                         next_block = next.GetParentBlock()

   794                 else:

   795                     previous_block = None

   796             wire = self.RemoveStep(step)

   797             self.SelectedElement = None

   798             if next_block:

   799                 if isinstance(next_block, SFC_Divergence) and next_block.GetType() == SIMULTANEOUS_CONVERGENCE and isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SIMULTANEOUS_DIVERGENCE:

   800                     wire.Clean()

   801                     self.Wires.remove(wire)

   802                     self.Elements.remove(wire)

   803                     next_block.RemoveBranch(next)

   804                     if next_block.GetBranchNumber() < 2:

   805                         self.DeleteDivergence(next_block)

   807                         next_block.RefreshModel()

   791                         next_block = None

   808                     previous_block.RemoveBranch(previous)

   792                 elif isinstance(previous_block, SFC_Transition):

   809                     if previous_block.GetBranchNumber() < 2:

   793                     self.RemoveTransition(previous_block)

   810                         self.DeleteDivergence(previous_block)

   794                     previous = step.GetPreviousConnector()

   795                     if previous:

   796                         previous_block = previous.GetParentBlock()

   812                         previous_block.RefreshModel()

   798                         previous_block = None

   813                 else:

   799                 wire = self.RemoveStep(step)

   814                     pos = previous.GetPosition(False)

   800                 self.SelectedElement = None

   815                     next_pos = next.GetPosition(False)

   801                 if next_block:

   816                     wire_size = GetWireSize(previous_block)

   802                     if isinstance(next_block, SFC_Divergence) and next_block.GetType() == SIMULTANEOUS_CONVERGENCE and isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SIMULTANEOUS_DIVERGENCE:

   817                     previous_block.RefreshOutputPosition((0, pos.y + wire_size - next_pos.y))

   803                         wire.Clean()

   818                     wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])

   804                         self.Wires.remove(wire)

   819                     if isinstance(next_block, SFC_Divergence):

   805                         self.Elements.remove(wire)

   820                         next_block.RefreshPosition()

   806                         next_block.RemoveBranch(next)

   821                     previous_block.RefreshOutputModel(True)

   807                         if next_block.GetBranchNumber() < 2:

   822             else:

   808                             self.DeleteDivergence(next_block)

   823                 if isinstance(previous_block, SFC_Step):

   809                         else:

   824                     previous_block.RemoveOutput()

   810                             next_block.RefreshModel()

   825                     self.RefreshStepModel(previous_block)

   826                 elif isinstance(previous_block, SFC_Divergence):

   827                     if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

   828                         self.DeleteDivergence(previous_block)

   829                     else:

   834                             self.RefreshDivergenceModel(previous_block)

   815                             previous_block.RefreshModel()

   816                     else:

   817                         pos = previous.GetPosition(False)

   818                         next_pos = next.GetPosition(False)

   819                         wire_size = GetWireSize(previous_block)

   820                         previous_block.RefreshOutputPosition((0, pos.y + wire_size - next_pos.y))

   821                         wire.SetPoints([wxPoint(pos.x, pos.y + wire_size), wxPoint(pos.x, pos.y)])

   822                         if isinstance(next_block, SFC_Divergence):

   823                             next_block.RefreshPosition()

   824                         previous_block.RefreshOutputModel(True)

   825                 else:

   826                     if isinstance(previous_block, SFC_Step):

   827                         previous_block.RemoveOutput()

   828                         self.RefreshStepModel(previous_block)

   829                     elif isinstance(previous_block, SFC_Divergence):

   830                         if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

   831                             self.DeleteDivergence(previous_block)

   832                         else:

   833                             previous_block.RemoveBranch(previous)

   834                             if previous_block.GetBranchNumber() < 2:

   835                                 self.DeleteDivergence(previous_block)

   836                             else:

   837                                 self.RefreshDivergenceModel(previous_block)

   837         previous = transition.GetPreviousConnector()

   840         if self.GetDrawingMode() == FREEDRAWING_MODE:

   838         previous_block = previous.GetParentBlock()

   841             Viewer.DeleteTransition(self, transition)

   839         next = transition.GetNextConnector()

   842         else:

   840         next_block = next.GetParentBlock()

   843             previous = transition.GetPreviousConnector()

   841         if isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SELECTION_DIVERGENCE and isinstance(next_block, SFC_Divergence) and next_block.GetType() == SELECTION_CONVERGENCE:

   844             previous_block = previous.GetParentBlock()

   845             next = transition.GetNextConnector()

   846             next_block = next.GetParentBlock()

   847             if isinstance(previous_block, SFC_Divergence) and previous_block.GetType() == SELECTION_DIVERGENCE and isinstance(next_block, SFC_Divergence) and next_block.GetType() == SELECTION_CONVERGENCE:

   848                 wires = previous.GetWires()

   849                 if len(wires) != 1:

   850                     return

   851                 wire = wires[0][0]

   852                 wire.Clean()

   853                 self.Wires.remove(wire)

   854                 self.Elements.remove(wire)

   855                 wires = next.GetWires()

   856                 if len(wires) != 1:

   857                     return

   858                 wire = wires[0][0]

   859                 wire.Clean()

   860                 self.Wires.remove(wire)

   861                 self.Elements.remove(wire)

   862                 transition.Clean()

   863                 self.Blocks.remove(transition)

   864                 self.Elements.remove(transition)

   865                 self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())

   866                 previous_block.RemoveBranch(previous)

   867                 if previous_block.GetBranchNumber() < 2:

   868                     self.DeleteDivergence(previous_block)

   869                 else:

   870                     self.RefreshDivergenceModel(previous_block)

   871                 next_block.RemoveBranch(next)

   872                 if next_block.GetBranchNumber() < 2:

   873                     self.DeleteDivergence(next_block)

   874                 else:

   875                     self.RefreshDivergenceModel(next_block)

   876             self.Parent.RefreshProjectTree()

   877 

   878     def DeleteDivergence(self, divergence):

   879         if self.GetDrawingMode() == FREEDRAWING_MODE:

   880             Viewer.DeleteDivergence(self, divergence)

   881         else:

   882             connectors = divergence.GetConnectors()

   883             type = divergence.GetType()

   884             if type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

   885                 wires = connectors["outputs"][0].GetWires()

   886                 if len(wires) > 1:

   887                     return

   888                 elif len(wires) == 1:

   889                     next = wires[0][0].StartConnected

   890                     next_block = next.GetParentBlock()

   891                     wire = wires[0][0]

   892                     wire.Clean()

   893                     self.Wires.remove(wire)

   894                     self.Elements.remove(wire)

   895                 else:

   896                     next = None

   897                     next_block = None

   898                 for index, connector in enumerate(connectors["inputs"]):

   899                     if next and index == 0:

   900                         wires = connector.GetWires()

   901                         wire = wires[0][0]

   902                         previous = wires[0][0].EndConnected

   903                         wire.Clean()

   904                         self.Wires.remove(wire)

   905                         self.Elements.remove(wire)

   906                     else:

   907                         if type == SELECTION_CONVERGENCE:

   908                             wires = connector.GetWires()

   909                             previous_block = wires[0][0].EndConnected.GetParentBlock()

   910                             self.RemoveTransition(previous_block)

   911                         wires = connector.GetWires()

   912                         wire = wires[0][0]

   913                         previous_connector = wire.EndConnected

   914                         previous_block = previous_connector.GetParentBlock()

   915                         wire.Clean()

   916                         self.Wires.remove(wire)

   917                         self.Elements.remove(wire)

   918                         if isinstance(previous_block, SFC_Step):

   919                             previous_block.RemoveOutput()

   920                             self.RefreshStepModel(previous_block)

   921                         elif isinstance(previous_block, SFC_Divergence):

   922                             if previous_block.GetType() in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:

   923                                 previous_block.RemoveBranch(previous_connector)

   924                                 if previous_block.GetBranchNumber() < 2:

   925                                     self.DeleteDivergence(previous_block)

   926                                 else:

   927                                     self.RefreshDivergenceModel(previous_block)

   928                             else:

   929                                 self.DeleteDivergence(previous_block)

   930                 divergence.Clean()

   931                 self.Blocks.remove(divergence)

   932                 self.Elements.remove(divergence)

   933                 self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())

   934                 if next:

   935                     wire = self.ConnectConnectors(next, previous)

   936                     previous_block = previous.GetParentBlock()

   937                     pos = previous.GetPosition(False)

   938                     next_pos = next.GetPosition(False)

   939                     wire_size = GetWireSize(previous_block)

   940                     previous_block.RefreshOutputPosition((0, previous_pos.y + wire_size - next_pos.y))

   941                     wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size), 

   942                         wxPoint(previous_pos.x, previous_pos.y)])

   943                     if isinstance(next_block, SFC_Divergence):

   944                         next_block.RefreshPosition()

   945                     previous_block.RefreshOutputModel(True)

   946             elif divergence.GetBranchNumber() == 1:

   947                 wires = connectors["inputs"][0].GetWires()

   948                 if len(wires) != 1:

   949                     return

   950                 wire = wires[0][0]

   951                 previous = wire.EndConnected

   952                 previous_block = previous.GetParentBlock()

   953                 wire.Clean()

   954                 self.Wires.remove(wire)

   955                 self.Elements.remove(wire)

   956                 wires = connectors["outputs"][0].GetWires()

   957                 if len(wires) != 1:

   958                     return

   959                 wire = wires[0][0]

   960                 next = wire.StartConnected

   961                 next_block = next.GetParentBlock()

   962                 wire.Clean()

   963                 self.Wires.remove(wire)

   964                 self.Elements.remove(wire)

   965                 divergence.Clean()

   966                 self.Blocks.remove(divergence)

   967                 self.Elements.remove(divergence)

   968                 self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())

   969                 wire = self.ConnectConnectors(next, previous)

   970                 previous_pos = previous.GetPosition(False)

   971                 next_pos = next.GetPosition(False)

   972                 wire_size = GetWireSize(previous_block)

   973                 previous_block.RefreshOutputPosition((previous_pos.x - next_pos.x, previous_pos.y + wire_size - next_pos.y))

   974                 wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size), 

   975                     wxPoint(previous_pos.x, previous_pos.y)])

   976                 if isinstance(next_block, SFC_Divergence):

   977                     next_block.RefreshPosition()

   978                 previous_block.RefreshOutputModel(True)

   979             self.Parent.RefreshProjectTree()

   980 

   981     def DeleteJump(self, jump):

   982         if self.GetDrawingMode() == FREEDRAWING_MODE:

   983             Viewer.DeleteJump(self, jump)

   984         else:

   985             previous = jump.GetPreviousConnector()

   986             previous_block = previous.GetParentBlock()

   987             if isinstance(previous_block, SFC_Transition):

   988                 self.RemoveTransition(previous_block)

   989                 previous = jump.GetPreviousConnector()

   990                 if previous:

   991                     previous_block = previous.GetParentBlock()

   992                 else:

   993                     previous_block = None

   849             wires = next.GetWires()

  1001             jump.Clean()

  1002             self.Blocks.remove(jump)

  1003             self.Elements.remove(jump)

  1004             self.Controler.RemoveCurrentElementEditingInstance(jump.GetId())

  1005             if isinstance(previous_block, SFC_Step):

  1006                 previous_block.RemoveOutput()

  1007                 self.RefreshStepModel(previous_block)

  1008             elif isinstance(previous_block, SFC_Divergence):

  1009                 if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

  1010                     self.DeleteDivergence(previous_block)

  1011                 else:

  1012                     previous_block.RemoveBranch(previous)

  1013                     if previous_block.GetBranchNumber() < 2:

  1014                         self.DeleteDivergence(previous_block)

  1015                     else:

  1016                         previous_block.RefreshModel()

  1017             self.Parent.RefreshProjectTree()

  1018 

  1019     def DeleteActionBlock(self, actionblock):

  1020         if self.GetDrawingMode() == FREEDRAWING_MODE:

  1021             Viewer.DeleteActionBlock(self, actionblock)

  1022         else:

  1023             connector = actionblock.GetConnector()

  1024             wires = connector.GetWires()

   856             transition.Clean()

  1032             actionblock.Clean()

   857             self.Blocks.remove(transition)

  1033             self.Blocks.remove(actionblock)

   858             self.Elements.remove(transition)

  1034             self.Elements.remove(actionblock)

   859             self.Controler.RemoveCurrentElementEditingInstance(transition.GetId())

  1035             self.Controler.RemoveCurrentElementEditingInstance(actionblock.GetId())

   860             previous_block.RemoveBranch(previous)

  1036             step.RemoveAction()

   861             if previous_block.GetBranchNumber() < 2:

  1037             self.RefreshStepModel(step)

   862                 self.DeleteDivergence(previous_block)

  1038             step.RefreshOutputPosition()

   863             else:

  1039             step.RefreshOutputModel(True)

   864                 self.RefreshDivergenceModel(previous_block)

  1040             self.Parent.RefreshProjectTree()

   865             next_block.RemoveBranch(next)

  1041 

   866             if next_block.GetBranchNumber() < 2:

   867                 self.DeleteDivergence(next_block)

   868             else:

   869                 self.RefreshDivergenceModel(next_block)

   870         self.Parent.RefreshProjectTree()

   871 

   872     def DeleteDivergence(self, divergence):

   873         connectors = divergence.GetConnectors()

   874         type = divergence.GetType()

   875         if type in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

   876             wires = connectors["outputs"][0].GetWires()

   877             if len(wires) > 1:

   878                 return

   879             elif len(wires) == 1:

   880                 next = wires[0][0].StartConnected

   881                 next_block = next.GetParentBlock()

   882                 wire = wires[0][0]

   883                 wire.Clean()

   884                 self.Wires.remove(wire)

   885                 self.Elements.remove(wire)

   886             else:

   887                 next = None

   888                 next_block = None

   889             for index, connector in enumerate(connectors["inputs"]):

   890                 if next and index == 0:

   891                     wires = connector.GetWires()

   892                     wire = wires[0][0]

   893                     previous = wires[0][0].EndConnected

   894                     wire.Clean()

   895                     self.Wires.remove(wire)

   896                     self.Elements.remove(wire)

   897                 else:

   898                     if type == SELECTION_CONVERGENCE:

   899                         wires = connector.GetWires()

   900                         previous_block = wires[0][0].EndConnected.GetParentBlock()

   901                         self.RemoveTransition(previous_block)

   902                     wires = connector.GetWires()

   903                     wire = wires[0][0]

   904                     previous_connector = wire.EndConnected

   905                     previous_block = previous_connector.GetParentBlock()

   906                     wire.Clean()

   907                     self.Wires.remove(wire)

   908                     self.Elements.remove(wire)

   909                     if isinstance(previous_block, SFC_Step):

   910                         previous_block.RemoveOutput()

   911                         self.RefreshStepModel(previous_block)

   912                     elif isinstance(previous_block, SFC_Divergence):

   913                         if previous_block.GetType() in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:

   914                             previous_block.RemoveBranch(previous_connector)

   915                             if previous_block.GetBranchNumber() < 2:

   916                                 self.DeleteDivergence(previous_block)

   917                             else:

   918                                 self.RefreshDivergenceModel(previous_block)

   919                         else:

   920                             self.DeleteDivergence(previous_block)

   921             divergence.Clean()

   922             self.Blocks.remove(divergence)

   923             self.Elements.remove(divergence)

   924             self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())

   925             if next:

   926                 wire = self.ConnectConnectors(next, previous)

   927                 previous_block = previous.GetParentBlock()

   928                 pos = previous.GetPosition(False)

   929                 next_pos = next.GetPosition(False)

   930                 wire_size = GetWireSize(previous_block)

   931                 previous_block.RefreshOutputPosition((0, previous_pos.y + wire_size - next_pos.y))

   932                 wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size), 

   933                     wxPoint(previous_pos.x, previous_pos.y)])

   934                 if isinstance(next_block, SFC_Divergence):

   935                     next_block.RefreshPosition()

   936                 previous_block.RefreshOutputModel(True)

   937         elif divergence.GetBranchNumber() == 1:

   938             wires = connectors["inputs"][0].GetWires()

   939             if len(wires) != 1:

   940                 return

   941             wire = wires[0][0]

   942             previous = wire.EndConnected

   943             previous_block = previous.GetParentBlock()

   944             wire.Clean()

   945             self.Wires.remove(wire)

   946             self.Elements.remove(wire)

   947             wires = connectors["outputs"][0].GetWires()

   948             if len(wires) != 1:

   949                 return

   950             wire = wires[0][0]

   951             next = wire.StartConnected

   952             next_block = next.GetParentBlock()

   953             wire.Clean()

   954             self.Wires.remove(wire)

   955             self.Elements.remove(wire)

   956             divergence.Clean()

   957             self.Blocks.remove(divergence)

   958             self.Elements.remove(divergence)

   959             self.Controler.RemoveCurrentElementEditingInstance(divergence.GetId())

   960             wire = self.ConnectConnectors(next, previous)

   961             previous_pos = previous.GetPosition(False)

   962             next_pos = next.GetPosition(False)

   963             wire_size = GetWireSize(previous_block)

   964             previous_block.RefreshOutputPosition((previous_pos.x - next_pos.x, previous_pos.y + wire_size - next_pos.y))

   965             wire.SetPoints([wxPoint(previous_pos.x, previous_pos.y + wire_size), 

   966                 wxPoint(previous_pos.x, previous_pos.y)])

   967             if isinstance(next_block, SFC_Divergence):

   968                 next_block.RefreshPosition()

   969             previous_block.RefreshOutputModel(True)

   970         self.Parent.RefreshProjectTree()

   971 

   972     def DeleteJump(self, jump):

   973         previous = jump.GetPreviousConnector()

   974         previous_block = previous.GetParentBlock()

   975         if isinstance(previous_block, SFC_Transition):

   976             self.RemoveTransition(previous_block)

   977             previous = jump.GetPreviousConnector()

   978             if previous:

   979                 previous_block = previous.GetParentBlock()

   980             else:

   981                 previous_block = None

   982         wires = previous.GetWires()

   983         if len(wires) != 1:

   984             return

   985         wire = wires[0][0]

   986         wire.Clean()

   987         self.Wires.remove(wire)

   988         self.Elements.remove(wire)

   989         jump.Clean()

   990         self.Blocks.remove(jump)

   991         self.Elements.remove(jump)

   992         self.Controler.RemoveCurrentElementEditingInstance(jump.GetId())

   993         if isinstance(previous_block, SFC_Step):

   994             previous_block.RemoveOutput()

   995             self.RefreshStepModel(previous_block)

   996         elif isinstance(previous_block, SFC_Divergence):

   997             if previous_block.GetType() in [SELECTION_CONVERGENCE, SIMULTANEOUS_CONVERGENCE]:

   998                 self.DeleteDivergence(previous_block)

   999             else:

  1000                 previous_block.RemoveBranch(previous)

  1001                 if previous_block.GetBranchNumber() < 2:

  1002                     self.DeleteDivergence(previous_block)

  1003                 else:

  1004                     previous_block.RefreshModel()

  1005         self.Parent.RefreshProjectTree()

  1006 

  1007     def DeleteActionBlock(self, actionblock):

  1008         connector = actionblock.GetConnector()

  1009         wires = connector.GetWires()

  1010         if len(wires) != 1:

  1011             return

  1012         wire = wires[0][0]

  1013         step = wire.EndConnected.GetParentBlock()

  1014         wire.Clean()

  1015         self.Wires.remove(wire)

  1016         self.Elements.remove(wire)

  1017         actionblock.Clean()

  1018         self.Blocks.remove(actionblock)

  1019         self.Elements.remove(actionblock)

  1020         self.Controler.RemoveCurrentElementEditingInstance(actionblock.GetId())

  1021         step.RemoveAction()

  1022         self.RefreshStepModel(step)

  1023         step.RefreshOutputPosition()

  1024         step.RefreshOutputModel(True)

  1025         self.Parent.RefreshProjectTree()

  1026 

  1027     def DeleteComment(self, comment):

  1028         self.Elements.remove(self.SelectedElement)

  1029         self.Controler.RemoveCurrentElementEditingInstance(comment.GetId())

  1030         

  1032         pass

  1043         if self.GetDrawingMode() == FREEDRAWING_MODE:

  1033 

  1044             Viewer.DeleteWire(self, wire)

  1045