self.splashPath = self.Bpath("images", "splash.png")

def Bpath(self, *args):

def ShowSplashScreen(self):

from wx.lib.agw.advancedsplash import AdvancedSplash

self.splash.Show()

self.splash.ProcessEvent(wx.PaintEvent())

else:

wx.Yield()

time.sleep(0.01);

global updateinfo

try:

import urllib2

except:

updateinfo = _("update info unavailable.")

import version

import tempfile

logpath = tempfile.gettempdir()+os.sep+'Beremiz'

def ShowUI(self):

self.frame = BeremizIDE.Beremiz(None, self.projectOpen, self.buildpath)

def Bpath(*args):

'size': 10,

}

MainThread = currentThread().ident

REFRESH_PERIOD = 0.1

from time import time as gettime

def write(self, s, style = None):

if self.lock.acquire():

self.lock.release()

current_time = gettime()

self.TimerAccessLock.acquire()

self.rising_timer = newtime

def write_warning(self, s):

def write_error(self, s):

def writeyield(self, s):

self.write(s)

self.Bind(wx.EVT_MENU, self.SwitchFullScrMode, id=keyID)

accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, wx.WXK_F12, keyID)]

def OnMethod(evt):

if obj.CTR is not None:

obj.CTR.CallMethod('_'+meth)

wx.CallAfter(self.RefreshStatusToolBar)

return OnMethod

newid = wx.NewId()

self.SetAcceleratorTable(wx.AcceleratorTable(accels))

self.__init_execute_path()

IDEFrame.__init__(self, parent, debug)

self.local_runtime = None

self.runtime_port = None

sys.executable,

Bpath("Beremiz_service.py"),

self.runtime_port,

self.local_runtime_tmpdir),

no_gui=False,

timeout=500, keyword = self.local_runtime_tmpdir,

if self.CTR is not None:

for confnode_method in self.CTR.StatusMethods:

id = wx.NewId()

