plcopeneditor_history: comparison PLCControler.py

equal deleted inserted replaced

-:e24d2f917c7e
+:7187e1c00975
 # Reset PLCControler internal variables
 def Reset(self):
 self.VerifyXML = False
 self.Project = None
 self.ProjectBuffer = None
+self.Buffering = False
 self.FilePath = ""
 self.FileName = ""
 self.ProgramFilePath = ""
 self.ElementsOpened = []
 self.CurrentElementEditing = None
 # Create a new project by replacing the current one
 def CreateNewProject(self, name):
 # Create the project
 self.Project = plcopen.project()
 self.Project.setName(name)
+self.SetFilePath("")
 # Initialize the project buffer
-#self.ProjectBuffer = UndoBuffer(self.Copy(self.Project))
+self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), False)
+self.Buffering = False
-# Change project name
-def SetProjectName(self, name):
-self.Project.setName(name)
-# Return project name
-def GetProjectName(self):
-return self.Project.getName()
 # Return project pou names
 def GetProjectPouNames(self):
 return [pou.getName() for pou in self.Project.getPous()]
 variables.append(transition.getName())
 for action in pou.getActionList():
 variables.append(action.getName())
 return variables
+# Return if project is saved
+def ProjectIsSaved(self):
+return self.ProjectBuffer.IsCurrentSaved()
 # Return file path if project is an open file
 def GetFilePath(self):
 return self.FilePath
 # Return file path if project is an open file
 self.FileName = "Unnamed%d"%self.LastNewIndex
 else:
 self.FileName = os.path.splitext(os.path.basename(filepath))[0]
 # Change project properties
-def SetProjectProperties(self, values):
+def SetProjectProperties(self, name = None, properties = None):
-self.Project.setFileHeader(values)
+if name != None:
+self.Project.setName(name)
+if properties != None:
+self.Project.setFileHeader(properties)
+if name != None or properties != None:
+self.BufferProject()
 # Return project properties
 def GetProjectProperties(self):
-return self.Project.getFileHeader()
+properties = self.Project.getFileHeader()
+properties["projectName"] = self.Project.getName()
+return properties
 # Return project informations
 def GetProjectInfos(self):
 if self.Project:
 infos = {"name": self.Project.getName(), "type": ITEM_PROJECT}
 return used
 return False
 def GenerateProgram(self, filepath):
 if self.Project:
-#try:
+try:
 program = GenerateCurrentProgram(self.Project)
 programfile = open(filepath, "w")
 programfile.write(program)
 programfile.close()
 self.ProgramFilePath = filepath
 return True
