plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:b22f661cbcfb
+:c798a68c5560
 self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False)
 self.Buffering = False
 # Return project pou names
 def GetProjectPouNames(self):
-return [pou.getName() for pou in self.Project.getPous()]
+if self.Project:
+return [pou.getName() for pou in self.Project.getPous()]
+return []
 # Return project pou names
 def GetProjectConfigNames(self):
-return [config.getName() for config in self.Project.getConfigurations()]
+if self.Project:
+return [config.getName() for config in self.Project.getConfigurations()]
+return []
 # Return project pou variables
 def GetProjectPouVariables(self, pou_name=None):
 variables = []
 for pou in self.Project.getPous():
 # Add a Pou to Project
 def ProjectAddPou(self, name, pou_type, body_type):
 # Add the pou to project
 self.Project.appendPou(name, pou_type, body_type)
+self.SetPouInterfaceReturnType(name, "BOOL")
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 # Remove a pou from project
 def ChangePouName(self, old_name, new_name):
 # Found the pou corresponding to old name and change its name to new name
 pou = self.Project.getPou(old_name)
 pou.setName(new_name)
 # If pou is currently opened, change its name in the list of opened pous
-if old_name in self.ElementsOpened:
+for idx, element in enumerate(self.ElementsOpened):
-idx = self.ElementsOpened.index(old_name)
+words = element.split("::")
-self.ElementsOpened[idx] = new_name
+if words[0] in ["P","T","A"] and words[1] == old_name:
+if words[0] == "P":
+self.ElementsOpened[idx] = self.ComputePouName(new_name)
+elif words[0] == "T":
+self.ElementsOpened[idx] = self.ComputePouTransitionName(new_name, words[2])
+else:
+self.ElementsOpened[idx] = self.ComputePouActionName(new_name, words[2])
 self.Project.updateElementName(old_name, new_name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 self.BufferProject()
 if old_computedname in self.ElementsOpened:
 idx = self.ElementsOpened.index(old_computedname)
 self.ElementsOpened[idx] = new_computedname
 self.BufferProject()
-# Change the name of a pou action
+# Change the name of a pou variable
 def ChangePouVariableName(self, pou_name, old_name, new_name):
 # Found the pou action corresponding to old name and change its name to new name
 pou = self.Project.getPou(pou_name)
 for type, varlist in pou.getVars():
 for var in varlist.getVariable():
 # Found the configuration corresponding to old name and change its name to new name
 configuration = self.Project.getConfiguration(old_name)
 configuration.setName(new_name)
 # If configuration is currently opened, change its name in the list of opened elements
 for idx, element in enumerate(self.ElementsOpened):
-self.ElementsOpened[idx] = element.replace(old_name, new_name)
+words = element.split("::")
+if words[0] in ["C","R"] and words[1] == old_name:
+if words[0] == "C":
+self.ElementsOpened[idx] = self.ComputeConfigurationName(new_name)
+else:
+self.ElementsOpened[idx] = self.ComputeConfigurationResourceName(new_name, words[2])
 self.BufferProject()
 # Change the name of a configuration resource
 def ChangeConfigurationResourceName(self, config_name, old_name, new_name):
 # Found the resource corresponding to old name and change its name to new name
 name = ""
 type = None
 if type == "function":
 blocktypes = []
 for category in BlockTypes[:-1]:
-if category["name"] != "SVGUI function blocks":
+cat = {"name" : category["name"], "list" : []}
-cat = {"name" : category["name"], "list" : []}
+for block in category["list"]:
-for block in category["list"]:
+if block["type"] == "function":
-if block["type"] == "function":
+cat["list"].append(block)
-cat["list"].append(block)
+if len(cat["list"]) > 0:
-if len(cat["list"]) > 0:
+blocktypes.append(cat)
-blocktypes.append(cat)
 else:
-blocktypes = [category for category in BlockTypes[:-1] if category["name"] != "SVGUI function blocks"]
+blocktypes = [category for category in BlockTypes[:-1]]
 if self.Project:
 blocktypes.append({"name" : "User-defined POUs", "list": []})
 for blocktype in BlockTypes[-1]["list"]:
 if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
 blocktypes[-1]["list"].append(blocktype)
 # Return Function Block types checking for recursion
 def GetFunctionBlockTypes(self):
 if self.CurrentElementEditing != None:
 if self.Project:
 current_name = self.ElementsOpened[self.CurrentElementEditing]
+print current_name
 words = current_name.split("::")
 if len(words) == 1:
 name = current_name
 else:
 name = words[1]
 else:
 name = ""
 type = None
 blocktypes = []
 for category in BlockTypes[:-1]:
-if category["name"] != "SVGUI function blocks":
+for block in category["list"]:
-for block in category["list"]:
+if block["type"] != "function":
-if block["type"] != "function":
+blocktypes.append(block["name"])
-blocktypes.append(block["name"])
 if self.Project:
 for blocktype in BlockTypes[-1]["list"]:
 if blocktype["name"] != name and not self.PouIsUsedBy(name, blocktype["name"]) and not (type == "function" and blocktype["type"] != "function"):
 blocktypes.append(blocktype["name"])
 return blocktypes
 # Return the list of pou names
 def GetElementsOpenedNames(self):
 names = []
 for pou_name in self.ElementsOpened:
 words = pou_name.split("::")
-if len(words) == 1:
+if words[0] in ["P","C"]:
-names.append(pou_name)
-elif len(words) == 2:
 names.append(words[1])
 else:
 names.append("%s-%s"%(words[1],words[2]))
 return names
+# Compute a pou transition name
+def ComputePouName(self, pou):
+return "P::%s" % pou
 # Compute a pou transition name
 def ComputePouTransitionName(self, pou, transition):
 return "T::%s::%s" % (pou, transition)
 self.CurrentElementEditing = len(self.ElementsOpened) - 1
 return self.CurrentElementEditing
 return None
 # Open a pou transition by giving pou and transition names
+def OpenPouEditing(self, pou):
+return self.OpenElementEditing(self.ComputePouName(pou))
+# Open a pou transition by giving pou and transition names
 def OpenPouTransitionEditing(self, pou, transition):
 return self.OpenElementEditing(self.ComputePouTransitionName(pou, transition))
 # Open a pou action by giving pou and action names
 def OpenPouActionEditing(self, pou, action):
 # Open a configuration resource by giving configuration and resource names
 def OpenConfigurationResourceEditing(self, config, resource):
 return self.OpenElementEditing(self.ComputeConfigurationResourceName(config, resource))
 # Return if pou given by name is opened
-def IsElementEditing(self, name):
+def IsPouEditing(self, pou):
-return name in self.ElementsOpened
+return self.ComputePouName(pou) in self.ElementsOpened
 # Return if pou transition given by pou and transition names is opened
 def IsPouTransitionEditing(self, pou, transition):
 return self.ComputePouTransitionName(pou, transition) in self.ElementsOpened
 # Return if pou action given by pou and action names is opened
 def IsPouActionEditing(self, pou, action):
 return self.ComputePouActionName(pou, action) in self.ElementsOpened
 # Return if pou action given by configuration name is opened
-def IsConfigurationEditing(self, pou):
+def IsConfigurationEditing(self, config):
 return self.ComputeConfigurationName(config) in self.ElementsOpened
 # Return if pou action given by configuration and resource names is opened
-def IsConfigurationResourceEditing(self, pou, resource):
+def IsConfigurationResourceEditing(self, config, resource):
 return self.ComputeConfigurationResourceName(config, resource) in self.ElementsOpened
-# Close current pou editing
+# Close current element editing
 def CloseElementEditing(self):
 # Remove pou from list of pou opened
 self.ElementsOpened.pop(self.CurrentElementEditing)
-# Update index of current pou editing
+# Update index of current element editing
 if len(self.ElementsOpened) > 0:
 self.CurrentElementEditing = min(self.CurrentElementEditing, len(self.ElementsOpened) - 1)
 else:
 self.CurrentElementEditing = None
-# Change current pou editing for pou given by name
+# Change current element editing for pou given by name
 def ChangeElementEditing(self, name):
-# Verify that pou is opened
+# Verify that element is opened
 if name in self.ElementsOpened:
-# Change current pou editing
+# Change current element editing
 self.CurrentElementEditing = self.ElementsOpened.index(name)
 return self.CurrentElementEditing
 return None
-# Change current pou editing for transition given by pou and transition names
+# Change current element editing for pou given by pou name
+def ChangePouEditing(self, pou):
+return self.ChangeElementEditing(self.ComputePouName(pou))
+# Change current element editing for transition given by pou and transition names
 def ChangePouTransitionEditing(self, pou, transition):
 return self.ChangeElementEditing(self.ComputePouTransitionName(pou, transition))
-# Change current pou editing for action given by pou and action names
+# Change current element editing for action given by pou and action names
 def ChangePouActionEditing(self, pou, action):
 return self.ChangeElementEditing(self.ComputePouActionName(pou, action))
-# Change current pou editing for action given by configuration name
+# Change current element editing for configuration given by configuration name
 def ChangeConfigurationEditing(self, config):
 return self.ChangeElementEditing(self.ComputeConfigurationName(config))
-# Change current pou editing for action given by configuration and resource names
+# Change current element editing for resource given by configuration and resource names
 def ChangeConfigurationResourceEditing(self, config, resource):
 return self.ChangeElementEditing(self.ComputeConfigurationResourceName(config, resource))
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 def GetCurrentElementEditing(self):
 # Verify that there's one editing and return it
 if self.CurrentElementEditing != None:
 name = self.ElementsOpened[self.CurrentElementEditing]
 words = name.split("::")
-if len(words) == 1:
+if words[0] == "P":
-return self.Project.getPou(name)
+return self.Project.getPou(words[1])
-else:
+if words[0] in ['T', 'A']:
-if words[0] in ['T', 'A']:
+pou = self.Project.getPou(words[1])
-pou = self.Project.getPou(words[1])
+if words[0] == 'T':
-if words[0] == 'T':
+return pou.getTransition(words[2])
-return pou.getTransition(words[2])
+elif words[0] == 'A':
-elif words[0] == 'A':
+return pou.getAction(words[2])
-return pou.getAction(words[2])
+elif words[0] == 'C':
-elif words[0] == 'C':
+return self.Project.getConfiguration(words[1])
-result = self.Project.getConfiguration(words[1])
+elif words[0] == 'R':
-return result
+return self.Project.getConfigurationResource(words[1], words[2])
-elif words[0] == 'R':
-result = self.Project.getConfigurationResource(words[1], words[2])
-return result
 return None
 # Return current pou editing name
 def GetCurrentElementEditingName(self):
 # Verify that there's one editing and return its name
 if self.CurrentElementEditing != None:
 name = self.ElementsOpened[self.CurrentElementEditing]
 words = name.split("::")
-if len(words) == 1:
+if words[0] in ["P","C"]:
-return name
-elif len(words) == 2:
 return words[1]
 else:
 return words[2]
 return None
 # Return language in which current pou editing is written
 def GetCurrentElementEditingType(self):
 if self.CurrentElementEditing != None:
 name = self.ElementsOpened[self.CurrentElementEditing]
 words = name.split("::")
-if len(words) == 1:
+if words[0] == "P":
-return self.GetPouType(name)
-elif len(words) == 2:
-return None
-elif words[0] != "R":
 return self.GetPouType(words[1])
 return None
 # Return language in which current pou editing is written
 def GetCurrentElementEditingBodyType(self):
 if self.CurrentElementEditing != None:
 name = self.ElementsOpened[self.CurrentElementEditing]
 words = name.split("::")
-if len(words) == 1:
+if words[0] == "P":
-return self.GetPouBodyType(name)
+return self.GetPouBodyType(words[1])
-else:
+elif words[0] == 'T':
-if words[0] == 'T':
+return self.GetTransitionBodyType(words[1], words[2])
-return self.GetTransitionBodyType(words[1], words[2])
+elif words[0] == 'A':
-elif words[0] == 'A':
+return self.GetActionBodyType(words[1], words[2])
-return self.GetActionBodyType(words[1], words[2])
 return None
 # Return the variables of the current pou editing
 def GetCurrentElementEditingInterfaceVars(self):
 if self.CurrentElementEditing != None:
 current_name = self.ElementsOpened[self.CurrentElementEditing]
 words = current_name.split("::")
-if len(words) == 1:
+if words[0] in ["P","T","A"]:
-pou = self.Project.getPou(current_name)
-return self.GetPouInterfaceVars(pou)
-else:
 pou = self.Project.getPou(words[1])
 return self.GetPouInterfaceVars(pou)
 return []
 # Return the return type of the current pou editing
 def GetCurrentElementEditingInterfaceReturnType(self):
 if self.CurrentElementEditing != None:
 current_name = self.ElementsOpened[self.CurrentElementEditing]
 words = current_name.split("::")
-if len(words) == 1:
+if words[0] == "P":
-pou = self.Project.getPou(current_name)
+pou = self.Project.getPou(words[1])
 return self.GetPouInterfaceReturnType(pou)
 elif words[0] == 'T':
 return "BOOL"
 return None
 # Return the names of the pou elements
 def GetCurrentElementEditingVariables(self):
 if self.CurrentElementEditing != None:
 current_name = self.ElementsOpened[self.CurrentElementEditing]
 words = current_name.split("::")
-if len(words) == 1:
+if words[0] in ["P","T","A"]:
-return self.GetProjectPouVariables(current_name)
-else:
 return self.GetProjectPouVariables(words[1])
 return []
 # Return the current pou editing informations
 def GetCurrentElementEditingInstanceInfos(self, id = None, exclude = []):
 if instance.connectionPointOutAction:
 infos["connectors"]["action"] = {"position" : instance.connectionPointOutAction.getRelPosition()}
 elif isinstance(instance, plcopen.transition):
 infos["type"] = "transition"
 condition = instance.getConditionContent()
+priority = instance.getPriority()
+if priority == None:
+infos["priority"] = 0
+else:
+infos["priority"] = priority
 infos["condition_type"] = condition["type"]
 infos["connectors"] = {"input":{},"output":{}}
 infos["connectors"]["input"]["position"] = instance.connectionPointIn.getRelPosition()
 infos["connectors"]["input"]["links"] = []
 connections = instance.connectionPointIn.getConnections()
 # Return the variable type of the given pou
 def GetCurrentPouVarValueType(self, varname):
 current_name = self.ElementsOpened[self.CurrentElementEditing]
 words = current_name.split("::")
-if len(words) == 1:
+if words[0] in ["P","T","A"]:
-pou = self.Project.getPou(current_name)
-else:
 pou = self.Project.getPou(words[1])
 for type, varlist in pou.getVars():
 for var in varlist.getVariable():
 if var.getName() == varname:
 return var.getType()
 return ""
 def SetConnectionWires(self, connection, connector):
 wires = connector.GetWires()
 idx = 0
 blocktype_infos = GetBlockType(blocktype)
 if blocktype_infos["type"] != "function":
 if self.CurrentElementEditing != None:
 name = self.ElementsOpened[self.CurrentElementEditing]
 words = name.split("::")
-if len(words) == 1:
+if words[0] in ["P","T","A"]:
-element.addPouVar(blocktype, blockname)
-elif words[0] in ['T', 'A']:
 pou = self.Project.getPou(words[1])
 pou.addPouVar(blocktype, blockname)
 element.addInstance("block", block)
 self.RefreshPouUsingTree()
 transition.setWidth(value)
 elif param == "x":
 transition.setX(value)
 elif param == "y":
 transition.setY(value)
+elif param == "priority":
+if value != 0:
+transition.setPriority(value)
+else:
+transition.setPriority(None)
 elif param == "connectors":
 input_connector = value["input"]
 position = input_connector.GetRelPosition()
 transition.addConnectionPointIn()
 transition.connectionPointIn.setRelPosition(position.x, position.y)

changeset 80	c798a68c5560
parent 71	0578bc212c20
child 81	11ca9ad9e3c3