StatusToolBar.AddSimpleTool(id,

GetBitmap(confnode_method.get("bitmap", "Unknown")),

def Display_Exception_Dialog(e_type, e_value, e_tb, bug_report_path):

trcbck_lst = []

trcbck = " " + str(i+1) + ". "

if line[0].find(os.getcwd()) == -1:

trcbck += "file : " + str(line[0]) + ", "

def AddExceptHook(path, app_version='[No version]'): #, ignored_exceptions=[]):

info = {

'app-title': wx.GetApp().GetAppName(), # app_title

'app-version': app_version,

def Bpath(*args):

def SetupI18n():

import gettext

# Get folder containing translation files

# Get the default language

langid = wx.LANGUAGE_DEFAULT

# Define translation domain (name of translation files)

def _LiveShellLocals(self):

if self.pyroserver.plcobj is not None:

else:

return {}

def default_evaluator(tocall, *args, **kwargs):

try:

except Exception:

res=(None, sys.exc_info())

return res

self.plcobj = PLCObject(self.workdir, self.daemon, self.argv,

self.statuschange, self.evaluator,

self.pyruntimevars)

print _("Pyro port :"), self.port

print _("Pyro object's uri :"), uri

main_thread = currentThread()

def statuschangeTskBar(status):

statuschange.append(statuschangeTskBar)

def wx_evaluator(obj, *args, **kwargs):

obj.res = default_evaluator(tocall, *args, **kwargs)

wx_eval_lock.release()

# avoid dead lock if called from the wx mainloop

return default_evaluator(tocall, *args, **kwargs)

else:

wx_eval_lock.acquire()

return o.res

def LogException(*exp):

if pyroserver.plcobj is not None:

else:

traceback.print_exception(*exp)

else:

try:

pyroserver.Loop()

pass

pyroserver.Quit()

sys.exit(0)

def OnCTNSave(self, from_project_path=None):

filepath = self.CodeFileName()

xmlfile.write(etree.tostring(

self.CodeFile,

pretty_print=True,

def ConfNodePath(self):

return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)

if not CTNName:

CTNName = self.CTNName()

if not project_path:

# generate XML for base XML parameters controller of the confnode

if self.MandatoryParams:

BaseXMLFile.write(etree.tostring(

self.MandatoryParams[1],

pretty_print=True,

# generate XML for XML parameters controller of the confnode

if self.CTNParams:

XMLFile.write(etree.tostring(

self.CTNParams[1],

pretty_print=True,

}, ...]

@return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

"""

def _Generate_C(self, buildpath, locations):

# Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files

def IECSortedChildren(self):

# reorder children by IEC_channels

if ordered:

ordered.sort()

return zip(*ordered)[1]

# reorganize self.CTNChildrenTypes tuples from (name, CTNClass, Help)

# to ( name, (CTNClass, Help)), an make a dict

transpose = zip(*self.CTNChildrenTypes)

# Check that adding this confnode is allowed

try:

CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

for tab in tabs:

if tab["pos"][0] == rect.x:

others = [t for t in tabs if t != tab]

for other in others:

if (other["pos"][1] == tab["pos"][1] and

other["size"][1] == tab["size"][1] and

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

others = [t for t in tabs if t != tab]

for other in others:

if (other["pos"][0] == tab["pos"][0] and

other["size"][0] == tab["size"][0] and

event.Skip()

return OnTabsOpenedDClick

pane = self.AUIManager.GetPane(self.TabsOpened)

if pane.IsMaximized():

self.AUIManager.RestorePane(pane)

def GetUneditableNames():

return [_("User-defined POUs"), _("Functions"), _("Function Blocks"),

_("Programs"), _("Data Types"), _("Transitions"), _("Actions"),

_("Configurations"), _("Resources"), _("Properties")]

project = self.GetProject(debug)

if project is not None:

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

for datatype in project.getdataTypes():

datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE,

"tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})

for pou in project.getpous():

pou_type = pou.getpouType()

pou_infos = {"name": pou.getname(), "type": ITEM_POU,

self.TotalTypes.extend(addedcat)

for cat in addedcat:

for desc in cat["list"]:

BlkLst.append((section["name"], desc))

# Function that clear the confnode list

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

def GetBlockType(self, typename, inputs = None, debug = False):

result_blocktype = None

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

block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])

if reduce(lambda x, y: x and y, map(lambda x: x[0] == "ANY" or self.IsOfType(*x), zip(inputs, block_inputs)), True):

project = self.GetProject(debug)

if project is not None:

pou_type = None

name = words[1]

pou_type = self.GetPouType(name, debug)

filter = (["function"]

project = self.GetProject(debug)

words = tagname.split("::")

name = None

name = words[1]

blocktypes = []

for blocks in self.TotalTypesDict.itervalues():

if block["type"] == "functionBlock":

blocktypes.append(block["name"])

if project is not None:

TypeHierarchy_list has a rough order to it (e.g. SINT, INT, DINT, ...),

which makes it easy for a user to find a type in a menu.

'''

def IsOfType(self, typename, reference, debug = False):

if reference is None or typename == reference:

# Return edited element name

def GetEditedElementName(self, tagname):

words = tagname.split("::")

return words[1]

else:

return words[2]

# Return edited element name and type

def GetEditedElementType(self, tagname, debug = False):

words = tagname.split("::")

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

return None, None

# Return the edited element variables

def GetEditedElementInterfaceVars(self, tagname, tree=False, debug = False):

words = tagname.split("::")

project = self.GetProject(debug)

if project is not None:

pou = project.getpou(words[1])

# Return the names of the pou elements

def GetEditedElementVariables(self, tagname, debug = False):

words = tagname.split("::")

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

elif words[0] in ["C", "R"]:

names = self.GetConfigurationVariableNames(words[1], debug)

names.update(dict([(varname.upper(), True)

for varname in self.GetEditedElementVariables(tagname, debug)]))

words = tagname.split("::")

element = self.GetEditedElement(tagname, debug)

if element is not None and element.getbodyType() not in ["ST", "IL"]:

for instance in element.getinstances():

var_type_obj.setcontent(derived_type)

return var_type_obj

if self.Project is not None:

words = tagname.split("::")

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

("%s" % min_value, (tagname, "lower")),

("..", ()),

("%s" % max_value, (tagname, "upper")),

# Data type is an enumerated type

elif basetype_content_type == "enum":

values = [[(value.getname(), (tagname, "value", i))]

self.ComputedConnectors = {}

self.ConnectionTypes = {}

self.RelatedConnections = []

self.SFCComputedBlocks = []

self.ActionNumber = 0

self.Program = []

body = body[0]

body_content = body.getcontent()

body_type = body_content.getLocalTag()

text = body_content.getanyText()

self.ParentGenerator.GeneratePouProgramInText(text.upper())

self.Program = [(ReIndentText(text, len(self.CurrentIndent)),

Max_Traceback_List_Size = 20

trcbck_lst = []

trcbck = " " + str(i+1) + _(". ")

if line[0].find(os.getcwd()) == -1:

trcbck += _("file : ") + str(line[0]) + _(", ")

if str(e_value).startswith("!!!"):

Display_Error_Dialog(e_value)

elif ex not in ignored_exceptions:

if result:

ignored_exceptions.append(ex)

info = {

if 'self' in exception_locals:

info['self'] = format_namespace(exception_locals['self'].__dict__)

lst = info.keys()

lst.sort()

for a in lst:

def ExtractChildrenTypesFromCatalog(catalog):

children_types = []

if isinstance(c, ListType):

children_types.extend(ExtractChildrenTypesFromCatalog(c))

else:

def ExtractMenuItemsFromCatalog(catalog):

menu_items = []

if isinstance(c, ListType):

children = ExtractMenuItemsFromCatalog(c)

else:

paths=[

os.path.join(base_folder, "matiec")

]

# otherwise use iec2c from PATH

if path is not None:

os.path.join(base_folder, "matiec", "lib"),

"/usr/lib/matiec"

]

return path

def findLibCPath(self):

paths=[

os.path.join(self.ieclib_path, "C"),

self.ieclib_path]

return path

def findSupportedOptions(self):

# Invoke compiler. Output files are listed to stdout, errors to stderr

status, result, err_result = ProcessLogger(None, buildcmd,

no_stdout=True, no_stderr=True).spin()

return buildopt

for opt in options:

"""+"\n".join(['<xsd:attribute name='+

'"Enable_'+ libname + '_Library" '+

'type="xsd:boolean" use="optional" default="true"/>'

</xsd:complexType>

</xsd:element>""") if len(features.libraries)>0 else '') + """

</xsd:sequence>

def LoadLibraries(self):

self.Libraries = []

TypeStack=[]

if self.BeremizRoot.Libraries is None or getattr(self.BeremizRoot.Libraries, "Enable_"+libname+"_Library"):

Lib = GetClassImporter(clsname)()(self, libname, TypeStack)

TypeStack.append(Lib.GetTypes())

def GetLibrariesCCode(self, buildpath):

if len(self.Libraries)==0:

self.GetIECProgramsAndVariables()

LibIECCflags = '"-I%s" -Wno-unused-function' % os.path.abspath(self.GetIECLibPath())

LocatedCCodeAndFlags=[]

Extras=[]

for lib in self.Libraries:

LocatedCCodeAndFlags.append(res[:2])

if len(res)>2:

Extras.extend(res[2:])

# Update PLCOpenEditor ConfNode Block types from loaded confnodes

def RefreshConfNodesBlockLists(self):

def GetLocations(self):

locations = []

if os.path.isfile(filepath):

# IEC2C compiler generate a list of located variables : LOCATED_VARIABLES.h

# each line of LOCATED_VARIABLES.h declares a located variable

lines = [line.strip() for line in location_file.readlines()]

# This regular expression parses the lines genereated by IEC2C

# Get the resulting dict

resdict = result.groupdict()

# rewrite string for variadic location as a tuple of integers

# set located size to 'X' if not given

if not resdict['SIZE']:

resdict['SIZE'] = 'X'

# Invoke compiler. Output files are listed to stdout, errors to stderr

status, result, err_result = ProcessLogger(self.logger, buildcmd,

no_stdout=True, no_stderr=True).spin()

self.logger.write_error(buildcmd + "\n")

self.logger.write_error(repr(e) + "\n")

return False

self.logger.write_error(_("Error : At least one configuration and one resource must be declared in PLC !\n"))

return False

# transform those base names to full names with path

# prepend beremiz include to configuration header

H_files = [ fname for fname in result.splitlines() if fname[-2:]==".h" or fname[-2:]==".H" ]

H_files.remove("LOCATED_VARIABLES.h")

for H_file in H_files:

with file(H_file, 'r') as original: data = original.read()

with file(H_file, 'w') as modified: modified.write('#include "beremiz.h"\n' + data)

targetclass = targets.GetBuilder(targetname)

# if target already

# Get classname instance

self._builder = targetclass(self)

return self._builder

"""

if self._ProgramList is None or self._VariablesList is None:

try:

# describes CSV columns

ProgramsListAttributeName = ["num", "C_path", "type"]

VariablesListAttributeName = ["num", "vartype", "IEC_path", "C_path", "type"]

# Separate sections

ListGroup = []

strippedline = line.strip()

if strippedline.startswith("//"):

# Start new section

# first section contains programs

for line in ListGroup[0]:

# Split and Maps each field to dictionnary entries

# Truncate "C_path" to remove conf an resources names

# Push this dictionnary into result.

self._ProgramList.append(attrs)

Idx = 0

for line in ListGroup[1]:

# Split and Maps each field to dictionnary entries

# Truncate "C_path" to remove conf an resources names

if len(parts) > 2:

config_FB = config_FBs.get(tuple(parts[:2]))

if config_FB:

if len(ListGroup) > 2:

self._Ticktime = int(ListGroup[2][0])

self.logger.write_error(_("Cannot open/parse VARIABLES.csv!\n"))

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

self.ResetIECProgramsAndVariables()

sz = DebugTypesSize.get(v["type"], 0)

variable_decl_array += [

"{&(%(C_path)s), " % v+

bofs += sz

debug_code = targets.GetCode("plc_debug.c") % {

"programs_declarations":

"\n".join(["extern %(type)s %(C_path)s;" % p for p in self._ProgramList]),

for v in self._VariablesList if v["C_path"].find('.')<0]),

"variable_decl_array": ",\n".join(variable_decl_array)

}

"""

# filter location that are related to code that will be called

# in retreive, publish, init, cleanup

# Generate main, based on template

if not self.BeremizRoot.getDisable_Extensions():

plc_main_code = targets.GetCode("plc_main_head.c") % {

"int __init_%(s)s(int argc,char **argv);\n"+

"void __cleanup_%(s)s(void);\n"+

"void __retrieve_%(s)s(void);\n"+

"__retrieve_%s();" % locstr for locstr in locstrs]),

"__publish_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)]),

"init_level=%d; " % (i+1)+

"if((res = __init_%s(argc,argv))){" % locstr +

#"printf(\"%s\"); "%locstr + #for debug

"if(init_level >= %d) " % i+

"__cleanup_%s();" % locstrs[i-1] for i in xrange(len(locstrs), 0, -1)])

}

else:

plc_main_code = targets.GetCode("plc_main_head.c") % {

plc_main_code += targets.GetTargetCode(self.GetTarget().getcontent().getLocalTag())

plc_main_code += targets.GetCode("plc_main_tail.c")

return plc_main_code

# Recreate directory

os.mkdir(extrafilespath)

# Then write the files

open(fpath, "wb").write(fobject.read())

# Now we can forget ExtraFiles (will close files object)

del ExtraFiles

# Header file for extensions

# Template based part of C code generation

# files are stacked at the beginning, as files of confnode tree root

# debugger code

(self.Generate_plc_debugger, "plc_debugger.c", "Debugger"),

# init/cleanup/retrieve/publish, run and align code

try:

# Do generate

code = generator()

if code is None:

raise

open(code_path, "w").write(code)

# Insert this file as first file to be compiled at root confnode

except Exception, exc:

self.logger.write_error(name+_(" generation failed !\n"))

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

status = "Disconnected"

if(self.previous_plcstate != status):

for args in {

("_Stop", True)],

("_Stop", False)],

("_Stop", False)],

("_Stop", False),

("_Transfer", False),

("_Connect", True),

("_Disconnect", False)],

self.ShowMethod(*args)

self.previous_plcstate = status

if self.AppFrame is not None:

if self._connector is not None:

self.IECdebug_lock.acquire()

IECPathsToPop = []

WeakCallableDict, data_log, status, fvalue, buffer_list = data_tuple

if len(WeakCallableDict) == 0:

# Callable Dict is empty.

IECPathsToPop.append(IECPath)

elif IECPath != "__tick__":

# Convert

if Idx is not None:

if IEC_Type in DebugTypesSize:

Idxs.append((Idx, IEC_Type, fvalue, IECPath))

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()

def GetDebugIECVariableType(self, IECPath):

return IEC_Type

def SubscribeDebugIECVariable(self, IECPath, callableobj, buffer_list=False):

self.IECdebug_lock.acquire()

IECdebug_data = self.IECdebug_datas.get(IECPath, None)

if IECdebug_data is not None:

if len(IECdebug_data[0]) == 0:

self.IECdebug_datas.pop(IECPath)

else:

if data_tuple is not None:

WeakCallableDict, data_log, status, fvalue, buffer_list = data_tuple

#data_log.append((debug_tick, value))

function = getattr(weakcallable, function_name, None)

if function is not None:

if buffer_list:

#self.logger.write(_("PLC is %s\n")%status)

if self.DebugAvailable() and self.GetIECProgramsAndVariables():

self.logger.write(_("Debugger ready\n"))

self._connect_debug()

text += "\n}\n\n"

Gen_Cfile_path = os.path.join(buildpath, "CFile_%s.c" % location_str)

cfile.write(text)

cfile.close()

matiec_CFLAGS = '"-I%s"' % os.path.abspath(self.GetCTRoot().GetIECLibPath())

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

if res:

raise Exception, res

def LoadPrevious(self):

self.LoadCurrentPrevious()

Gen_OD_path = os.path.join(buildpath, "OD_%s.c" % prefix )

# Create a new copy of the model with DCF loaded with PDO mappings for desired location

try:

except config_utils.PDOmappingException, e:

raise Exception, e.message

# Do generate C file.

dump(master, file)

file.close()

def LoadPrevious(self):

self.Manager.LoadCurrentPrevious()

</xsd:schema>

"""

def GetParamsAttributes(self, path = None):

infos = ConfigTreeNode.GetParamsAttributes(self, path = path)

for element in infos:

can_driver_name = ""

"candriver": can_driver_name,

"nodes_includes": "",

"board_decls": "",

"pre_op_register": "",

}

for child in self.IECSortedChildren():

nodename = "OD_%s" % childlocstr

# Try to get Slave Node

"}\n")

# register previously declared func as post_SlaveBootup callback for that node

format_dict["slavebootup_register"] += (

format_dict["pre_op"] += (

"static void %s_preOperational(CO_Data* d){\n " % (nodename)+

"".join([" masterSendNMTstateChange(d, %d, NMT_Reset_Comunication);\n" % NdId for NdId in SlaveIDs])+

"}\n")

format_dict["pre_op_register"] += (

else:

# Slave node

align = child_data.getSync_Align()

" }\n"+

"}\n")

format_dict["post_sync_register"] += (

format_dict["nodes_init"] += 'NODE_SLAVE_INIT(%s, %s)\n ' % (

nodename,

child_data.getNodeId())

format_dict["nodes_close"] += 'NODE_CLOSE(%s)\n ' % (nodename)

format_dict["nodes_stop"] += 'NODE_STOP(%s)\n ' % (nodename)

cf_main = open(filename).read() % format_dict

cf_main_path = os.path.join(buildpath, "CF_%(locstr)s.c" % format_dict)

f.write(cf_main)

f.close()

if can_driver is not None:

if os.path.exists(can_driver_path):

return res

from types import *

# Translation between IEC types and Can Open types

# Constants for PDO types

RPDO = 1

VariableIncrement = 0x100

VariableStartIndex = {TPDO: 0x2000, RPDO: 0x4000}

VariableDirText = {TPDO: "__I", RPDO: "__Q"}

TrashVariables = [(1, 0x01), (8, 0x05), (16, 0x06), (32, 0x07), (64, 0x1B)]

RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(node)

# Get Slave's default SDO server parameters

if not RSDO_cobid:

RSDO_cobid = 0x600 + nodeid

if not TSDO_cobid:

TSDO_cobid = 0x580 + nodeid

format(a1 = location["IEC_TYPE"], a2 = COlocationtype, a3 = subentry_infos["type"], a4 = name)

typeinfos = node.GetEntryInfos(COlocationtype)

else:

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

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

# Generate entry name

indexname = "%s%s%s_%d" % (VariableDirText[variable_infos["pdotype"]],

variable_infos["sizelocation"],

variable_infos["nodeid"])

# Search for an entry that has an empty subindex

dcfgenerator = ConciseDCFGenerator(nodelist, nodename)

dcfgenerator.GenerateDCF(locations, current_location, sync_TPDOs)

# allow access to local OD from Master PLC

pointers.update(LocalODPointers(locations, current_location, masternode))

def LocalODPointers(locations, current_location, slave):

# Extract command options

try:

except getopt.GetoptError:

# print help information and exit:

usage()

result = nodelist.LoadProject("test_config")

# List of locations, we try to map for test

# Generate MasterNode configuration

try:

"""

servicetype, location = uri.split("://")

urlpath, realm, ID = location.split('#')

url = urlprefix+"://"+urlpath

def RegisterWampClient():

# create a WAMP application session factory

component_config = types.ComponentConfig(

realm = realm,

session_factory = wamp.ApplicationSessionFactory(

config = component_config)

session_factory.session = WampSession

reactor.run(installSignalHandlers=False)

def WampSessionProcMapper(funcname):

global _WampSession

if _WampSession is not None:

try:

return threads.blockingCallFromThread(

reactor, _WampSession.call, wampfuncname,

except TransportLost, e:

confnodesroot.logger.write_error(_("Connection lost!\n"))

confnodesroot._SetConnector(None)

errmess = traceback.format_exc()

confnodesroot.logger.write_error(errmess+"\n")

print errmess

def _GetLocalConnectorClassFactory(name):

return lambda: getattr(__import__(name, globals(), locals()), name + "_connector_factory")

for name in listdir(_base_path)

if path.isdir(path.join(_base_path, name))

and not name.startswith("__")}

(self._cols, self.GetNumberCols(), wx.grid.GRIDTABLE_NOTIFY_COLS_DELETED, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED),

]:

if new < current:

grid.ProcessTableMessage(msg)

elif new > current:

grid.ProcessTableMessage(msg)

self.UpdateValues(grid)

grid.EndBatch()

# Search for the nearest point from mouse position

if len(x_data) > 0 and len(y_data) > 0:

length = min(len(x_data), len(y_data))

# Set cursor tick to the tick of this point

cursor_tick = x_data[numpy.argmin(d), 0]

# and set cursor tick to the tick of this point

if len(data) > 0:

cursor_tick = data[numpy.argmin(

# Update cursor tick

if cursor_tick is not None:

def SetAxesColor(self, color):

if LooseVersion(matplotlib.__version__) >= LooseVersion("1.5.0"):

else:

self.Axes.set_color_cycle(color)

oldest_message = (-1, None)

else:

dump_end = prev - 1

new_message = self.GetLogMessageFromSource(msgidx, level)

if new_message is None:

if prev is None:

getattr(CT, "TR_ALIGN_WINDOWS_RIGHT", CT.TR_ALIGN_WINDOWS))

self.VariablesList.SetIndent(0)

self.VariablesList.SetSpacing(5)

self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

self.OnVariablesListItemActivated)

self.VariablesList.Bind(wx.EVT_LEFT_DOWN, self.OnVariablesListLeftDown)

flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT)

