Mercurial Mercurial > beremiz / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
editors/Viewer.py
branch1.1 Korean release
changeset 1384 02fe382c4511
parent 1366 3756ae754713
child 1377 cc8f9177d41c
equal deleted inserted replaced
1280:72a826dfcfbb 1384:02fe382c4511 
    82 ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]
 
    82 ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]
 
    83 
    83 
    84 def GetVariableCreationFunction(variable_type):
 
    84 def GetVariableCreationFunction(variable_type):
 
    85     def variableCreationFunction(viewer, id, specific_values):
 
    85     def variableCreationFunction(viewer, id, specific_values):
 
    86         return FBD_Variable(viewer, variable_type, 
    86         return FBD_Variable(viewer, variable_type, 
    87                                     specific_values["name"], 
    87                                     specific_values.name, 
    88                                     specific_values["value_type"], 
    88                                     specific_values.value_type, 
    89                                     id,
 
    89                                     id,
 
    90                                     specific_values["executionOrder"])
 
    90                                     specific_values.execution_order)
 
    91     return variableCreationFunction
 
    91     return variableCreationFunction
 
    92 
    92 
    93 def GetConnectorCreationFunction(connector_type):
 
    93 def GetConnectorCreationFunction(connector_type):
 
    94     def connectorCreationFunction(viewer, id, specific_values):
 
    94     def connectorCreationFunction(viewer, id, specific_values):
 
    95         return FBD_Connector(viewer, connector_type, 
    95         return FBD_Connector(viewer, connector_type, 
    96                                      specific_values["name"], id)
 
    96                                      specific_values.name, id)
 
    97     return connectorCreationFunction
 
    97     return connectorCreationFunction
 
    98 
    98 
    99 def commentCreationFunction(viewer, id, specific_values):
 
    99 def commentCreationFunction(viewer, id, specific_values):
 
   100     return Comment(viewer, specific_values["content"], id)
 
   100     return Comment(viewer, specific_values.content, id)
 
   101 
   101 
   102 def GetPowerRailCreationFunction(powerrail_type):
 
   102 def GetPowerRailCreationFunction(powerrail_type):
 
   103     def powerRailCreationFunction(viewer, id, specific_values):
 
   103     def powerRailCreationFunction(viewer, id, specific_values):
 
   104         return LD_PowerRail(viewer, powerrail_type, id, 
   104         return LD_PowerRail(viewer, powerrail_type, id, 
   105                                     specific_values["connectors"])
 
   105                                     specific_values.connectors)
 
   106     return powerRailCreationFunction
 
   106     return powerRailCreationFunction
 
       
   107 
       
   108 MODIFIER_VALUE = lambda x: x if x is not None else 'none'
 
   107 
   109 
   108 CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,
 
   110 CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,
 
   109                  (False, "rising"): CONTACT_RISING,
 
   111                  (False, "rising"): CONTACT_RISING,
 
   110                  (False, "falling"): CONTACT_FALLING}
 
   112                  (False, "falling"): CONTACT_FALLING}
 
   111 
   113 
   112 def contactCreationFunction(viewer, id, specific_values):
 
   114 def contactCreationFunction(viewer, id, specific_values):
 
   113     contact_type = CONTACT_TYPES.get((specific_values.get("negated", False), 
   115     contact_type = CONTACT_TYPES.get((specific_values.negated, 
   114                                       specific_values.get("edge", "none")),
 
   116                                       MODIFIER_VALUE(specific_values.edge)),
 
   115                                      CONTACT_NORMAL)
 
   117                                      CONTACT_NORMAL)
 
   116     return LD_Contact(viewer, contact_type, specific_values["name"], id)
 
   118     return LD_Contact(viewer, contact_type, specific_values.name, id)
 
   117 
   119 
   118 COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,
 
   120 COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,
 
   119               (False, "none", "set"): COIL_SET,
 
   121               (False, "none", "set"): COIL_SET,
 
   120               (False, "none", "reset"): COIL_RESET,
 
   122               (False, "none", "reset"): COIL_RESET,
 
   121               (False, "rising", "none"): COIL_RISING,
 
   123               (False, "rising", "none"): COIL_RISING,
 
   122               (False, "falling", "none"): COIL_FALLING}
 
   124               (False, "falling", "none"): COIL_FALLING}
 
   123 
   125 
   124 def coilCreationFunction(viewer, id, specific_values):
 
   126 def coilCreationFunction(viewer, id, specific_values):
 
   125     coil_type = COIL_TYPES.get((specific_values.get("negated", False), 
   127     coil_type = COIL_TYPES.get((specific_values.negated, 
   126                                 specific_values.get("edge", "none"),
 
   128                                 MODIFIER_VALUE(specific_values.edge),
 
   127                                 specific_values.get("storage", "none")),
 
   129                                 MODIFIER_VALUE(specific_values.storage)),
 
   128                                COIL_NORMAL)
 
   130                                COIL_NORMAL)
 
   129     return LD_Coil(viewer, coil_type, specific_values["name"], id)
 
   131     return LD_Coil(viewer, coil_type, specific_values.name, id)
 
   130 
   132 
   131 def stepCreationFunction(viewer, id, specific_values):
 
   133 def stepCreationFunction(viewer, id, specific_values):
 
   132     step = SFC_Step(viewer, specific_values["name"], 
   134     step = SFC_Step(viewer, specific_values.name, 
   133                             specific_values.get("initial", False), id)
 
   135                             specific_values.initial, id)
 
   134     if specific_values.get("action", None):
 
   136     if specific_values.action is not None:
 
   135         step.AddAction()
 
   137         step.AddAction()
 
   136         connector = step.GetActionConnector()
 
   138         connector = step.GetActionConnector()
 
   137         connector.SetPosition(wx.Point(*specific_values["action"]["position"]))
 
   139         connector.SetPosition(wx.Point(*specific_values.action.position))
 
   138     return step
 
   140     return step
 
   139 
   141 
   140 def transitionCreationFunction(viewer, id, specific_values):
 
   142 def transitionCreationFunction(viewer, id, specific_values):
 
   141     transition = SFC_Transition(viewer, specific_values["condition_type"], 
   143     transition = SFC_Transition(viewer, specific_values.condition_type, 
   142                                         specific_values.get("condition", None), 
   144                                         specific_values.condition, 
   143                                         specific_values["priority"], id)
 
   145                                         specific_values.priority, id)
 
   144     return transition
 
   146     return transition
 
   145 
   147 
   146 def GetDivergenceCreationFunction(divergence_type):
 
   148 def GetDivergenceCreationFunction(divergence_type):
 
   147     def divergenceCreationFunction(viewer, id, specific_values):
 
   149     def divergenceCreationFunction(viewer, id, specific_values):
 
   148         return SFC_Divergence(viewer, divergence_type, 
   150         return SFC_Divergence(viewer, divergence_type, 
   149                                       specific_values["connectors"], id)
 
   151                                       specific_values.connectors, id)
 
   150     return divergenceCreationFunction
 
   152     return divergenceCreationFunction
 
   151 
   153 
   152 def jumpCreationFunction(viewer, id, specific_values):
 
   154 def jumpCreationFunction(viewer, id, specific_values):
 
   153     return SFC_Jump(viewer, specific_values["target"], id)
 
   155     return SFC_Jump(viewer, specific_values.target, id)
 
   154 
   156 
   155 def actionBlockCreationFunction(viewer, id, specific_values):
 
   157 def actionBlockCreationFunction(viewer, id, specific_values):
 
   156     return SFC_ActionBlock(viewer, specific_values["actions"], id)
 
   158     return SFC_ActionBlock(viewer, specific_values.actions, id)
 
   157 
   159 
   158 ElementCreationFunctions = {
 
   160 ElementCreationFunctions = {
 
   159     "input": GetVariableCreationFunction(INPUT),
 
   161     "input": GetVariableCreationFunction(INPUT),
 
   160     "output": GetVariableCreationFunction(OUTPUT),
 
   162     "output": GetVariableCreationFunction(OUTPUT),
 
   161     "inout": GetVariableCreationFunction(INOUT),
 
   163     "inout": GetVariableCreationFunction(INOUT),
 
   328                     var_class = OUTPUT
 
   330                     var_class = OUTPUT
 
   329                 elif values[1] == "InOut":
 
   331                 elif values[1] == "InOut":
 
   330                     var_class = INPUT
 
   332                     var_class = INPUT
 
   331                 else:
 
   333                 else:
 
   332                     var_class = INPUT
 
   334                     var_class = INPUT
 
   333                 tree = dict([(var["Name"], var["Tree"]) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, self.ParentWindow.Debug)]).get(values[0], None)
 
   335                 tree = dict([(var.Name, var.Tree) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, True, self.ParentWindow.Debug)]).get(values[0], None)
 
   334                 if tree is not None:
 
   336                 if tree is not None:
 
   335                     if len(tree[0]) > 0:
 
   337                     if len(tree[0]) > 0:
 
   336                         menu = wx.Menu(title='')
 
   338                         menu = wx.Menu(title='')
 
   337                         self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])
 
   339                         self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])
 
   338                         self.ParentWindow.PopupMenuXY(menu)
 
   340                         self.ParentWindow.PopupMenuXY(menu)
 
   566         # Adding a rubberband to Viewer
 
   568         # Adding a rubberband to Viewer
 
   567         self.rubberBand = RubberBand(viewer=self)
 
   569         self.rubberBand = RubberBand(viewer=self)
 
   568         self.Editor.SetBackgroundColour(wx.Colour(255,255,255))
 
   570         self.Editor.SetBackgroundColour(wx.Colour(255,255,255))
 
   569         self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 
   571         self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 
   570         self.ResetView()
 
   572         self.ResetView()
 
       
   573         self.LastClientSize = None
 
   571         self.Scaling = None
 
   574         self.Scaling = None
 
   572         self.DrawGrid = True
 
   575         self.DrawGrid = True
 
   573         self.GridBrush = wx.TRANSPARENT_BRUSH
 
   576         self.GridBrush = wx.TRANSPARENT_BRUSH
 
   574         self.PageSize = None
 
   577         self.PageSize = None
 
   575         self.PagePen = wx.TRANSPARENT_PEN
 
   578         self.PagePen = wx.TRANSPARENT_PEN
 
  1048     def ElementNeedRefresh(self, element):
 
  1051     def ElementNeedRefresh(self, element):
 
  1049         self.ElementRefreshList_lock.acquire()
 
  1052         self.ElementRefreshList_lock.acquire()
 
  1050         self.ElementRefreshList.append(element)
 
  1053         self.ElementRefreshList.append(element)
 
  1051         self.ElementRefreshList_lock.release()
 
  1054         self.ElementRefreshList_lock.release()
 
  1052         
  1055         
  1053     def RefreshNewData(self):
 
  1056     def NewDataAvailable(self, ticks, *args, **kwargs):
 
  1054         refresh_rect = None
 
  1057         if self.IsShown():
 
  1055         self.ElementRefreshList_lock.acquire()
 
  1058             refresh_rect = None
 
  1056         for element in self.ElementRefreshList:
 
  1059             self.ElementRefreshList_lock.acquire()
 
  1057             if refresh_rect is None:
 
  1060             for element in self.ElementRefreshList:
 
  1058                 refresh_rect = element.GetRedrawRect()
 
  1061                 if refresh_rect is None:
 
  1059             else:
 
  1062                     refresh_rect = element.GetRedrawRect()
 
  1060                 refresh_rect.Union(element.GetRedrawRect())
 
  1063                 else:
 
  1061         self.ElementRefreshList = []
 
  1064                     refresh_rect.Union(element.GetRedrawRect())
 
  1062         self.ElementRefreshList_lock.release()
 
  1065             self.ElementRefreshList = []
 
  1063         
  1066             self.ElementRefreshList_lock.release()
 
  1064         if refresh_rect is not None:
 
  1067             
  1065             self.RefreshRect(self.GetScrolledRect(refresh_rect), False)
 
  1068             if refresh_rect is not None:
 
  1066         else:
 
  1069                 self.RefreshRect(self.GetScrolledRect(refresh_rect), False)
 
  1067             DebugViewer.RefreshNewData(self)
 
  1070         
  1068     
       
  1069     def SubscribeAllDataConsumers(self):
 
  1071     def SubscribeAllDataConsumers(self):
 
  1070         self.RefreshView()
 
  1072         self.RefreshView()
 
  1071         DebugViewer.SubscribeAllDataConsumers(self)
 
  1073         DebugViewer.SubscribeAllDataConsumers(self)
 
  1072         
  1074         
  1073     # Refresh Viewer elements
 
  1075     # Refresh Viewer elements
 
  1074     def RefreshView(self, variablepanel=True, selection=None):
 
  1076     def RefreshView(self, variablepanel=True, selection=None):
 
  1075         EditorPanel.RefreshView(self, variablepanel)
 
  1077         EditorPanel.RefreshView(self, variablepanel)
 
  1076         
  1078         
  1077         if self.TagName.split("::")[0] == "A":
 
  1079         if self.TagName.split("::")[0] == "A" and self.Debug:
 
  1078             self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)
 
  1080             self.AddDataConsumer("%s.Q" % self.InstancePath.upper(), self)
 
  1079         
  1081         
  1080         if self.ToolTipElement is not None:
 
  1082         if self.ToolTipElement is not None:
 
  1081             self.ToolTipElement.DestroyToolTip()
 
  1083             self.ToolTipElement.DestroyToolTip()
 
  1082             self.ToolTipElement = None
 
  1084             self.ToolTipElement = None
 
  1087         self.Flush()
 
  1089         self.Flush()
 
  1088         self.ResetView()
 
  1090         self.ResetView()
 
  1089         self.ResetBuffer()
 
  1091         self.ResetBuffer()
 
  1090         instance = {}
 
  1092         instance = {}
 
  1091         # List of ids of already loaded blocks
 
  1093         # List of ids of already loaded blocks
 
  1092         ids = []
 
  1094         instances = self.Controler.GetEditedElementInstancesInfos(self.TagName, debug = self.Debug)
 
  1093         # Load Blocks until they are all loaded
 
  1095         # Load Blocks until they are all loaded
 
  1094         while instance is not None:
 
  1096         while len(instances) > 0:
 
  1095             instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, exclude = ids, debug = self.Debug)
 
  1097             self.loadInstance(instances.popitem(0)[1], instances, selection)
 
  1096             if instance is not None:
 
       
  1097                 self.loadInstance(instance, ids, selection)
 
       
  1098         
  1098         
  1099         if (selection is not None and 
  1099         if (selection is not None and 
  1100             isinstance(self.SelectedElement, Graphic_Group)):
 
  1100             isinstance(self.SelectedElement, Graphic_Group)):
 
  1101             self.SelectedElement.RefreshWireExclusion()
 
  1101             self.SelectedElement.RefreshWireExclusion()
 
  1102             self.SelectedElement.RefreshBoundingBox()
 
  1102             self.SelectedElement.RefreshBoundingBox()
 
  1218             group.AddElement(self.SelectedElement)
 
  1218             group.AddElement(self.SelectedElement)
 
  1219             group.AddElement(element)
 
  1219             group.AddElement(element)
 
  1220             self.SelectedElement = group
 
  1220             self.SelectedElement = group
 
  1221         
  1221         
  1222     # Load instance from given informations
 
  1222     # Load instance from given informations
 
  1223     def loadInstance(self, instance, ids, selection):
 
  1223     def loadInstance(self, instance, remaining_instances, selection):
 
  1224         ids.append(instance["id"])
 
  1224         self.current_id = max(self.current_id, instance.id)
 
  1225         self.current_id = max(self.current_id, instance["id"])
 
  1225         creation_function = ElementCreationFunctions.get(instance.type, None)
 
  1226         creation_function = ElementCreationFunctions.get(instance["type"], None)
 
       
  1227         connectors = {"inputs" : [], "outputs" : []}
 
  1226         connectors = {"inputs" : [], "outputs" : []}
 
  1228         specific_values = instance["specific_values"]
 
  1227         specific_values = instance.specific_values
 
  1229         if creation_function is not None:
 
  1228         if creation_function is not None:
 
  1230             element = creation_function(self, instance["id"], specific_values)
 
  1229             element = creation_function(self, instance.id, specific_values)
 
  1231             if isinstance(element, SFC_Step):
 
  1230             if isinstance(element, SFC_Step):
 
  1232                 if len(instance["inputs"]) > 0:
 
  1231                 if len(instance.inputs) > 0:
 
  1233                     element.AddInput()
 
  1232                     element.AddInput()
 
  1234                 else:
 
  1233                 else:
 
  1235                     element.RemoveInput()
 
  1234                     element.RemoveInput()
 
  1236                 if len(instance["outputs"]) > 0:
 
  1235                 if len(instance.outputs) > 0:
 
  1237                     element.AddOutput()
 
  1236                     element.AddOutput()
 
  1238             if isinstance(element, SFC_Transition) and specific_values["condition_type"] == "connection":
 
  1237             if isinstance(element, SFC_Transition) and specific_values.condition_type == "connection":
 
  1239                 connector = element.GetConditionConnector()
 
  1238                 connector = element.GetConditionConnector()
 
  1240                 self.CreateWires(connector, instance["id"], specific_values["connection"]["links"], ids, selection)
 
  1239                 self.CreateWires(connector, instance.id, specific_values.connection.links, remaining_instances, selection)
 
  1241         else:
 
  1240         else:
 
  1242             executionControl = False
 
  1241             executionControl = False
 
  1243             for input in instance["inputs"]:
 
  1242             for input in instance.inputs:
 
  1244                 if input["negated"]:
 
  1243                 input_edge = MODIFIER_VALUE(input.edge)
 
  1245                     connectors["inputs"].append((input["name"], None, "negated"))
 
  1244                 if input.negated:
 
  1246                 elif input["edge"]:
 
  1245                     connectors["inputs"].append((input.name, None, "negated"))
 
  1247                     connectors["inputs"].append((input["name"], None, input["edge"]))
 
  1246                 elif input_edge:
 
       
  1247                     connectors["inputs"].append((input.name, None, input_edge))
 
  1248                 else:
 
  1248                 else:
 
  1249                     connectors["inputs"].append((input["name"], None, "none"))
 
  1249                     connectors["inputs"].append((input.name, None, "none"))
 
  1250             for output in instance["outputs"]:
 
  1250             for output in instance.outputs:
 
  1251                 if output["negated"]:
 
  1251                 output_edge = MODIFIER_VALUE(output.edge)
 
  1252                     connectors["outputs"].append((output["name"], None, "negated"))
 
  1252                 if output.negated:
 
  1253                 elif output["edge"]:
 
  1253                     connectors["outputs"].append((output.name, None, "negated"))
 
  1254                     connectors["outputs"].append((output["name"], None, output["edge"]))
 
  1254                 elif output_edge:
 
       
  1255                     connectors["outputs"].append((output.name, None, output_edge))
 
  1255                 else:
 
  1256                 else:
 
  1256                     connectors["outputs"].append((output["name"], None, "none"))
 
  1257                     connectors["outputs"].append((output.name, None, "none"))
 
  1257             if len(connectors["inputs"]) > 0 and connectors["inputs"][0][0] == "EN":
 
  1258             if len(connectors["inputs"]) > 0 and connectors["inputs"][0][0] == "EN":
 
  1258                 connectors["inputs"].pop(0)
 
  1259                 connectors["inputs"].pop(0)
 
  1259                 executionControl = True
 
  1260                 executionControl = True
 
  1260             if len(connectors["outputs"]) > 0 and connectors["outputs"][0][0] == "ENO":
 
  1261             if len(connectors["outputs"]) > 0 and connectors["outputs"][0][0] == "ENO":
 
  1261                 connectors["outputs"].pop(0)
 
  1262                 connectors["outputs"].pop(0)
 
  1262                 executionControl = True
 
  1263                 executionControl = True
 
  1263             if specific_values["name"] is None:
 
  1264             block_name = specific_values.name if specific_values.name is not None else ""
 
  1264                 specific_values["name"] = ""
 
  1265             element = FBD_Block(self, instance.type, block_name, 
  1265             element = FBD_Block(self, instance["type"], specific_values["name"], 
  1266                       instance.id, len(connectors["inputs"]), 
  1266                       instance["id"], len(connectors["inputs"]), 
       
  1267                       connectors=connectors, executionControl=executionControl, 
  1267                       connectors=connectors, executionControl=executionControl, 
  1268                       executionOrder=specific_values["executionOrder"])
 
  1268                       executionOrder=specific_values.execution_order)
 
  1269         if isinstance(element, Comment):
 
  1269         if isinstance(element, Comment):
 
  1270             self.AddComment(element)
 
  1270             self.AddComment(element)
 
  1271         else:
 
  1271         else:
 
  1272             self.AddBlock(element)
 
  1272             self.AddBlock(element)
 
  1273             connectors = element.GetConnectors()
 
  1273             connectors = element.GetConnectors()
 
  1274         element.SetPosition(instance["x"], instance["y"])
 
  1274         element.SetPosition(instance.x, instance.y)
 
  1275         element.SetSize(instance["width"], instance["height"])
 
  1275         element.SetSize(instance.width, instance.height)
 
  1276         for i, output_connector in enumerate(instance["outputs"]):
 
  1276         for i, output_connector in enumerate(instance.outputs):
 
       
  1277             connector_pos = wx.Point(*output_connector.position)
 
  1277             if isinstance(element, FBD_Block):
 
  1278             if isinstance(element, FBD_Block):
 
  1278                 connector = element.GetConnector(
 
  1279                 connector = element.GetConnector(connector_pos,
 
  1279                     wx.Point(*output_connector["position"]),
 
  1280                     output_name = output_connector.name)
 
  1280                     output_name = output_connector["name"])
 
       
  1281             elif i < len(connectors["outputs"]):
 
  1281             elif i < len(connectors["outputs"]):
 
  1282                 connector = connectors["outputs"][i]
 
  1282                 connector = connectors["outputs"][i]
 
  1283             else:
 
  1283             else:
 
  1284                 connector = None
 
  1284                 connector = None
 
  1285             if connector is not None:
 
  1285             if connector is not None:
 
  1286                 if output_connector.get("negated", False):
 
  1286                 if output_connector.negated:
 
  1287                     connector.SetNegated(True)
 
  1287                     connector.SetNegated(True)
 
  1288                 if output_connector.get("edge", "none") != "none":
 
  1288                 if output_connector.edge is not None:
 
  1289                     connector.SetEdge(output_connector["edge"])
 
  1289                     connector.SetEdge(output_connector.edge)
 
  1290                 if connectors["outputs"].index(connector) == i:
 
  1290                 if connectors["outputs"].index(connector) == i:
 
  1291                     connector.SetPosition(wx.Point(*output_connector["position"]))
 
  1291                     connector.SetPosition(connector_pos)
 
  1292         for i, input_connector in enumerate(instance["inputs"]):
 
  1292         for i, input_connector in enumerate(instance.inputs):
 
       
  1293             connector_pos = wx.Point(*input_connector.position)
 
  1293             if isinstance(element, FBD_Block):
 
  1294             if isinstance(element, FBD_Block):
 
  1294                 connector = element.GetConnector(
 
  1295                 connector = element.GetConnector(connector_pos,
 
  1295                     wx.Point(*input_connector["position"]),
 
  1296                     input_name = input_connector.name)
 
  1296                     input_name = input_connector["name"])
 
       
  1297             elif i < len(connectors["inputs"]):
 
  1297             elif i < len(connectors["inputs"]):
 
  1298                 connector = connectors["inputs"][i]
 
  1298                 connector = connectors["inputs"][i]
 
  1299             else:
 
  1299             else:
 
  1300                 connector = None
 
  1300                 connector = None
 
  1301             if connector is not None:
 
  1301             if connector is not None:
 
  1302                 if connectors["inputs"].index(connector) == i:
 
  1302                 if connectors["inputs"].index(connector) == i:
 
  1303                     connector.SetPosition(wx.Point(*input_connector["position"]))
 
  1303                     connector.SetPosition(connector_pos)
 
  1304                 if input_connector.get("negated", False):
 
  1304                 if input_connector.negated:
 
  1305                     connector.SetNegated(True)
 
  1305                     connector.SetNegated(True)
 
  1306                 if input_connector.get("edge", "none") != "none":
 
  1306                 if input_connector.edge is not None:
 
  1307                     connector.SetEdge(input_connector["edge"])
 
  1307                     connector.SetEdge(input_connector.edge)
 
  1308                 if not self.CreateWires(connector, instance["id"], input_connector["links"], ids, selection):
 
  1308                 if not self.CreateWires(connector, instance.id, input_connector.links, remaining_instances, selection):
 
  1309                     element.RefreshModel()
 
  1309                     element.RefreshModel()
 
  1310         element.RefreshConnectors()
 
  1310         element.RefreshConnectors()
 
  1311         if selection is not None and selection[0].get(instance["id"], False):
 
  1311         if selection is not None and selection[0].get(instance.id, False):
 
  1312             self.SelectInGroup(element)
 
  1312             self.SelectInGroup(element)
 
  1313 
  1313 
  1314     def CreateWires(self, start_connector, id, links, ids, selection=None):
 
  1314     def CreateWires(self, start_connector, id, links, remaining_instances, selection=None):
 
  1315         links_connected = True
 
  1315         links_connected = True
 
  1316         for link in links:
 
  1316         for link in links:
 
  1317             refLocalId = link["refLocalId"]
 
  1317             refLocalId = link.refLocalId
 
  1318             if refLocalId is None:
 
  1318             if refLocalId is None:
 
  1319                 links_connected = False
 
  1319                 links_connected = False
 
  1320                 continue
 
  1320                 continue
 
  1321             
  1321             
  1322             if refLocalId not in ids:
 
  1322             new_instance = remaining_instances.pop(refLocalId, None)
 
  1323                 new_instance = self.Controler.GetEditedElementInstanceInfos(self.TagName, refLocalId, debug = self.Debug)
 
  1323             if new_instance is not None:
 
  1324                 if new_instance is not None:
 
  1324                 self.loadInstance(new_instance, remaining_instances, selection)
 
  1325                     self.loadInstance(new_instance, ids, selection)
 
       
  1326             
  1325             
  1327             connected = self.FindElementById(refLocalId)
 
  1326             connected = self.FindElementById(refLocalId)
 
  1328             if connected is None:
 
  1327             if connected is None:
 
  1329                 links_connected = False
 
  1328                 links_connected = False
 
  1330                 continue
 
  1329                 continue
 
  1331             
  1330             
  1332             points = link["points"]
 
  1331             points = link.points
 
  1333             end_connector = connected.GetConnector(wx.Point(points[-1][0], points[-1][1]), link["formalParameter"])
 
  1332             end_connector = connected.GetConnector(
 
       
  1333                 wx.Point(points[-1].x, points[-1].y)
 
       
  1334                 if len(points) > 0 else wx.Point(0, 0), 
       
  1335                 link.formalParameter)
 
  1334             if end_connector is not None:
 
  1336             if end_connector is not None:
 
  1335                 wire = Wire(self)
 
  1337                 if len(points) > 0:
 
  1336                 wire.SetPoints(points)
 
  1338                     wire = Wire(self)
 
  1337                 start_connector.Connect((wire, 0), False)
 
  1339                     wire.SetPoints(points)
 
  1338                 end_connector.Connect((wire, -1), False)
 
  1340                 else:
 
  1339                 wire.ConnectStartPoint(None, start_connector)
 
  1341                     wire = Wire(self,
 
  1340                 wire.ConnectEndPoint(None, end_connector)
 
  1342                         [wx.Point(*start_connector.GetPosition()), 
       
  1343                          start_connector.GetDirection()],
 
       
  1344                         [wx.Point(*end_connector.GetPosition()),
 
       
  1345                          end_connector.GetDirection()])
 
       
  1346                 start_connector.Wires.append((wire, 0))
 
       
  1347                 end_connector.Wires.append((wire, -1))
 
       
  1348                 wire.StartConnected = start_connector
 
       
  1349                 wire.EndConnected = end_connector
 
  1341                 connected.RefreshConnectors()
 
  1350                 connected.RefreshConnectors()
 
  1342                 self.AddWire(wire)
 
  1351                 self.AddWire(wire)
 
  1343                 if selection is not None and (\
 
  1352                 if selection is not None and (\
 
  1344                    selection[1].get((id, refLocalId), False) or \
 
  1353                    selection[1].get((id, refLocalId), False) or \
 
  1345                    selection[1].get((refLocalId, id), False)):
 
  1354                    selection[1].get((refLocalId, id), False)):
 
  2212                         self.SelectedElement.HighlightPoint(pos)
 
  2221                         self.SelectedElement.HighlightPoint(pos)
 
  2213                 else:
 
  2222                 else:
 
  2214                     movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
  2223                     movex, movey = self.SelectedElement.OnMotion(event, dc, self.Scaling)
 
  2215                     if movex != 0 or movey != 0:
 
  2224                     if movex != 0 or movey != 0:
 
  2216                         self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(movex, movey)), False)
 
  2225                         self.RefreshRect(self.GetScrolledRect(self.SelectedElement.GetRedrawRect(movex, movey)), False)
 
  2217                     self.RefreshVisibleElements()
 
       
  2218             elif self.Debug and self.StartMousePos is not None and event.Dragging():
 
  2226             elif self.Debug and self.StartMousePos is not None and event.Dragging():
 
  2219                 pos = event.GetPosition()
 
  2227                 pos = event.GetPosition()
 
  2220                 if abs(self.StartMousePos.x - pos.x) > 5 or abs(self.StartMousePos.y - pos.y) > 5:
 
  2228                 if abs(self.StartMousePos.x - pos.x) > 5 or abs(self.StartMousePos.y - pos.y) > 5:
 
  2221                     element = self.SelectedElement
 
  2229                     element = self.SelectedElement
 
  2222                     if isinstance(self.SelectedElement, FBD_Block):
 
  2230                     if isinstance(self.SelectedElement, FBD_Block):
 
  2421                     values["extension"], values["inputs"], 
  2429                     values["extension"], values["inputs"], 
  2422                     executionControl = values["executionControl"],
 
  2430                     executionControl = values["executionControl"],
 
  2423                     executionOrder = values["executionOrder"])
 
  2431                     executionOrder = values["executionOrder"])
 
  2424             self.Controler.AddEditedElementBlock(self.TagName, id, values["type"], values.get("name", None))
 
  2432             self.Controler.AddEditedElementBlock(self.TagName, id, values["type"], values.get("name", None))
 
  2425             connector = None
 
  2433             connector = None
 
  2426             for input_connector in block.GetConnectors()["inputs"]:
 
  2434             if wire is not None:
 
  2427                 if input_connector.IsCompatible(
 
  2435                 for input_connector in block.GetConnectors()["inputs"]:
 
  2428                         wire.GetStartConnectedType()):
 
  2436                     if input_connector.IsCompatible(
 
  2429                     connector = input_connector
 
  2437                             wire.GetStartConnectedType()):
 
  2430                     break
 
  2438                         connector = input_connector
 
       
  2439                         break
 
  2431             self.AddNewElement(block, bbox, wire, connector)
 
  2440             self.AddNewElement(block, bbox, wire, connector)
 
  2432         dialog.Destroy()
 
  2441         dialog.Destroy()
 
  2433     
  2442     
  2434     def AddNewVariable(self, bbox, exclude_input=False, wire=None):
 
  2443     def AddNewVariable(self, bbox, exclude_input=False, wire=None):
 
  2435         dialog = FBDVariableDialog(self.ParentWindow, self.Controler, self.TagName, exclude_input)
 
  2444         dialog = FBDVariableDialog(self.ParentWindow, self.Controler, self.TagName, exclude_input)
 
  2608 
  2617 
  2609     def AddNewActionBlock(self, bbox, wire=None):
 
  2618     def AddNewActionBlock(self, bbox, wire=None):
 
  2610         dialog = ActionBlockDialog(self.ParentWindow)
 
  2619         dialog = ActionBlockDialog(self.ParentWindow)
 
  2611         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  2620         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  2612         dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
 
  2621         dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
 
  2613         dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 
  2622         dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, debug=self.Debug))
 
  2614         if dialog.ShowModal() == wx.ID_OK:
 
  2623         if dialog.ShowModal() == wx.ID_OK:
 
  2615             id = self.GetNewId()
 
  2624             id = self.GetNewId()
 
  2616             actionblock = SFC_ActionBlock(self, dialog.GetValues(), id)
 
  2625             actionblock = SFC_ActionBlock(self, dialog.GetValues(), id)
 
  2617             self.Controler.AddEditedElementActionBlock(self.TagName, id)
 
  2626             self.Controler.AddEditedElementActionBlock(self.TagName, id)
 
  2618             self.AddNewElement(actionblock, bbox, wire)
 
  2627             self.AddNewElement(actionblock, bbox, wire)
 
  2858 
  2867 
  2859     def EditActionBlockContent(self, actionblock):
 
  2868     def EditActionBlockContent(self, actionblock):
 
  2860         dialog = ActionBlockDialog(self.ParentWindow)
 
  2869         dialog = ActionBlockDialog(self.ParentWindow)
 
  2861         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  2870         dialog.SetQualifierList(self.Controler.GetQualifierTypes())
 
  2862         dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
 
  2871         dialog.SetActionList(self.Controler.GetEditedElementActions(self.TagName, self.Debug))
 
  2863         dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug))
 
  2872         dialog.SetVariableList(self.Controler.GetEditedElementInterfaceVars(self.TagName, debug=self.Debug))
 
  2864         dialog.SetValues(actionblock.GetActions())
 
  2873         dialog.SetValues(actionblock.GetActions())
 
  2865         if dialog.ShowModal() == wx.ID_OK:
 
  2874         if dialog.ShowModal() == wx.ID_OK:
 
  2866             actions = dialog.GetValues()
 
  2875             actions = dialog.GetValues()
 
  2867             rect = actionblock.GetRedrawRect(1, 1)
 
  2876             rect = actionblock.GetRedrawRect(1, 1)
 
  2868             actionblock.SetActions(actions)
 
  2877             actionblock.SetActions(actions)
 
  3456                 yp = max(0, min(y - rotation * 3, self.Editor.GetVirtualSize()[1] / self.Editor.GetScrollPixelsPerUnit()[1]))
 
  3465                 yp = max(0, min(y - rotation * 3, self.Editor.GetVirtualSize()[1] / self.Editor.GetScrollPixelsPerUnit()[1]))
 
  3457                 self.RefreshVisibleElements(yp = yp)
 
  3466                 self.RefreshVisibleElements(yp = yp)
 
  3458                 self.Scroll(x, yp)
 
  3467                 self.Scroll(x, yp)
 
  3459             
  3468             
  3460     def OnMoveWindow(self, event):
 
  3469     def OnMoveWindow(self, event):
 
  3461         self.RefreshScrollBars()
 
  3470         client_size = self.GetClientSize()
 
  3462         self.RefreshVisibleElements()
 
  3471         if self.LastClientSize != client_size:
 
       
  3472             self.LastClientSize = client_size
 
       
  3473             self.RefreshScrollBars()
 
       
  3474             self.RefreshVisibleElements()
 
  3463         event.Skip()
 
  3475         event.Skip()
 
  3464 
  3476 
  3465     def DoDrawing(self, dc, printing = False):
 
  3477     def DoDrawing(self, dc, printing = False):
 
  3466         if printing:
 
  3478         if printing:
 
  3467             if getattr(dc, "printing", False):
 
  3479             if getattr(dc, "printing", False):
beremiz