try:

CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

except KeyError:

# if CTNClass is a class factory, call it. (prevent unneeded imports)

if type(CTNClass) == types.FunctionType:

ChildrenWithSameClass = self.Children.setdefault(CTNType, list())

# Check count

if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:

# create the final class, derived of provided confnode and template

class FinalCTNClass(CTNClass, ConfigTreeNode):

_self.LoadXMLParams(NewCTNName)

# Basic check. Better to fail immediately.

if (_self.BaseParams.getName() != NewCTNName):

# Now, self.CTNPath() should be OK

split = None

for idx, tab in enumerate(tabs):

if len(tab["pages"]) == 0:

if tab["size"][0] == rect.width:

if tab["pos"][1] == rect.y:

split = (wx.TOP, float(tab["size"][1]) / float(rect.height))

if isinstance(tabs, ListType):

if len(tabs) == 0:

return

if "split" in tabs:

self.LoadTabLayout(notebook, tabs["others"])

program = pou_program.GenerateProgram(pou)

self.Program += program

else:

# Generate a POU defined and used in text

def GeneratePouProgramInText(self, text):

# Single argument if exists

if single is not None:

if len(single) == 0:

if single[0] == '[' and single[-1] == ']':

SNGLKW = "MULTI"

self.ConnectionTypes[content["value"]] = "BOOL"

connections = content["value"].getconnections()

if not connections:

for link in connections:

connected = self.GetLinkedConnector(link, body)

if connected is not None and not connected in self.ConnectionTypes:

for element in body.getcontentInstances():

if isinstance(element, ConnectorClass) and element.getname() == name:

if connector is not None:

connector = element

if connector is not None:

undefined = [instance.connectionPointOut, connector.connectionPointIn]

for connection in related:

self.ConnectionTypes[connection] = var_type

else:

elif isinstance(instance, BlockClass):

block_infos = self.GetBlockType(instance.gettypeName(), "undefined")

if block_infos is not None:

if block_infos is not None:

self.ComputeBlockInputTypes(instance, block_infos, body)

else:

if body_type == "SFC":

previous_tagname = self.TagName

for action in pou.getactionList():

if block_infos is None:

block_infos = self.GetBlockType(block_type)

if block_infos is None:

try:

self.GenerateBlock(instance, block_infos, body, None)

except ValueError, e:

elif isinstance(instance, ConnectorClass):

connector = instance.getname()

if self.ComputedConnectors.get(connector, None):

blockname = "{a1}({a2})".format(a1=name, a2=type)

else:

blockname = type

def GeneratePaths(self, connections, body, order=False, to_inout=False):

paths = []

if block_infos is None:

block_infos = self.GetBlockType(block_type)

if block_infos is None:

try:

paths.append(str(self.GenerateBlock(next, block_infos, body, connection, order, to_inout)))

except ValueError, e:

elif isinstance(next, ContinuationClass):

name = next.getname()

computed_value = self.ComputedConnectors.get(name, None)

for instance in body.getcontentInstances():

if isinstance(instance, ConnectorClass) and instance.getname() == name:

if connector is not None:

connector = instance

if connector is not None:

connections = connector.connectionPointIn.getconnections()

self.ComputedConnectors[name] = expression

paths.append(str(expression))

else:

elif isinstance(next, ContactClass):

contact_info = (self.TagName, "contact", next.getlocalId())

variable = str(self.ExtractModifier(next, [(next.getvariable(), contact_info + ("reference",))], contact_info))

jump_target = jump.gettargetName()

if not pou.hasstep(jump_target):

pname = pou.getname()

if jump.connectionPointIn is not None:

instances = []

connections = jump.connectionPointIn.getconnections()

self.SFCComputedBlocks += self.Program

self.Program = []

if not "content" in transition_infos:

self.TagName = previous_tagname

elif transitionValues["type"] == "connection":

body = pou.getbody()

elif len(transition_infos["from"]) == 1:

self.Program += transition_infos["from"][0]

else:

self.Program += [(" TO ", ())]

if len(transition_infos["to"]) > 1:

self.Program += [("(", ())]

elif len(transition_infos["to"]) == 1:

self.Program += transition_infos["to"][0]

else:

self.Program += transition_infos["content"]

self.Program += [("%sEND_TRANSITION\n\n" % self.CurrentIndent, ())]

for [(step_name, step_infos)] in transition_infos["to"]:

(self.ReturnType, (self.TagName, "return"))]

program += [("\n", ())]

if len(self.Interface) == 0:

if len(self.Program) == 0:

var_number = 0

for list_type, option, located, variables in self.Interface:

variable_type = errorVarTypes.get(list_type, "var_local")

pointers = config_utils.LocalODPointers(locations, current_location, slave)

res = gen_cfile.GenerateFile(Gen_OD_path, slave, pointers)

if res:

res = eds_utils.GenerateEDSFile(os.path.join(buildpath, "Slave_%s.eds" % prefix), slave)

if res:

return [(Gen_OD_path, local_canfestival_config.getCFLAGS(CanFestivalPath))], "", False

def LoadPrevious(self):

try:

master, pointers = config_utils.GenerateConciseDCF(locations, current_location, self, self.CanFestivalNode.getSync_TPDOs(), "OD_%s" % prefix)

except config_utils.PDOmappingException, e:

# Do generate C file.

res = gen_cfile.GenerateFile(Gen_OD_path, master, pointers)

if res:

file = open(os.path.join(buildpath, "MasterGenerated.od"), "w")

dump(master, file)

name = location["NAME"]

if name in self.IECLocations:

if self.IECLocations[name]["type"] != COlocationtype:

else:

# Get only the part of the location that concern this node

loc = location["LOC"][len(current_location):]

# loc correspond to (ID, INDEX, SUBINDEX [,BIT])

if len(loc) not in (2, 3, 4):

elif len(loc) == 2:

continue

# Check Id is in slave node list

if nodeid not in self.NodeList.SlaveNodes.keys():

# Get the model for this node (made from EDS)

node = self.NodeList.SlaveNodes[nodeid]["Node"]

if not node.IsEntry(index, subindex):

msg = _("No such index/subindex ({a1},{a2}) in ID : {a3} (variable {a4})").\

format(a1="%x" % index, a2="%x" % subindex, a3=nodeid, a4=name)

# Get the entry info

subentry_infos = node.GetSubentryInfos(index, subindex)

if sizelocation == "X" and len(loc) > 3:

numbit = loc[3]

elif sizelocation != "X" and len(loc) > 3:

else:

numbit = None

if location["IEC_TYPE"] != "BOOL" and subentry_infos["type"] != COlocationtype:

typeinfos = node.GetEntryInfos(COlocationtype)

self.IECLocations[name] = {

"sizelocation": sizelocation

}

else:

#-------------------------------------------------------------------------------

# Search for locations already mapped

pdomapping = []

result = self.GetEmptyPDO(nodeid, pdotype)

if result is None:

pdoindex, pdocobid, pdonbparams = result

for name, loc_infos in locations[pdotype]:

pdosize += loc_infos["size"]

pdomapping = [(name, loc_infos)]

result = self.GetEmptyPDO(nodeid, pdotype, pdoindex + 1)

if result is None:

pdoindex, pdocobid, pdonbparams = result

else:

pdomapping.append((name, loc_infos))

name = location["NAME"]

if name in IECLocations:

if IECLocations[name] != COlocationtype:

else:

# Get only the part of the location that concern this node

loc = location["LOC"][len(current_location):]

# loc correspond to (ID, INDEX, SUBINDEX [,BIT])

if len(loc) not in (2, 3, 4):

elif len(loc) != 2:

continue

# Extract and check index and subindex

if not slave.IsEntry(index, subindex):

# Get the entry info

subentry_infos = slave.GetSubentryInfos(index, subindex)

if subentry_infos["type"] != COlocationtype:

IECLocations[name] = COlocationtype

pointers[(index, subindex)] = name

reactor, RegisterWampClient)

if not _WampSessionEvent.wait(5):

_WampConnection = stopConnecting()

def __del__(self):

global _WampConnection

if rung not in rungs:

rungs.append(rung)

if len(rungs) > 1:

element = self.FindElementById(instance["id"])

element_connectors = element.GetConnectors()

self.Rungs[rungs[0]].SelectElement(element)

if rung not in rungs:

rungs.append(rung)

if len(rungs) > 1:

element = self.FindElementById(instance["id"])

element_connectors = element.GetConnectors()

self.Rungs[rungs[0]].SelectElement(element)

def appenddataType(self, name):

if self.getdataType(name) is not None:

self.types.appenddataTypeElement(name)

setattr(cls, "appenddataType", appenddataType)

def addconfiguration(self, name):

if self.getconfiguration(name) is not None:

new_configuration = PLCOpenParser.CreateElement("configuration", "configurations")

new_configuration.setname(name)

self.instances.configurations.appendconfiguration(new_configuration)

def removeconfiguration(self, name):

configuration = self.getconfiguration(name)

if configuration is None:

self.instances.configurations.remove(configuration)