-#except:
+except:
-#    pass
+pass
 return False
 #-------------------------------------------------------------------------------
 #                        Project Pous management functions
 #-------------------------------------------------------------------------------
 def ProjectAddPou(self, name, pou_type, body_type):
 # Add the pou to project
 self.Project.appendPou(name, pou_type, body_type)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Remove a pou from project
 def ProjectRemovePou(self, name):
 removed = None
 # Search if the pou removed is currently opened
 self.CurrentElementEditing = None
 # Remove pou from project
 self.Project.removePou(name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Add a configuration to Project
 def ProjectAddConfiguration(self, name):
 self.Project.addConfiguration(name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Remove a configuration from project
 def ProjectRemoveConfiguration(self, name):
 self.Project.removeConfiguration(name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Add a resource to a configuration of the Project
 def ProjectAddConfigurationResource(self, config, name):
 self.Project.addConfigurationResource(config, name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Remove a resource from a configuration of the project
 def ProjectRemoveConfigurationResource(self, config, name):
 self.Project.removeConfigurationResource(config, name)
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Add a Transition to a Project Pou
 def ProjectAddPouTransition(self, pou_name, transition_name, transition_type):
 pou = self.Project.getPou(pou_name)
 pou.addTransition(transition_name, transition_type)
+self.BufferProject()
 # Add a Transition to a Project Pou
 def ProjectAddPouAction(self, pou_name, action_name, action_type):
 pou = self.Project.getPou(pou_name)
 pou.addAction(action_name, action_type)
+self.BufferProject()
 # Change the name of a pou
 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)
 if old_name in self.ElementsOpened:
 idx = self.ElementsOpened.index(old_name)
 self.ElementsOpened[idx] = new_name
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
+self.BufferProject()
 # Change the name of a pou transition
 def ChangePouTransitionName(self, pou_name, old_name, new_name):
 # Found the pou transition corresponding to old name and change its name to new name
 pou = self.Project.getPou(pou_name)
 old_computedname = self.ComputePouTransitionName(pou_name, old_name)
 new_computedname = self.ComputePouTransitionName(pou_name, new_name)
 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
 def ChangePouActionName(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)
 old_computedname = self.ComputePouActionName(pou_name, old_name)
 new_computedname = self.ComputePouActionName(pou_name, new_name)
 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
 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():
 if var.getName() == old_name:
 var.setName(new_name)
 self.RefreshBlockTypes()
+self.BufferProject()
 # Change the name of a configuration
 def ChangeConfigurationName(self, old_name, new_name):
 # 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)
+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
 resource = self.Project.getConfigurationResource(config_name)
 resource.setName(new_name)
 old_computedname = self.ComputeConfigurationResourceName(config_name, old_name)
 new_computedname = self.ComputeConfigurationResourceName(config_name, new_name)
 if old_computedname in self.ElementsOpened:
 idx = self.ElementsOpened.index(old_computedname)
 self.ElementsOpened[idx] = new_computedname
+self.BufferProject()
 # Return the type of the pou given by its name
 def GetPouType(self, name):
 # Found the pou correponding to name and return its type
 pou = self.Project.getPou(name)
 # Add a Transition to a Project Pou
 def ProjectRemovePouTransition(self, pou_name, transition_name):
 pou = self.Project.getPou(pou_name)
 pou.removeTransition(transition_name)
+self.BufferProject()
 # Add a Transition to a Project Pou
 def ProjectRemovePouAction(self, pou_name, action_name):
 pou = self.Project.getPou(pou_name)
 pou.removeAction(action_name)
+self.BufferProject()
 # Extract varlists from a list of vars
 def ExtractVarLists(self, vars):
 varlist_list = []
 current_varlist = None
 # Set configuration global vars
 configuration.setGlobalVars([])
 for vartype, varlist in self.ExtractVarLists(vars):
 configuration.globalVars.append(varlist)
 self.RefreshBlockTypes()
+self.BufferProject()
 # Return the configuration globalvars
 def GetConfigurationGlobalVars(self, name):
 vars = []
 # Found the configuration corresponding to name
 configuration = self.Project.getConfiguration(name)
 if resource:
 resource.setGlobalVars([])
 for vartype, varlist in self.ExtractVarLists(vars):
 resource.globalVars.append(varlist)
 self.RefreshBlockTypes()
+self.BufferProject()
 # Return the resource globalvars
 def GetConfigurationResourceGlobalVars(self, config_name, name):
 vars = []
 # Found the resource corresponding to name
 resource = self.Project.getConfigurationResource(config_name, name)
 if not pou.interface:
 pou.interface = plcopen.pou_interface()
 # Set Pou interface
 pou.setVars(self.ExtractVarLists(vars))
 self.RefreshBlockTypes()
+self.BufferProject()
 # Replace the return type of the pou given by its name (only for functions)
 def SetPouInterfaceReturnType(self, name, type):
 pou = self.Project.getPou(name)
 if not pou.interface:
 pou.interface = plcopen.pou_interface()
 return_type = plcopen.dataType()
 pou.interface.setReturnType(return_type)
 # Change return type
 return_type.setValue(type)
 self.RefreshBlockTypes()
+self.BufferProject()
 # Return the return type of the pou given by its name
 def GetPouInterfaceReturnTypeByName(self, name):
 # Found the pou correponding to name and return the return type
 return self.GetPouInterfaceReturnType(self.Project.getPou(name))
 tree = minidom.parse(xmlfile)
 xmlfile.close()
 self.Project = plcopen.project()
 self.Project.loadXMLTree(tree.childNodes[0])
-self.UndoBuffer = UndoBuffer(self.Copy(self.Project), True)
 self.SetFilePath(filepath)
+self.ProjectBuffer = UndoBuffer(self.Copy(self.Project), True)
+self.Buffering = False
 self.ElementsOpened = []
 self.CurrentElementEditing = None
 self.RefreshPouUsingTree()
 self.RefreshBlockTypes()
 xmlfile = open(filepath,"w")
 else:
 xmlfile = open(self.FilePath,"w")
 xmlfile.write(text)
 xmlfile.close()
-#self.ProjectBuffer.CurrentSaved()
+self.ProjectBuffer.CurrentSaved()
 if filepath:
 self.SetFilePath(filepath)
 return True
 #-------------------------------------------------------------------------------
 """
 def Copy(self, model):
 return cPickle.loads(cPickle.dumps(model))
 def BufferProject(self):
-self.ProjectBuffer.Buffering(self.Copy(self))
+self.ProjectBuffer.Buffering(self.Copy(self.Project))
+def StartBuffering(self):
+self.ProjectBuffer.Buffering(self.Project)
+self.Buffering = True
+def EndBuffering(self):
+if self.Buffering:
+self.Project = self.Copy(self.Project)
+self.Buffering = False
 def ProjectIsSaved(self):
 return self.ProjectBuffer.IsCurrentSaved()
 def LoadPrevious(self):
 self.Project = self.Copy(self.ProjectBuffer.Previous())
-self.RefreshElementsOpened()
 def LoadNext(self):
 self.Project = self.Copy(self.ProjectBuffer.Next())
-self.RefreshElementsOpened()
 def GetBufferState(self):
 first = self.ProjectBuffer.IsFirst()
 last = self.ProjectBuffer.IsLast()
 return not first, not last

changeset 56	7187e1c00975
parent 53	4988262d03e3
child 57	9bf197698af0