self.Scalings = {}

scaling_panel = wx.Panel(scaling_nb, style=wx.TAB_TRAVERSAL)

scalingpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=5)

scalingpanel_sizer.AddGrowableCol(1)

flag=wx.BOTTOM|wx.LEFT)

self.ContentDescription = wx.TextCtrl(self.MiscellaneousPanel,

self.Bind(wx.EVT_TEXT_ENTER, self.OnContentDescriptionChanged,

self.ContentDescription)

self.ContentDescription.Bind(wx.EVT_KILL_FOCUS,

editor = wx.grid.GridCellChoiceEditor()

excluded = []

if self.Parent.IsFunctionBlockType(var_type):

editor.SetParameters(",".join([_(choice) for choice in self.Parent.ClassList if choice not in excluded]))

elif colname != "Documentation":

grid.SetReadOnly(row, col, True)

elif (element_type not in ["config", "resource", "function"] and values[1] == "Global" and

self.ParentWindow.Filter in ["All", "Interface", "External"] or

element_type != "function" and values[1] in ["location", "NamedConstant"]):

var_name = values[3]

else:

var_name = values[0]

var_infos.Class = "Global"

var_infos.Location = location

elif values[1] == "NamedConstant":

var_infos.Class = "Local"

var_infos.InitialValue = values[0]

else:

l = wx.ALIGN_LEFT

c = wx.ALIGN_CENTER

else:

# this is an element that cannot have located variables

l = wx.ALIGN_LEFT

c = wx.ALIGN_CENTER

self.PanelWidthMin = sum(self.ColSizes)

def RefreshTypeList(self):

if self.Filter == "All":

elif self.Filter == "Interface":

elif self.Filter == "Variables":

else:

self.ClassList = [self.Filter]

self.RefreshValues()

self.SaveValues()

# build a submenu containing standard IEC types

base_menu = wx.Menu(title='')

for base_type in self.Controler.GetBaseTypes():

type_menu.AppendMenu(wx.NewId(), _("Base Types"), base_menu)

# build a submenu containing user-defined types

datatype_menu = wx.Menu(title='')

datatypes = self.Controler.GetDataTypes(basetypes = False, confnodetypes = False)

self.BuildLibsTypesMenu(type_menu)

self.BuildArrayTypesMenu(type_menu)

self.Table = ActionTable(self, [], GetActionTableColnames())

typelist = GetTypeList()

self.TranslateType = dict([(_(value), value) for value in typelist])

self.ColSizes = [60, 90, 130, 200, 50]

self.ColAlignements = [wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]

# Add function to preview panel so that it answers to graphic elements

# like Viewer

setattr(self.Preview, "GetBlockType", controller.GetBlockType)

setattr(self.Preview, "IsOfType", controller.IsOfType)

# Create text control for defining connection name

self.ConnectionName = wx.TextCtrl(self)

self.Bind(wx.EVT_TEXT, self.OnNameChanged, self.ConnectionName)

self.LeftGridSizer.AddWindow(self.ConnectionName, flag=wx.GROW)

# Add preview panel and associated label to sizers

self.LeftGridSizer.AddWindow(self.PreviewLabel, flag=wx.GROW)

self.LeftGridSizer.AddWindow(self.Preview, flag=wx.GROW)

def OnIpButton(self, event):

if self.LatestSelection is not None:

self.EndModal(wx.ID_OK)

event.Skip()

# Create a list box to selected variable expression in the list of

# variables defined in POU

style=wx.LB_SINGLE|wx.LB_SORT)

self.Bind(wx.EVT_LISTBOX, self.OnNameChanged, self.VariableName)

self.RightGridSizer.AddWindow(self.VariableName, border=4, flag=wx.GROW|wx.TOP)

self.SetStatusText(message)

if len(self.criteria) > 0:

wx.CallAfter(self.ParentWindow.FindInPou,

self.criteria)

event.Skip()

infos_sizer.AddWindow(actionname_label, border=4,

flag=wx.ALIGN_CENTER_VERTICAL|wx.TOP)

infos_sizer.AddWindow(self.ActionName, flag=wx.GROW)

language_label = wx.StaticText(self, label=_('Language:'))

infos_sizer.AddWindow(transitionname_label, border=4,

flag=wx.ALIGN_CENTER_VERTICAL|wx.TOP)

infos_sizer.AddWindow(self.TransitionName, flag=wx.GROW)

language_label = wx.StaticText(self, label=_('Language:'))

@param tagname: Tagname of project POU edited

@param initial: True if step is initial (default: False)

"""

title=_('Edit Step'))

# Init common sizers

self.CaseSensitive = wx.CheckBox(self, label=_('Case sensitive'))

pattern_sizer.AddWindow(self.CaseSensitive, flag=wx.GROW)

self.Bind(wx.EVT_TEXT, self.FindPatternChanged, self.Pattern)

pattern_sizer.AddWindow(self.Pattern, flag=wx.GROW)

self.Bind(wx.EVT_CHAR_HOOK, self.OnEscapeKey)

else:

return None

else:

if(os.path.isfile(readerexepath)):

open_lin_pdf(readerexepath, pdffile, pagenum)

else:

wx.MessageBox("Inkscape is not found or installed !")

return None

else:

if(os.path.isfile(svgexepath)):

open_lin_svg(svgexepath, svgfile)

else:

self.SetProperty("fold", "1")

self.SetProperty("tab.timmy.whinge.level", "1")

self.SetViewWhiteSpace(False)

self.ParentWindow = window

self.Controler = controler

self.Table = VariablesTable(self, [], self.GetVariableTableColnames())

self.ColAlignements = [wx.ALIGN_RIGHT] + \

[wx.ALIGN_LEFT]*(len(self.VariablesDefaultValue))

def GetVariableTableColnames(self):

_ = lambda x: x

def RefreshModel(self):

self.Controler.SetVariables(self.Table.GetData())

bmp = self.bmpFocus

if self.bmpSelected and not self.up:

bmp = self.bmpSelected

if not self.up:

dw = dy = self.labelDelta

hasMask = bmp.GetMask() != None

msizer = wx.BoxSizer(wx.HORIZONTAL)

for confnode_method in self.Controler.ConfNodeMethods:

button = GenBitmapTextButton(self.Editor,

bitmap=GetBitmap(confnode_method.get("bitmap", "Unknown")),

label=confnode_method["name"], style=wx.NO_BORDER)

button.Bind(wx.EVT_ENTER_WINDOW, setFontStyle(button, mouseover_bt_font))

button.Bind(wx.EVT_LEAVE_WINDOW, setFontStyle(button, normal_bt_font))

# hack to force size to mini

button.Disable()

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

return msizer

self.GetCheckBoxCallBackFunction(checkbox, element_path),

checkbox)

if element_infos["type"].startswith("unsigned"):

scmin = 0

else:

# Disable button to prevent re-entrant call

event.GetEventObject().Disable()

# Call

# Re-enable button

event.GetEventObject().Enable()

element_tree = {}

for element in elements:

if element not in element_tree:

GenerateTree(element, element_tree, stop_list)

elif element_tree[element]:

element_tree[element]["parents"].append("start")

for element, values in element_tree.items():

if "stop" in values["children"]:

removed = []

if next in element_tree:

element_tree[next]["parents"].append(element)

else:

GenerateTree(next, element_tree, stop_list)

if returntype == "BOOL":

varlist.append(self.Controler.GetEditedElementName(self.TagName))

dialog.SetVariables(varlist)

if dialog.ShowModal() == wx.ID_OK:

values = dialog.GetValues()

startx, starty = LD_OFFSET[0], 0

left_element = self.SelectedElement.EndConnected

if not isinstance(left_element.GetParentBlock(), LD_Coil):

wires.append(self.SelectedElement)

if False not in [self.IsWire(element) for element in self.SelectedElement.GetElements()]:

for element in self.SelectedElement.GetElements():

wires.append(element)

if var.Class != "Output" and var.Type == "BOOL":

varlist.append(var.Name)

dialog.SetVariables(varlist)

if dialog.ShowModal() == wx.ID_OK:

values = dialog.GetValues()

points = wires[0].GetSelectedSegmentPoints()

right_index = []

for block in blocks:

connectors = block.GetConnectors()

block_infos.update(connectors)

for connector in block_infos["inputs"]:

for wire, handle in connector.GetWires():

if returntype == "BOOL":

varlist.append(self.Controler.GetEditedElementName(self.TagName))

dialog.SetVariables(varlist)

if dialog.ShowModal() == wx.ID_OK:

values = dialog.GetValues()

powerrail = right_elements[0].GetParentBlock()

if interval != "" and IEC_TIME_MODEL.match(interval.upper()) is None:

error = True

elif colname == "Single":

editor.SetParameters(self.Parent.VariableList)

if self.GetValueByName(row, "Triggering") != "Interrupt":

grid.SetReadOnly(row, col, True)

single = self.GetValueByName(row, colname)

error = True

elif colname == "Triggering":

editor = wx.grid.GridCellChoiceEditor()

return blockName

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

# Full "SFC_StandardRules" table would be symmetrical and

# to avoid duplicate records and minimize the table only upper part is defined.

if (direction == SOUTH or direction == EAST):

# Adding a rubberband to Viewer

self.rubberBand = RubberBand(viewer=self)

self.Editor.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

self.ResetView()

self.LastClientSize = None

comment = Comment(self, value, id)

comment.SetPosition(bbox.x, bbox.y)

min_width, min_height = comment.GetMinSize()

self.AddComment(comment)

self.Controler.AddEditedElementComment(self.TagName, id)

self.RefreshCommentModel(comment)

def AddNewStep(self, bbox, initial=False, wire=None):

if wire is not None:

values = {

"output": True,

else:

dialog = SFCStepDialog(self.ParentWindow, self.Controler, self.TagName, initial)

dialog.SetPreviewFont(self.GetFont())

dialog = SFCTransitionDialog(self.ParentWindow, self.Controler, self.TagName, self.GetDrawingMode() == FREEDRAWING_MODE)

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(transition.GetSize())

if dialog.ShowModal() == wx.ID_OK:

values = dialog.GetValues()

rect = transition.GetRedrawRect(1, 1)

transition.SetPriority(values["priority"])

rect = rect.Union(transition.GetRedrawRect())

self.RefreshTransitionModel(transition)

outputs = connectors.get("outputs", [])

self.Description = None

if self.ExecutionControl:

self.Pen = MiterPen(self.Colour)

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

from math import *

from types import *

import datetime

from graphics.ToolTipProducer import ToolTipProducer

from graphics.DebugDataConsumer import DebugDataConsumer

[HANDLE_MOVE, HANDLE_RESIZE, HANDLE_POINT, HANDLE_SEGMENT, HANDLE_CONNECTOR] = range(5)

# List of value for resize handle that are valid

# Contants for defining the direction of a connector

# Contants for defining which mode is selected for each view

[MODE_SELECTION, MODE_BLOCK, MODE_VARIABLE, MODE_CONNECTION, MODE_COMMENT,

self.oldPos = None

self.StartPos = None

self.CurrentDrag = None

self.Dragging = False

self.Selected = False

self.Highlighted = False

# Method called when a LeftDown event have been generated

def OnLeftDown(self, event, dc, scaling):

for input in self.Inputs:

position = input.GetRelPosition()

self.RealConnectors["Inputs"].append(float(position.x)/float(self.Size[0]))

"""

if applicationDomain is None:

else:

applicationName = applicationDomain

currentDir = os.getcwd()

os.chdir(applicationDirectoryPath)

filelist = 'app.fil'

if not os.path.exists(filelist):

fileout = 'messages.pot'

# Steps:

"""

if applicationDomain is None:

else:

applicationName = applicationDomain

currentDir = os.getcwd()

if os.path.exists(langPOfileName):

fileList = ''

for fileName in listOf_extraPo:

cmd = "msgcat -s --no-wrap %s %s > %s.cat" % (langPOfileName, fileList, langPOfileName)

if verbose: print cmd

os.system(cmd)

if targetDir is None:

pass

else:

if verbose: print cmd

os.system(cmd)

os.chdir(currentDir)

"""Compile the Portable Object files into the Machine Object stored in the right location.

makeMO converts all translated language-specific PO files located inside

print "Target directory for .mo files is: %s" % targetDir

if applicationDomain is None:

else:

applicationName = applicationDomain

currentDir = os.getcwd()

else:

langPOfileName = "%s_%s.po" % (applicationName, langCode)

if os.path.exists(langPOfileName):

if not os.path.exists(mo_targetDir):

mkdir(mo_targetDir)

if verbose: print cmd

os.system(cmd)

os.chdir(currentDir)

print "\n ERROR: %s" % errorMsg

"""fileBaseOf(filename,withPath) ---> string

Return base name of filename. The returned string never includes the extension.

if os.sep == '/':

return thePath

else:

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

option['domain'] = None

option['moTarget'] = None

try:

except getopt.GetoptError, e:

printUsage(e[0])

sys.exit(1)

if (opt == '-h'):

printUsage()

sys.exit(0)

print "Application domain used is: '%s'" % option['domain']

if option['po']:

try:

except IOError, e:

printUsage(e[1] + '\n You must write a file app.fil that contains the list of all files to parse.')

if option['mo']:

sys.exit(1)

# Override gettext _ in this module

# since we just want string to be added to dictionnary

# but translation should happen here

LOCATIONDATATYPES = {"X": ["BOOL"],

"B": ["SINT", "USINT", "BYTE", "STRING"],

# Function Block Types definitions

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

def GetBlockInfos(pou):

DefaultType = "DINT"

DataTypeRange_list = [

]

ANY_TO_ANY_FILTERS = {

# simple type conv are let as C cast

# REAL_TO_INT

# TO_TIME

# FROM_TIME

(("TIME",), ("ANY_STRING",)),

(("DATE",), ("ANY_STRING",)),

# TO_STRING

(("ANY_REAL",), ("ANY_STRING",)),

(("ANY_SINT",), ("ANY_STRING",)),

(("ANY_UINT",), ("ANY_STRING",)),

(("ANY_STRING",), ("ANY_BIT",)),

(("ANY_STRING",), ("ANY_SINT",)),

(("ANY_STRING",), ("ANY_UINT",)),

}

# remove gettext override

"""

Define in which order var types must be displayed

"""

"""

Define which action qualifier must be associated with a duration

setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)

def appendcontentInstance(self, instance):

self.content.appendcontent(instance)

else:

raise TypeError, _("%s body don't have instances!") % self.content.getLocalTag()

setattr(cls, "appendcontentInstance", appendcontentInstance)

def getcontentInstances(self):

return self.content.getcontent()

else:

raise TypeError, _("%s body don't have instances!") % self.content.getLocalTag()

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

instance_by_name_xpath = PLCOpen_XPath("ppx:block[@instanceName=$name]")

def getcontentInstance(self, local_id):

instance = instance_by_id_xpath(self.content, localId=local_id)

if len(instance) > 0:

return instance[0]

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):