setattr(cls, "removeconfiguration", removeconfiguration)

def addconfigurationResource(self, config_name, name):

if self.getconfigurationResource(config_name, name) is not None:

configuration = self.getconfiguration(config_name)

if configuration is not None:

new_resource = PLCOpenParser.CreateElement("resource", "configuration")

configuration.remove(resource)

found = True

if not found:

setattr(cls, "removeconfigurationResource", removeconfigurationResource)

def updateElementName(self, old_name, new_name):

found = True

break

if not found:

setattr(cls, "removedataTypeElement", removedataTypeElement)

def getpouElements(self):

def appendpouElement(self, name, pou_type, body_type):

for element in self.pous.getpou():

if TextMatched(element.getname(), name):

new_pou = PLCOpenParser.CreateElement("pou", "pous")

self.pous.appendpou(new_pou)

new_pou.setname(name)

found = True

break

if not found:

setattr(cls, "removepouElement", removepouElement)

def Search(self, criteria, parent_infos=[]):

if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:

self.body[0].setcontent(PLCOpenParser.CreateElement(body_type, "body"))

else:

setattr(cls, "setbodyType", setbodyType)

def getbodyType(self):

removed = True

break

if not removed:

setattr(cls, "removetransition", removetransition)

def addaction(self, name, body_type):

removed = True

break

if not removed:

setattr(cls, "removeaction", removeaction)

def updateElementName(self, old_name, new_name):

if body_type in ["IL", "ST", "LD", "FBD", "SFC"]:

self.body.setcontent(PLCOpenParser.CreateElement(body_type, "body"))

else:

def getbodyType(self):

element.setexecutionOrderId(0)

self.checkedBlocksDict.clear()

else:

setattr(cls, "resetexecutionOrder", resetexecutionOrder)

def compileexecutionOrder(self):

self.compileelementExecutionOrder(connections[0])

element.setexecutionOrderId(self.getnewExecutionOrderId())

else:

setattr(cls, "compileexecutionOrder", compileexecutionOrder)

def compileelementExecutionOrder(self, link):

if connections and len(connections) == 1:

self.compileelementExecutionOrder(connections[0])

else:

setattr(cls, "compileelementExecutionOrder", compileelementExecutionOrder)

def setelementExecutionOrder(self, instance, new_executionOrder):

element.setexecutionOrderId(element_executionOrder + 1)

instance.setexecutionOrderId(new_executionOrder)

else:

setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)

def appendcontentInstance(self, instance):

if self.content.getLocalTag() in ["LD", "FBD", "SFC"]:

self.content.appendcontent(instance)

else:

setattr(cls, "appendcontentInstance", appendcontentInstance)

def getcontentInstances(self):

if self.content.getLocalTag() in ["LD", "FBD", "SFC"]:

return self.content.getcontent()

else:

setattr(cls, "getcontentInstances", getcontentInstances)

instance_by_id_xpath = PLCOpen_XPath("*[@localId=$localId]")

return instance[0]

return None

else:

setattr(cls, "getcontentInstance", getcontentInstance)

def getcontentInstancesIds(self):

return OrderedDict([(instance.getlocalId(), True)

for instance in self.content])

else:

setattr(cls, "getcontentInstancesIds", getcontentInstancesIds)

def getcontentInstanceByName(self, name):

return instance[0]

return None

else:

setattr(cls, "getcontentInstanceByName", getcontentInstanceByName)

def removecontentInstance(self, local_id):

if len(instance) > 0:

self.content.remove(instance[0])

else:

else:

setattr(cls, "removecontentInstance", removecontentInstance)

def settext(self, text):

if self.content.getLocalTag() in ["IL", "ST"]:

self.content.setanyText(text)

else:

setattr(cls, "settext", settext)

def gettext(self):

if self.content.getLocalTag() in ["IL", "ST"]:

return self.content.getanyText()

else:

setattr(cls, "gettext", gettext)

def hasblock(self, block_type):

if self.content.getLocalTag() in ["IL", "ST"]:

return self.content.hasblock(block_type)

else:

setattr(cls, "hasblock", hasblock)

def updateElementName(self, old_name, new_name):

elif opened == closed:

i += 1

else:

return items

service.add_method(func.__name__, func)

else:

emsg = 'Service "%s" not found' % str(service.__name__)

return func

return remotify

if class_idx is not None and class_idx < len(element_class):

new_element = element_class[class_idx]()

else:

else:

new_element = element_class()

DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)

# Check that item type is a simple type

if itemtypeinfos["type"] != SIMPLETYPE:

simpleType["basename"] = "list"