self.LastRefreshTime = gettime()

self.LastRefreshTimer = None

if self.lock.acquire():

self.stack.append((s, style))

self.lock.release()

self.ConnectionStatusBar = esb.EnhancedStatusBar(self, style=wx.ST_SIZEGRIP)

self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

self.ConnectionStatusBar.AddWidget(self.ProgressStatusBar, esb.ESB_EXACT_FIT, esb.ESB_EXACT_FIT, 2)

self.ProgressStatusBar.Hide()

self.SetStatusBar(self.ConnectionStatusBar)

else:

self.SetTitle(name)

if (self.local_runtime is None) or (self.local_runtime.exitcode is not None):

# create temporary directory for runtime working directory

self.local_runtime_tmpdir = tempfile.mkdtemp()

{False: "-x 0", True: "-x 1"}[taskbaricon],

self.local_runtime_tmpdir),

no_gui=False,

self.local_runtime.spin()

return self.runtime_port

class ParamsEntryDialog(wx.TextEntryDialog):

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

event(self, function)

wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

self.Tests = []

self.CodeFile, error = self.CodeFileParser.LoadXMLString(codefile_xml)

if error is not None:

(fname, lnum, src) = ((self.CODEFILE_NAME,) + error)

self.CreateCodeFileBuffer(True)

except Exception, exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

else:

def GetBaseTypes(self):

return self.GetCTRoot().GetBaseTypes()

return self.GetCTRoot().GetDataTypes(basetypes=basetypes)

def GenerateNewName(self, format, start_idx):

#Default, do nothing and return success

return True

if path:

parts = path.split(".", 1)

if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

shutil.move(oldname, self.CTNPath())

# warn user he has two left hands

if DesiredName != res:

self.GetCTRoot().logger.write_warning(msg)

return res

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:

raise Exception, msg

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

# Basic check. Better to fail immediately.

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

msg = _("Project tree layout do not match confnode.xml {a1}!={a2} ").\

raise Exception, msg

# Now, self.CTNPath() should be OK

child.ClearChildren()

self.Children = {}

methode_name = os.path.join(self.CTNPath(CTNName), "methods.py")

if os.path.isfile(methode_name):

execfile(methode_name)

self.BaseParams, error = _BaseParamsParser.LoadXMLString(basexmlfile.read())

if error is not None:

(fname, lnum, src) = ((ConfNodeName + " BaseParams",) + error)

self.MandatoryParams = ("BaseParams", self.BaseParams)

basexmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

obj, error = self.Parser.LoadXMLString(xmlfile.read())

if error is not None:

(fname, lnum, src) = ((ConfNodeName,) + error)

name = obj.getLocalTag()

setattr(self, name, obj)

self.CTNParams = (name, obj)

xmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

try:

self.CTNAddChild(pname, ptype)

except Exception, exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

# Compatibility function for wx versions < 2.6

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

# @param controler The controler been used by PLCOpenEditor (default: None).

# @param fileOpen The filepath to open if no controler defined (default: None).

# @param debug The filepath to open if no controler defined (default: False).

self.Controler = None

self.Config = wx.ConfigBase.Get()

self.EnableDebug = enable_debug

old_name = self.ProjectTree.GetItemText(item)

item_infos = self.ProjectTree.GetPyData(item)

if item_infos["type"] == ITEM_PROJECT:

elif item_infos["type"] == ITEM_DATATYPE:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectDataTypeNames() if name != old_name]:

message = _("\"%s\" data type already exists!") % new_name

else:

event.Skip()

openedidx = self.IsOpened(tagname)

if openedidx is not None:

old_selected = self.TabsOpened.GetSelection()

self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE)

self.EditProjectElement(ITEM_DATATYPE, tagname)

def OnAddPouMenu(event):

dialog = PouDialog(self, pou_type, type_readonly)

dialog.SetPouNames(self.Controler.GetProjectPouNames())

class GraphicPrintout(wx.Printout):

wx.Printout.__init__(self)

self.Viewer = viewer

self.PageSize = page_size

Class implementing a buffer of changes made on the current editing model

"""

"""

Constructor initialising buffer

"""

def GetQualifierTypes(self):

return QualifierList

if debug and self.CurrentCompiledProject is not None:

return self.CurrentCompiledProject

else:

self.Buffering = False

# Return project data type names

project = self.GetProject(debug)

if project is not None:

return [datatype.getname() for datatype in project.getdataTypes()]

return []

# Return project pou names

project = self.GetProject(debug)

if project is not None:

return [pou.getname() for pou in project.getpous()]

return []

# Return project pou names

project = self.GetProject(debug)

if project is not None:

return [config.getname() for config in project.getconfigurations()]

return []

# Return project pou variable names

variables = []

project = self.GetProject(debug)

if project is not None:

self.FileName = os.path.splitext(os.path.basename(filepath))[0]

# Change project properties

if self.Project is not None:

if name is not None:

self.Project.setname(name)

return None

# Return project properties

project = self.GetProject(debug)

if project is not None:

properties = project.getfileHeader()

return None

# Return project informations

project = self.GetProject(debug)

if project is not None:

infos = {"name": project.getname(), "type": ITEM_PROJECT}

return infos

return None

pou_type = None

project = self.GetProject(debug)

if project is not None:

etree.parse(

os.path.join(ScriptDirectory, "plcopen", "pou_variables.xslt"),

parser),

for name in ["SetRoot", "AddVariable"]})

obj = None

return None

instances = []

project = self.GetProject(debug)

if project is not None:

etree.parse(

os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"),

parser),

("instances_ns", "AddInstance"): factory.AddInstance})

instances_path_xslt_tree(root,

return instances

project = self.GetProject(debug)

if project is not None:

words = tagname.split("::")

self.ComputePouName(words[1]), debug)]

return []

project = self.GetProject(debug)

factory = InstanceTagName(self)

etree.parse(

os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"),

parser),

for name in ["ConfigTagName", "ResourceTagName",

"PouTagName", "ActionTagName",

"TransitionTagName"]})

return factory.GetTagName()

tagname = self.GetPouInstanceTagName(instance_path)

if tagname is not None:

infos = self.GetPouVariables(tagname, debug)

return None

# Return if data type given by name is used by another data type or pou

project = self.GetProject(debug)

if project is not None:

return len(self.GetInstanceList(project, name, debug)) > 0

return False

# Return if pou given by name is used by another pou

project = self.GetProject(debug)

if project is not None:

return len(self.GetInstanceList(project, name, debug)) > 0

return False

# Return if pou given by name is directly or undirectly used by the reference pou

pou_infos = self.GetPou(reference, debug)

if pou_infos is not None:

return len(self.GetInstanceList(pou_infos, name, debug)) > 0

# programs cannot be pasted as functions or function blocks

if orig_type == 'functionBlock' and pou_type == 'function' or \

orig_type == 'program' and pou_type in ['function', 'functionBlock']:

return msg

new_pou.setpouType(pou_type)

self.BufferProject()

# Return the description of the pou given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name and return its type

return ""

# Return the description of the pou given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name and return its type

self.BufferProject()

# Return the type of the pou given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name and return its type

return None

# Return pous with SFC language

list = []

project = self.GetProject(debug)

if project is not None:

return list

# Return the body language of the pou given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name and return its body language

return None

# Return the actions of a pou

transitions = []

project = self.GetProject(debug)

if project is not None:

return transitions

# Return the body language of the transition given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name

return None

# Return the actions of a pou

actions = []

project = self.GetProject(debug)

if project is not None:

return actions

# Return the body language of the pou given by its name

project = self.GetProject(debug)

if project is not None:

# Found the pou correponding to name and return its body language

etree.parse(

os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),

parser),

for name in ["SetType", "AddDimension", "AddTree",

"AddVarToTree", "AddVariable"]})

variables_infos_xslt_tree(object_with_vars,

in self.ExtractVarLists(vars)])

# Return the configuration globalvars

project = self.GetProject(debug)

if project is not None:

# Found the configuration corresponding to name

return []

# Return configuration variable names

variables = []

project = self.GetProject(debug)

if project is not None:

in self.ExtractVarLists(vars)])

# Return the resource globalvars

project = self.GetProject(debug)

if project is not None:

# Found the resource corresponding to name

# Return resource variable names

def GetConfigurationResourceVariableNames(self,

variables = []

project = self.GetProject(debug)

if project is not None:

return variables

# Return the interface for the given pou

interface = pou.interface

# Verify that the pou has an interface

if interface is not None:

etree.parse(

os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),

parser),

for name in ["SetType", "AddDimension",

"AddTree", "AddVarToTree"]})

return_type_infos_xslt_tree(return_type,

self.TotalTypesDict = StdBlckDct.copy()

self.TotalTypes = StdBlckLst[:]

return [{"name": _("%s Data Types") % confnodetypes["name"],

"list": [

datatype.getname()

return global_vars

# Function that returns the block definition associated to the block type given

result_blocktype = None

for sectioname, blocktype in self.TotalTypesDict.get(typename, []):

if inputs is not None and inputs != "undefined":

return None

# Return Block types checking for recursion

typename = None

words = tagname.split("::")

name = None

return self.TotalTypes

# Return Function Block types checking for recursion

project = self.GetProject(debug)

words = tagname.split("::")

name = None

return blocktypes

# Return Block types checking for recursion

blocktypes = []

for category in StdBlckLst[:-1]:

for blocktype in category["list"]:

return blocktypes

# Return Data Types checking for recursion

if basetypes:

datatypes = self.GetBaseTypes()

else:

return datatypes

# Return Data Type Object

project = self.GetProject(debug)

if project is not None:

result = project.getpou(typename)

return None

# Return Data Type Object

project = self.GetProject(debug)

if project is not None:

result = project.getdataType(typename)

return None

# Return Base Type of given possible derived type

if TypeHierarchy.has_key(typename):

return typename

'''

return [x for x, y in TypeHierarchy_list if not x.startswith("ANY")]

if reference is None or typename == reference:

return True

return not typename.startswith("ANY")

return True

basetype_content = datatype.baseType.getcontent()

basetype_content_type = basetype_content.getLocalTag()

if basetype_content_type in ["enum", "struct"]:

return self.IsLocatableType(array_base_type.getname(), debug)

return True

if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:

return False

return self.IsLocatableDataType(datatype)

return True

if isinstance(typename, TupleType):

typename = typename[1]

datatype = self.GetDataType(typename, debug)

return basetype_content_type == "enum"

return False

if typename == exclude:

return False

if isinstance(typename, TupleType):

self.GetDataTypeBaseType(datatype), exclude)

return False

return self.IsOfType(typename, "ANY_NUM", debug) or\

self.IsOfType(typename, "ANY_BIT", debug)

range = DataTypeRange.get(typename)

if range is not None:

return range

return None

# Return Subrange types

subrange_basetypes = DataTypeRange.keys()

project = self.GetProject(debug)

if project is not None:

return subrange_basetypes

# Return Enumerated Values

values = []

if typename is not None:

datatype_obj = self.GetDataType(typename, debug)

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

# Return the data type informations

project = self.GetProject(debug)

if project is not None:

words = tagname.split("::")

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

# Return edited element

project = self.GetProject(debug)

if project is not None:

words = tagname.split("::")

return None

# Return edited element name and type

words = tagname.split("::")

if words[0] in ["P", "T", "A"]:

return words[1], self.GetPouType(words[1], debug)

return None, None

# Return language in which edited element is written

words = tagname.split("::")

if words[0] == "P":

return self.GetPouBodyType(words[1], debug)

return None

# Return the edited element variables

words = tagname.split("::")

if words[0] in ["P", "T", "A"]:

project = self.GetProject(debug)

return []

# Return the edited element return type

words = tagname.split("::")

if words[0] == "P":

project = self.GetProject(debug)

element.settext(text)

# Return the edited element text

element = self.GetEditedElement(tagname, debug)

if element is not None:

return element.gettext()

return ""

# Return the edited element transitions

pou = self.GetEditedElement(tagname, debug)

if pou is not None and pou.getbodyType() == "SFC":

transitions = []

return []

# Return edited element transitions

pou = self.GetEditedElement(tagname, debug)

if pou is not None and pou.getbodyType() == "SFC":

actions = []

return []

# Return the names of the pou elements

words = tagname.split("::")

if words[0] in ["P", "T", "A"]:

return self.GetProjectPouVariableNames(words[1], debug)

return names

return []

element = self.GetEditedElement(tagname, debug)

if element is not None:

return element.tostring()

return ""

element = self.GetEditedElement(tagname, debug)

text = ""

if element is not None:

return new_id, connections

element_instances = OrderedDict()

element = self.GetEditedElement(tagname, debug)

if element is not None:

pou_block_instances_xslt_tree = etree.XSLT(

pou_block_instances_xslt,

("pou_block_instances_ns", name): getattr(factory, name)

for name in ["AddBlockInstance", "SetSpecificValues",

"AddInstanceConnection", "AddConnectionLink",

if pou is not None:

pou.removepouVar(type, name)

element = self.GetEditedElement(tagname)

if element is not None:

block = PLCOpenParser.CreateElement("block", "fbdObjects")

self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())

element.removeinstance(id)

varlist = []

words = tagname.split("::")

for var in self.GetConfigurationGlobalVars(words[1], debug):

new_instance.setname(instance["Name"])

new_instance.settypeName(instance["Type"])

resource = self.GetEditedElement(tagname, debug)

if resource is not None:

tasks = resource.gettask()

self.CurrentElementEditing = None

return error

if not filepath and self.FilePath == "":

return False

else:

if single is not None:

if len(single) == 0:

msg = _("Source signal has to be defined for single task '{a1}' in resource '{a2}.{a3}'.").\

raise PLCGenException, msg

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

for element in body.getcontentInstances():

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

if connector is not None:

raise PLCGenException, msg

connector = element

if connector is not None:

for connection in related:

self.ConnectionTypes[connection] = var_type

else:

raise PLCGenException, msg

elif isinstance(instance, BlockClass):

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

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:

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

self.Program += [(");\n", ())]

else:

self.Warnings.append(msg)

elif block_infos["type"] == "functionBlock":

if not self.ComputedBlocks.get(block, False) and not order:

if output_parameter is None:

output_parameter = ""

if name:

else:

blockname = type

msg = _("No output {a1} variable found in block {a2} in POU {a3}. Connection must be broken").\

raise ValueError, msg

paths = []

for connection in connections:

localId = connection.getrefLocalId()

if block_infos is None:

block_infos = self.GetBlockType(block_type)

if block_infos is None:

raise PLCGenException, msg

try:

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

for instance in body.getcontentInstances():

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

if connector is not None:

raise PLCGenException, msg

connector = instance

if connector is not None:

self.ComputedConnectors[name] = expression

paths.append(str(expression))

else:

raise PLCGenException, msg

elif isinstance(next, ContactClass):

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

paths.append(str(self.GeneratePaths(next.connectionPointIn.getconnections(), body, order)))

return paths

if type(paths) == TupleType:

if None in paths:

return [("TRUE", ())]

else:

return eval(paths)

paths = self.GeneratePaths(connections, body, order, to_inout)

if len(paths) == 0:

return None

jump_target = jump.gettargetName()

if not pou.hasstep(jump_target):

pname = pou.getname()

raise PLCGenException, msg

if jump.connectionPointIn is not None:

instances = []

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

else:

msg = _("Transition with content \"{a1}\" not connected to a previous step in \"{a2}\" POU").\

raise PLCGenException, msg

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

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

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

else:

msg = _("Transition with content \"{a1}\" not connected to a next step in \"{a2}\" POU").\

raise PLCGenException, msg

self.Program += transition_infos["content"]

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

# Compatibility function for wx versions < 2.6

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

# @param controler The controler been used by PLCOpenEditor (default: None).

# @param fileOpen The filepath to open if no controler defined (default: None).

# @param debug The filepath to open if no controler defined (default: False).

self.icon = wx.Icon(os.path.join(beremiz_dir, "images", "poe.ico"), wx.BITMAP_TYPE_ICO)

IDEFrame.__init__(self, parent)

if result is not None:

(num, line) = result

def OnCloseFrame(self, event):

if self.Controler is None or self.CheckSaveBeforeClosing(_("Close Application")):

if result is not None:

(num, line) = result

def OnCloseProjectMenu(self, event):

if not self.CheckSaveBeforeClosing():

target.setcontent(self.Parser.CreateElement(target_name, "TargetType"))

return target

params = ConfigTreeNode.GetParamsAttributes(self, path)

if params[0]["name"] == "BeremizRoot":

for child in params[0]["children"]:

if error is not None:

if self.Project is not None:

(fname_err, lnum, src) = (("PLC",) + error)

else:

return error, False

if len(self.GetProjectConfigNames()) == 0:

text = file(plc_file).read()

except:

text = '(* No IEC code have been generated at that time ! *)'

self._IECCodeView.Editor.SetReadOnly(True)

self._IECCodeView.SetIcon(GetBitmap("ST"))

setattr(self._IECCodeView, "_OnClose", self.OnCloseEditor)

}

return msgs.get(status, status)

self.AppFrame.ProgressStatusBar.Show()

self.AppFrame.ConnectionStatusBar.SetStatusText(self.GetTextStatus(status), 1)

self.AppFrame.ProgressStatusBar.SetValue(progress)

if self.IsPLCStarted():

# Timer to prevent rapid-fire when registering many variables

# use wx.CallAfter use keep using same thread. TODO : use wx.Timer instead

# Rearm anti-rapid-fire timer

self.DebugTimer.start()

CTNChildrenTypes = [("CanOpenNode", _NodeListCTN, "CanOpen Master"),

("CanOpenSlave", _SlaveCTN, "CanOpen Slave" )]

for element in infos:

if element["name"] == "CanFestivalInstance":

for child in element["children"]:

return "".join([chr(int(car, 16)) for car in list_car])

"""

Find the PDO indexes of a node

@param node: node

# 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"]

# Extract and check index and subindex

if not node.IsEntry(index, subindex):

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

raise PDOmappingException, msg

# Get the entry info

numbit = loc[3]

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

msg = _("Cannot set bit offset for non bool '{a1}' variable (ID:{a2},Idx:{a3},sIdx:{a4}))").\

raise PDOmappingException, msg

else:

numbit = None

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

raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\

typeinfos = node.GetEntryInfos(COlocationtype)

self.IECLocations[name] = {

}

else:

raise PDOmappingException, _("Not PDO mappable variable : '{a1}' (ID:{a2},Idx:{a3},sIdx:{a4}))").\

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

# Search for locations already mapped

self.Manager.AddSubentriesToCurrent(mapvariableidx, 1, self.MasterNode)

nbsubentries += 1

# Add informations to the new subentry created

# Set value of the PDO mapping

typeinfos = self.Manager.GetEntryInfos(typeidx)

# Extract and check index and subindex

if not slave.IsEntry(index, subindex):

raise PDOmappingException, _("No such index/subindex ({a1},{a2}) (variable {a3})").\

# Get the entry info

subentry_infos = slave.GetSubentryInfos(index, subindex)

if subentry_infos["type"] != COlocationtype:

raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\

IECLocations[name] = COlocationtype

pointers[(index, subindex)] = name

ip = str(socket.inet_ntoa(i.getAddress()))

port = str(i.getPort())

newlocation = ip + ':' + port

location = newlocation

r.close()

except Exception, msg:

# create a WAMP application session factory

component_config = types.ComponentConfig(

session_factory = wamp.ApplicationSessionFactory(

session_factory.session = WampSession

# create a WAMP-over-WebSocket transport client factory

transport_factory = WampWebSocketClientFactory(

session_factory,

# start the client from a Twisted endpoint

conn = connectWS(transport_factory)

wx.SWISS,

wx.NORMAL,

wx.NORMAL,

self.Bind(wx.EVT_PAINT, self.OnPaint)

# Update position of figure (keeping up and bottom border the same

# size)

self.Figure.subplotpars.update(

# Update position of items labels

if self.GraphType == GRAPH_PARALLEL or self.Is3DCanvas():

# Add plot to canvas

self.Axes.plot(x_data[:, 1][:length],

y_data[:, 1][:length],

# Display cursor in canvas if a cursor tick is defined and

# it is include in values tick range

def GetVariableNameMask(self):

return self.VariableNameMask

for panel in self.GraphicPanels:

if panel.GetItem(iec_path) is not None:

if graph and isinstance(panel, DebugVariableTextViewer):

self.Thaw()

self.ForceRefresh()

if idx is None:

idx = len(self.GraphicPanels)

source_panel = None

event.Skip()

def AddWidget(self, widget, horizontalalignment=ESB_ALIGN_CENTER_HORIZONTAL,

"""Add A Widget To The EnhancedStatusBar.

Parameters:

self.Tree.SelectItem(item)

self.Tree.EnsureVisible(item)

"""

Find Tree item corresponding to block informations given

Function is recursive

class SearchResultPanel(wx.Panel):

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

else:

header_format = _("'{a1}' - {a2} matches in project")

self.ResetButton.Enable(True)

if matches_number > 0:

grid.SetReadOnly(row, col, True)

else:

if colname == "Option":

if len(options) > 1:

editor = wx.grid.GridCellChoiceEditor()

editor.SetParameters(",".join(map(_, options)))

base_location_type = self.ParentWindow.Controler.GetBaseType(values[2])

if values[2] != variable_type and base_type != base_location_type:

message = _("Incompatible data types between \"{a1}\" and \"{a2}\"").\

if message is None:

if not location.startswith("%"):

message = _("Unrecognized data size \"%s\"") % location[0]

elif base_type not in LOCATIONDATATYPES[location[0]]:

message = _("Incompatible size of data between \"{a1}\" and \"{a2}\"").\

else:

dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow.ParentWindow,

_("Select a variable class:"), _("Variable class"),

new_row = self.Table.GetNumberRows()

self.SaveValues()

if self.ElementType == "resource":

self.RefreshValues()

return new_row

setattr(self.VariablesGrid, "_AddRow", _AddVariable)

self.Values.remove(self.Table.GetRow(row))

self.SaveValues()

if self.ElementType == "resource":

self.RefreshValues()

setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

words = self.TagName.split("::")

self.Controler.SetPouInterfaceReturnType(words[1], self.ReturnType.GetStringSelection())

self.Controler.BufferProject()

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

event.Skip()

def BuildUserTypesMenu(self, type_menu):

# build a submenu containing user-defined types

datatype_menu = wx.Menu(title='')

for datatype in datatypes:

new_id = wx.NewId()

datatype_menu.Append(help='', id=new_id, kind=wx.ITEM_NORMAL, text=datatype)

self.Table.SetValueByName(row, "Type", base_type)

self.Table.ResetView(self.VariablesGrid)

self.SaveValues(False)

self.Controler.BufferProject()

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU, PAGETITLES, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

return VariableTypeFunction

self.Table.SetValueByName(row, "Type", dialog.GetValue())

self.Table.ResetView(self.VariablesGrid)

self.SaveValues(False)

self.Controler.BufferProject()

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU, PAGETITLES, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

dialog.Destroy()

self.Table.SetData(data)

self.Table.ResetView(self.VariablesGrid)

words = self.TagName.split("::")

if self.ElementType == "config":

self.Controler.SetConfigurationGlobalVars(words[1], self.Values)

(self.BlockName.GetValue()

if self.BlockName.IsEnabled()

else ""),

# Reset graphic element displayed

else:

self.Class.GetStringSelection()],

name,

self.VariableList.get(name, ("", ""))[1],

# Call BlockPreviewDialog function

BlockPreviewDialog.RefreshPreview(self)

# set the longest message here, to use it length to calculate

# optimal size of dialog window

self.RegExpSyntaxErrMsg = _("Syntax error in regular expression of pattern to search!")

controls_sizer.AddWindow(self.StatusLabel, flag=wx.ALIGN_CENTER_VERTICAL)

panel.SetSizer(main_sizer)

class ForceVariableDialog(wx.TextEntryDialog):

def __init__(self, parent, iec_type, defaultValue=""):

self.IEC_Type = iec_type

if value == "":

message = _("You must type a value!")

elif GetTypeValue[self.IEC_Type](value) is None:

if message is not None:

dialog = wx.MessageDialog(self, message, _("Error"), wx.OK|wx.ICON_ERROR)

dialog.ShowModal()

# Set graphic element displayed, creating a power rail element

self.Element = LD_PowerRail(self.Preview,

self.GetPowerRailType(),

# Call BlockPreviewDialog function

BlockPreviewDialog.RefreshPreview(self)

class PouNameDialog(wx.TextEntryDialog):

wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

self.PouNames = []

divergence graphic element

"""

"""

Constructor

@param parent: Parent wx.Window of dialog for modal

class SFCStepNameDialog(wx.TextEntryDialog):

wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

self.PouNames = []

return None

if pagenum is not None:

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", "/A", "page=%d=OpenActions" % pagenum, '"%s"' % pdffile)

else:

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", '"%s"' % pdffile)

if pagenum is None:

os.system("%s -remote DS301 %s &" % (readerexepath, pdffile))

else:

os.system("%s -remote DS301 %s %d &" % (readerexepath, pdffile, pagenum))

if wx.Platform == '__WXMSW__':

try:

readerpath = get_acroversion()

""" Customized GenStaticBitmap, fix transparency redraw bug on wx2.8/win32,

and accept image name as __init__ parameter, fail silently if file do not exist"""

def __init__(self, parent, ID, bitmapname,

bitmap = GetBitmap(bitmapname)

if bitmap is None:

self.FullIECChannel = wx.StaticText(self.Editor, -1)

self.FullIECChannel.SetFont(

wx.Font(faces["size"], wx.DEFAULT, wx.NORMAL,

baseparamseditor_sizer.AddWindow(self.FullIECChannel,

flag=wx.ALIGN_CENTER_VERTICAL)

size=wx.Size(150, 25))

self.ConfNodeName.SetFont(

wx.Font(faces["size"] * 0.75, wx.DEFAULT, wx.NORMAL,

self.ConfNodeName.Bind(wx.EVT_TEXT,

self.GetTextCtrlCallBackFunction(self.ConfNodeName, "BaseParams.Name", True),

self.ConfNodeName)

self.Thaw()

def GenerateMethodButtonSizer(self):

msizer = wx.BoxSizer(wx.HORIZONTAL)

msizer.AddWindow(button, flag=wx.ALIGN_CENTER)

return msizer

if clean:

sizer.Clear(True)

first = True

Class derived from Viewer class that implements a Viewer of Ladder Diagram

"""

Viewer.__init__(self, parent, tagname, window, controler, debug, instancepath)

self.Rungs = []

self.RungComments = []

return i

return None

if self.GetDrawingMode() == FREEDRAWING_MODE:

return Viewer.FindElement(self, event, exclude_group, connectors)

"LD_Coil": [("SFC_Transition", WEST)]

}

Viewer.__init__(self, parent, tagname, window, controler, debug, instancepath)

self.CurrentLanguage = "SFC"

wire.ConnectEndPoint(None, end)

return wire

previous = connector.GetParentBlock()

id = self.GetNewId()

transition = SFC_Transition(self, "reference", "", 0, id)

wire = self.ConnectConnectors(next, previous)

return wire

previous = connector.GetParentBlock()

id = self.GetNewId()

step = SFC_Step(self, name, False, id)

return blockName

# This method check the IEC 61131-3 compatibility between two SFC blocks

if startblock is not None and endblock is not None and (isinstance(startblock, SFC_Objects)\

or isinstance(endblock, SFC_Objects)):

# Full "SFC_StandardRules" table would be symmetrical and

ID = ID_TEXTVIEWER

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

self.Bind(wx.stc.EVT_STC_DO_DROP, self.OnDoDrop, id=ID_TEXTVIEWERTEXTCTRL)

self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModification, id=ID_TEXTVIEWERTEXTCTRL)

if tagname != "" and controler is not None:

self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])

elif pou_type == "function" and values[1] != "function":

message = _("Function Blocks can't be used in Functions!")

elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

else:

blockname = values[2]

if len(values) > 3:

message = _("\"%s\" element for this pou already exists!") % blockname

else:

id = self.ParentWindow.GetNewId()

width, height = block.GetMinSize()

if scaling is not None:

x = round(float(x) / float(scaling[0])) * scaling[0]

"""

if wx.VERSION < (2, 6, 0):

if id is not None:

event(self, id, function)

else:

self.Editor.ParentWindow = self

# Create a new Viewer

self.VARIABLE_PANEL_TYPE = controler.GetPouType(tagname.split("::")[1])

EditorPanel.__init__(self, parent, tagname, window, controler, debug)

self.ElementRefreshList_lock = Lock()

dc = wx.ClientDC(self.Editor)

dc.SetFont(font)

width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

while width > 260:

faces["size"] -= 1

dc.SetFont(font)

width, height = dc.GetTextExtent("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

self.SetFont(font)

self.MiniTextDC = wx.MemoryDC()

self.CurrentScale = None

self.SetScale(ZOOM_FACTORS.index(1.0), False)

return block

return None

x, y = self.Editor.CalcUnscrolledPosition(0, 0)

if xp is not None:

x = xp * self.Editor.GetScrollPixelsPerUnit()[0]

self.ResetBuffer()

instance = {}

# List of ids of already loaded blocks

# Load Blocks until they are all loaded

while len(instances) > 0:

self.loadInstance(instances.popitem(0)[1], instances, selection)

connector_pos = wx.Point(*output_connector.position)

if isinstance(element, FBD_Block):

connector = element.GetConnector(connector_pos,

elif i < len(connectors["outputs"]):

connector = connectors["outputs"][i]

else:

connector_pos = wx.Point(*input_connector.position)

if isinstance(element, FBD_Block):

connector = element.GetConnector(connector_pos,

elif i < len(connectors["inputs"]):

connector = connectors["inputs"][i]

else:

def IsEndType(self, type):

return self.Controler.IsEndType(type)

return self.Controler.GetBlockType(type, inputs, self.Debug)

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

return wire

return None

dc = self.GetLogicalDC()

pos = event.GetLogicalPosition(dc)

if self.SelectedElement and not (exclude_group and isinstance(self.SelectedElement, Graphic_Group)):

return element

return None

result, error = self.FindBlockConnectorWithError(pos, direction, exclude)

return result

error = False

startblock = None

for block in self.Blocks.itervalues():

self.Editor.PopupMenu(menu)

menu.Destroy()

menu = wx.Menu(title='')

if connector is not None and connector.IsCompatible("BOOL"):

self.AddBlockPinMenuItems(menu, connector)

elif position.y > window_size[1] - SCROLL_ZONE:

move_window.y = 1

if move_window.x != 0 or move_window.y != 0:

self.Scroll(xstart + move_window.x, ystart + move_window.y)

self.RefreshScrollBars(move_window.x, move_window.y)

return True

def GetPopupMenuItems(self):

values.setdefault("name", "")

block = FBD_Block(self, values["type"], values["name"], id,

values["extension"], values["inputs"],

self.Controler.AddEditedElementBlock(self.TagName, id, values["type"], values.get("name", None))

connector = None

if wire is not None:

connector = transition.GetConnectors()["inputs"][0]

self.AddNewElement(transition, bbox, wire, connector)

dialog = SFCDivergenceDialog(self.ParentWindow, self.Controler, self.TagName, poss_div_types)

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize((bbox.width, bbox.height))

else:

block.SetName("")

block.SetSize(*self.GetScaledSize(new_values["width"], new_values["height"]))

block.SetExecutionOrder(new_values["executionOrder"])

rect = rect.Union(block.GetRedrawRect())

self.RefreshBlockModel(block)

self.Editor.Freeze()

wx.CallAfter(self.Editor.Thaw)

elif event.GetOrientation() == wx.HORIZONTAL:

else:

# Handle scroll in debug to fully redraw area and ensuring

# instance path is fully draw without flickering

if event.ShiftDown():

x, y = self.GetViewStart()

xp = max(0, min(x - rotation * 3, self.Editor.GetVirtualSize()[0] / self.Editor.GetScrollPixelsPerUnit()[0]))

self.Scroll(xp, y)

elif event.ControlDown():

dc = self.GetLogicalDC()

self.ParentWindow.RefreshDisplayMenu()

else:

x, y = self.GetViewStart()

yp = max(0, min(y - rotation * 3, self.Editor.GetVirtualSize()[1] / self.Editor.GetScrollPixelsPerUnit()[1]))

self.Scroll(x, yp)

def OnMoveWindow(self, event):

self.RefreshVisibleElements()

event.Skip()

if printing:

if getattr(dc, "printing", False):

font = wx.Font(self.GetFont().GetPointSize(), wx.MODERN, wx.NORMAL, wx.NORMAL)

"""

# Create a new block

Graphic_Element.__init__(self, parent)

self.Type = None

self.Description = None

self.Highlights = {}

# Make a clone of this FBD_Block

if self.Name != "" and name == "":

name = self.Name

block = FBD_Block(parent, self.Type, name, id, self.Extension)

self.Outputs = []

# Returns the RedrawRect

rect = Graphic_Element.GetRedrawRect(self, movex, movey)

if movex != 0 or movey != 0:

for input in self.Inputs:

# Unconnect all inputs and outputs

def Clean(self):

for input in self.Inputs:

for output in self.Outputs:

# Refresh the size of text for name

def RefreshNameSize(self):

self.RefreshConnected()

# Refresh the positions of wires connected to inputs and outputs

for input in self.Inputs:

input.MoveConnected(exclude)

for output in self.Outputs:

output.MoveConnected(exclude)

# Returns the block connector that starts with the point given if it exists

if input_name is not None:

# Test each input connector

for input in self.Inputs:

return {"inputs": self.Inputs, "outputs": self.Outputs}

# Test if point given is on one of the block connectors

# Test each input connector

for input in self.Inputs:

if input.TestPoint(pt, direction, exclude):

return None

# Changes the block type

if type != self.Type or self.Extension != extension or executionControl != self.ExecutionControl:

if type != self.Type:

self.Type = type

# Extract the inputs properties and create or modify the corresponding connector

input_connectors = []

for input_name, input_type, input_modifier in inputs:

if input_modifier == "negated":

connector.SetNegated(True)

elif input_modifier != "none":

break

input_connectors.append(connector)

for input in self.Inputs:

self.Inputs = input_connectors

# Extract the outputs properties and create or modify the corresponding connector

break

output_connectors.append(connector)

for output in self.Outputs:

self.Outputs = output_connectors

self.RefreshMinSize()

"""

# Create a new variable

Graphic_Element.__init__(self, parent)

self.Type = None

self.ValueType = None

self.Highlights = []

# Make a clone of this FBD_Variable

variable = FBD_Variable(parent, self.Type, self.Name, self.ValueType, id)

variable.SetSize(self.Size[0], self.Size[1])

if pos is not None:

self.Output = None

# Returns the RedrawRect

rect = Graphic_Element.GetRedrawRect(self, movex, movey)

if movex != 0 or movey != 0:

if self.Input and self.Input.IsConnected():

# Unconnect connector

def Clean(self):

if self.Input:

if self.Output:

# Delete this variable by calling the appropriate method

def Delete(self):

self.RefreshConnected()

# Refresh the position of wires connected to connector

if self.Input:

self.Input.MoveConnected(exclude)

if self.Output:

self.Output.MoveConnected(exclude)

# Test if point given is on the variable connector

if self.Input and self.Input.TestPoint(pt, direction, exclude):

return self.Input

if self.Output and self.Output.TestPoint(pt, direction, exclude):

return None

# Returns the block connector that starts with the point given if it exists

# if a name is given

if name is not None:

# Test input and output connector if they exists

# Create an input or output connector according to variable type

if self.Type != INPUT:

if self.Input is None:

elif self.Input:

self.Input = None

if self.Type != OUTPUT:

if self.Output is None:

self.Output = Connector(self, "", value_type, wx.Point(0, 0), EAST)

elif self.Output:

self.Output = None

self.RefreshConnectors()

self.RefreshBoundingBox()

"""

# Create a new connection

Graphic_Element.__init__(self, parent)

self.Type = type

self.Id = id

self.Highlights = []

# Create an input or output connector according to connection type

if self.Type == CONNECTOR:

else:

self.Connector = Connector(self, "", "ANY", wx.Point(0, 0), EAST)

self.RefreshConnectors()

self.Connector = None

# Returns the RedrawRect

rect = Graphic_Element.GetRedrawRect(self, movex, movey)

if movex != 0 or movey != 0:

if self.Connector and self.Connector.IsConnected():

return rect

# Make a clone of this FBD_Connector

connection = FBD_Connector(parent, self.Type, self.Name, id)

connection.SetSize(self.Size[0], self.Size[1])

if pos is not None:

# Unconnect connector

def Clean(self):

if self.Connector:

# Delete this connection by calling the appropriate method

def Delete(self):

self.RefreshConnected()

# Refresh the position of wires connected to connector

if self.Connector:

self.Connector.MoveConnected(exclude)

# Test if point given is on the connection connector

if self.Connector and self.Connector.TestPoint(pt, direction, exclude):

return self.Connector

return None

# Returns the connection connector

return self.Connector

# Returns all the block connectors

self.Clean()

# Create an input or output connector according to connection type

if self.Type == CONNECTOR:

else:

self.Connector = Connector(self, "", "ANY", wx.Point(0, 0), EAST)

self.RefreshConnectors()

"""

"""

Create a vector from two points and define if vector must be normal

"""

"""

# Create a new graphic element

ToolTipProducer.__init__(self, parent)

self.Parent = parent

self.Id = id

return self.BoundingBox

# Returns the RedrawRect

scalex, scaley = self.Parent.GetViewScale()

rect = wx.Rect()

rect.x = self.BoundingBox.x - int(HANDLE_SIZE / scalex) - 3 - abs(movex)

rect.height = self.BoundingBox.height + 2 * (int(HANDLE_SIZE / scaley) + abs(movey) + 1) + 4

return rect

if self.Visible:

if rect is not None:

self.Parent.RefreshRect(self.Parent.GetScrolledRect(rect), False)

return 0, 0

# Moves the element

self.Pos.x += max(-self.BoundingBox.x, dx)

self.Pos.y += max(-self.BoundingBox.y, dy)

self.RefreshConnected(exclude)

self.SetSize(width, height)

# Refreshes the element state according to move defined and handle selected

handle_type, handle = self.Handle

# If it is a resize handle, calculate the values from resizing

if handle_type == HANDLE_RESIZE:

return blocks, wires

# Make a clone of this element

group = Graphic_Group(parent)

connectors = {}

exclude_names = {}

if parent.IsNamedElement(element):

name = parent.GenerateNewName(element, exclude_names)

exclude_names[name.upper()] = True

else:

new_element.SetBestSize(parent.Scaling)

else:

new_element = element.Clone(parent)

self.WireExcluded.append(element)

# Returns the RedrawRect

rect = None

for element in self.Elements:

if rect is None:

"""

# Create a new connector

DebugDataConsumer.__init__(self)

ToolTipProducer.__init__(self, parent.Parent)

self.ParentBlock = parent

self.Wires = []

# Returns the RedrawRect

parent_pos = self.ParentBlock.GetPosition()

x = min(parent_pos[0] + self.Pos.x, parent_pos[0] + self.Pos.x + self.Direction[0] * CONNECTOR_SIZE)

y = min(parent_pos[1] + self.Pos.y, parent_pos[1] + self.Pos.y + self.Direction[1] * CONNECTOR_SIZE)

self.Selected = selected

# Make a clone of the connector

if parent is None:

parent = self.ParentBlock

return Connector(parent, self.Name, self.Type, wx.Point(self.Pos[0], self.Pos[1]),

return self.ParentBlock

# Returns the connector type

if self.ParentBlock.IsEndType(self.Type) or raw:

return self.Type

elif (self.Negated or self.Edge != "none") and self.ParentBlock.IsOfType("BOOL", self.Type):

return self.Pos

# Returns the connector absolute position