def CreateApplication(self):

if os.path.exists("BEREMIZ_DEBUG"):

__builtin__.__dict__["BMZ_DBG"] = True

__builtin__.__dict__["BMZ_DBG"] = False

global wxversion, wx

def updateinfoproc():

global updateinfo

import urllib2

updateinfo = urllib2.urlopen(self.updateinfo_url,None).read()

updateinfo = _("update info unavailable.")

from threading import Thread

if wx.Platform == '__WXMSW__':

faces = {

}

else:

faces = {

}

from threading import Lock,Timer,currentThread

self.YieldLock.release()

def _write(self):

self.output.Freeze()

self.lock.acquire()

for s, style in self.stack:

if style != self.black_white:

self.output.StartStyling(self.output.GetLength(), 0xff)

sys.executable,

Bpath("Beremiz_service.py"),

self.runtime_port,

self.local_runtime_tmpdir),

no_gui=False,

timeout=500, keyword = self.local_runtime_tmpdir,

self.SaveLastState()

Thing()

self.ToDoBeforeQuit = []

except:

defaultpath = os.path.expanduser("~")

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

projectpath = dialog.GetPath()

self.Config.Write("lastopenedfolder",

except:

defaultpath = os.path.expanduser("~")

wx.RESIZE_BORDER)

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

self.OpenProject(dialog.GetPath())

def OnOK(self, event):

value = self.GetValue()

for function, message in self.Tests:

if not function(value):

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

ip_addr = '' if ip_addr is None else ip_addr

dlg = ParamsEntryDialog(None, _("Enter the IP of the interface to bind"), defaultValue=ip_addr)

dlg.SetTests([(re.compile('\d{1,3}(?:\.\d{1,3}){3}$').match, _("IP is not valid!")),

])

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

self.pyroserver.ip_addr = dlg.GetValue()

def OnTaskBarChangePort(self, evt):

dlg = ParamsEntryDialog(None, _("Enter a port number "), defaultValue=str(self.pyroserver.port))

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

self.pyroserver.port = int(dlg.GetValue())

self.pyroserver.Stop()

servicename = self.pyroserver.servicename

servicename = '' if servicename is None else servicename

dlg = ParamsEntryDialog(None, _("Enter a name "), defaultValue=servicename)

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

self.pyroserver.servicename = dlg.GetValue()

self.pyroserver.Restart()

wx.CallAfter(wx.GetApp().ExitMainLoop)

def UpdateIcon(self, plcstatus):

currenticon = self.MakeIcon(starticon)

elif plcstatus is "Stopped":

currenticon = self.MakeIcon(stopicon)

self.plcobj.AutoLoad()

if self.plcobj.GetPLCstatus()[0] != "Empty":

self.plcobj.StartPLC()

self.plcobj.StatusChange()

installThreadExcepthook()

if havetwisted:

try:

import runtime.NevowServer as NS

except Exception, e:

webport = None

NS.WorkingDir = WorkingDir

try:

import runtime.WampClient as WC

except Exception, e:

execfile(extfilename, locals())

if havetwisted:

try:

website = NS.RegisterWebsite(webport)

pyruntimevars["website"] = website

except Exception, e:

print _("Nevow Web service failed. "), e

try:

WC.RegisterWampClient(wampconf)

pyruntimevars["wampsession"] = WC.GetSession

elif havewx:

app.MainLoop()

else:

pyroserver.Loop()

except KeyboardInterrupt,e:

pass

def GetVariables(self):

datas = []

for var in self.CodeFileVariables(self.CodeFile):

})

return datas

while res in AllChannels: # While channel not free

if res < CurrentChannel: # Want to go down ?

res -= 1 # Test for n-1

self.GetCTRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n") % CurrentChannel)

return CurrentChannel # Can't go bellow 0, do nothing

res += 1 # Test for n-1

# Finally set IEC Channel

self.BaseParams.setIEC_Channel(res)

# - Item icon filename

# - Item tooltip text

EditorToolBarItems = {

"debug": [(True, FREEDRAWING_MODE|DRIVENDRAWING_MODE,

}

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

def SetRefreshFunctions(self):

self.RefreshFunctions = {

PAGETITLES: self.RefreshPageTitles}

## Call PLCOpenEditor refresh functions.

if name != "Project":

new_id = wx.NewId()

AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Add POU"))

new_id = wx.NewId()

AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Paste POU"))

# Viewer Printout

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

class GraphicPrintout(wx.Printout):

"list": [block for block in category["list"]

if block["type"] in filter]}

for category in self.TotalTypes]

"list": [pou.getblockInfos()

for pou in project.getpous(name, filter)

if (name is None or

def GetElementType(self, tagname):

words = tagname.split("::")

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

# Project opened Data types management functions

# Dictionary associating PLCOpen variable categories to the corresponding

# IEC 61131-3 variable categories

# Dictionary associating PLCOpen POU categories to the corresponding

# IEC 61131-3 POU categories

errorVarTypes = {

def JoinList(separator, mylist):

""" Helper for emulate join on element list """

return reduce(lambda x, y: x + separator + y, mylist)

return mylist

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

for i, dimension in enumerate(basetype_content.getdimension())]

datatype_def += [("ARRAY [", ())]

datatype_def += JoinList([(",", ())], dimensions)

(basetype_name, (tagname, "base"))]

# Data type is a structure

elif basetype_content_type == "struct":

format(a1 = task.getname(), a2 = config_name, a3 = resource.getname())

raise PLCGenException, msg

SNGLKW = "MULTI"

else:

SNGLKW = "SINGLE"

self.GenerateSFCJump(instance, pou)

if len(self.InitialSteps) > 0 and len(self.SFCComputedBlocks) > 0:

action_name = "COMPUTE_FUNCTION_BLOCKS"

self.SFCNetworks["Steps"][self.InitialSteps[0]]["actions"].append(action_infos)

self.SFCNetworks["Actions"][action_name] = (self.SFCComputedBlocks, ())

self.Program = []

for initialstep in self.InitialSteps:

self.ComputeSFCStep(initialstep)

else:

orderedInstances = []

for instance in body.getcontentInstances():

if isinstance(instance, (OutVariableClass, InOutVariableClass, BlockClass)):

if step_name not in self.SFCNetworks["Steps"].keys():

if step.getinitialStep():

self.InitialSteps.append(step_name)

self.SFCNetworks["Steps"][step_name] = step_infos

if step.connectionPointIn is not None:

instances = []

if step_name in self.SFCNetworks["Steps"].keys():

actions = actionBlock.getactions()

for i, action in enumerate(actions):

if "duration" in action:

action_infos["duration"] = action["duration"]

if "indicator" in action:

steps.extend(self.ExtractConvergenceInputs(step, pou))

elif isinstance(instance, SimultaneousConvergenceClass):

steps.extend(self.ExtractConvergenceInputs(instance, pou))

"priority": transition.getpriority(),

self.SFCNetworks["Transitions"][transition] = transition_infos

transitionValues = transition.getconditionContent()

if transitionValues["type"] == "inline":

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

if len(self.Interface) == 0:

raise PLCGenException, _("No variable defined in \"%s\" POU") % self.Name

raise PLCGenException, _("No body defined in \"%s\" POU") % self.Name

var_number = 0

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

if result:

ignored_exceptions.append(ex)

info = {

}

if e_traceback:

info['traceback'] = ''.join(traceback.format_tb(e_traceback)) + '%s: %s' % (e_type, e_value)

return self.CTR()

def GetTypes(self):

def GetLibraryPath(self):

raise Exception("Not implemented")

path = os.getenv("USERPROFILE")

else:

path = os.getenv("HOME")

answer = dirdialog.ShowModal()

dirdialog.Destroy()

if answer == wx.ID_OK:

# prepare debug code

variable_decl_array = []

bofs = 0

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

variable_decl_array += [

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

# Build

try:

self.logger.write_error(_("C Build failed.\n"))

return False

except Exception, exc:

status = "Disconnected"

if(self.previous_plcstate != status):

for args in {

}.get(status,[]):

self.ShowMethod(*args)

self.previous_plcstate = status

plc_status, Traces = self._connector.GetTraceVariables()

debug_getvar_retry += 1

#print [dict.keys() for IECPath, (dict, log, status, fvalue) in self.IECdebug_datas.items()]

if len(Traces) > 0:

Failed = False

self.IECdebug_lock.acquire()

debug_vars = UnpackDebugBuffer(debug_buff, self.TracedIECTypes)

if (debug_vars is not None and

len(debug_vars) == len(self.TracedIECPath)):

MD5 = self.GetLastBuildMD5()

# Check if md5 file is empty : ask user to build PLC

self.logger.write_error(_("Failed : Must build before transfer.\n"))

return False

builder = self.GetBuilder()

if builder is not None:

data = builder.GetBinaryCode()

if self._connector.NewPLC(MD5, data, extrafiles) and self.GetIECProgramsAndVariables():

self.UnsubscribeAllDebugIECVariable()

self.ProgramTransferred()

wx.CallAfter(self.UpdateMethodsFromPLCStatus)

StatusMethods = [

]

ConfNodeMethods = [

]

dialog.Destroy()

ConfNodeMethods = [

]

def CTNTestModified(self):

# allow access to local OD from Slave PLC

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

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

raise Exception, res

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

raise Exception, res

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

return self._View

ConfNodeMethods = [

]

def OnCloseEditor(self, view):

raise Exception, e.message

# Do generate C file.

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

raise Exception, res

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

def GetCanDriver(self):

res = self.CanFestivalInstance.getCAN_Driver()

return ""

return res

can_driver = self.GetCanDriver()

if can_driver is not None:

can_drivers = local_canfestival_config.DLL_LIST

can_driver = can_drivers[0]

can_drv_ext = self.GetCTRoot().GetBuilder().extension

can_drv_prefix = self.GetCTRoot().GetBuilder().dlopen_prefix

can_driver_name = ""

}

for child in self.IECSortedChildren():

childlocstr = "_".join(map(str,child.GetCurrentLocation()))

RPDO = 1

TPDO = 2

VariableIncrement = 0x100

VariableTypeOffset = dict(zip(["","X","B","W","D","L"], range(6)))

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

for PdoIdx in nodeRpdoIndexes + nodeTpdoIndexes:

pdo_cobid = node.GetEntry(PdoIdx, 0x01)

# Extract COB ID, if PDO isn't active

pdo_cobid -= 0x80000000

# Remove COB ID from the list of available COB ID

if pdo_cobid in self.ListCobIDAvailable:

RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(self.MasterNode)

# Store the indexes of the first RPDO and TPDO available for MasterNode

# Prepare MasterNode with all nodelist slaves

for idx, (nodeid, nodeinfos) in enumerate(self.NodeList.SlaveNodes.items()):

@param pdomapping: list od variables to map with PDO

"""

# Add an entry to MasterMapping

# Return the data to add to DCF

if sync_TPDOs:

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] = {"type":COlocationtype, "pdotype":SlavePDOType[direction],

for value in values[1:]:

if value != 0:

mapping.append(value % 0x100)

# Indicate that this PDO entry must be saved

if locationinfos["bit"] is not None:

else:

# Add location to those that haven't been mapped yet

if locationinfos["nodeid"] not in self.LocationsNotMapped.keys():

self.LocationsNotMapped[locationinfos["nodeid"]][locationinfos["pdotype"]].append((name, locationinfos))

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

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)

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

_WampSession = None

print 'WAMP session left'

def WAMP_connector_factory(uri, confnodesroot):

wampfuncname = '.'.join((ID,funcname))

def catcher_func(*args,**kwargs):

global _WampSession

try:

return threads.blockingCallFromThread(

reactor, _WampSession.call, wampfuncname,

return member

# Try to get the proxy object

return WampPLCObjectProxy()

except Exception, msg:

confnodesroot.logger.write_error(_("WAMP connection to '%s' failed.\n") % location)

if wx.Platform == '__WXMSW__':

faces = { 'times': 'Times New Roman',

'other': 'Comic Sans MS',

}

else:

faces = { 'times': 'Times',

'other': 'new century schoolbook',

}

NAVIGATION_KEYS = [

# Set data associated to tree item (only save that item is a

# category)

# Iterate over functions and function blocks defined in library

# category add a tree item to category tree item for each of

# Define data to associate to block tree item

comment = blocktype["comment"]

self.Tree.SetPyData(blocktype_item, block_data)

# Select block tree item in tree if it corresponds to

child_name = GenerateName(infos[3:])

child_infos = {"name": child_name,

"type": child_type,

"text": text,

"matches": 1,

"children": [],

def GetVariableTableColnames(location):

if location:

return ["#", _("Name"), _("Class"), _("Type"), _("Location"), _("Initial Value"), _("Option"), _("Documentation")]

return ["#", _("Name"), _("Class"), _("Type"), _("Initial Value"), _("Option"), _("Documentation")]

def GetOptions(constant=True, retain=True, non_retain=True):

options = [""]

if constant:

options.append(_("Constant"))

def GetFilterChoiceTransfer():

return {_("All"): _("All"), _("Interface"): _("Interface"),

_(" Input"): _("Input"), _(" Output"): _("Output"), _(" InOut"): _("InOut"),

_(" External"): _("External"), _("Variables"): _("Variables"), _(" Local"): _("Local"),

value = getattr(self.data[row], colname, "")

if colname == "Type" and isinstance(value, TupleType):

if value[0] == "array":

if not isinstance(value, (StringType, UnicodeType)):

value = str(value)

if colname in ["Class", "Option"]:

if element_type in ["functionBlock","program"]:

var_infos.Class = "Local"

var_infos.InitialValue = values[0]

return

else:

var_infos.Class = "External"

self.DefaultValue = _VariableInfos("", "", "", "", "", True, "", DefaultType, ([], []), 0)

if element_type in ["config", "resource"]:

else:

if element_type in ["config", "resource"] \

or element_type in ["program", "transition", "action"]:

if isinstance(infos, TupleType) and infos[0] == "array":

self.BaseType.SetStringSelection(infos[1])

elif infos in datatypes:

self.BaseType.SetStringSelection(infos)

def GetDirFilterChoiceOptions():

return [(_("All"), [LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY]),

(_("Input"), [LOCATION_VAR_INPUT]),

(_("Output"), [LOCATION_VAR_OUTPUT]),

def GetTypeFilterChoiceOptions():

return [_("All"),

_("Type and derivated"),

_("Type strict")]

self.LatestSelection=None

def __del__(self):

self.ZeroConfInstance.close()

def RefreshList(self):

self.Browser = ServiceBrowser(self.ZeroConfInstance, service_type, self)

def OnRefreshButton(self, event):

def OnIpButton(self, event):

if self.LatestSelection is not None:

self.URI = "%s://%s:%s" % tuple(map(l,(1,2,3)))

self.EndModal(wx.ID_OK)

event.Skip()

# Dictionaries containing correspondence between variable block class and string

# to be shown in Class combo box in both sense

VARIABLE_CLASSES_DICT_REVERSE = dict(

[(value, key) for key, value in VARIABLE_CLASSES_DICT.iteritems()])

# Helpers

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

def gen_get_function(f):

def GetActionLanguages():

return [_("IL"), _("ST"), _("LD"), _("FBD")]

ACTION_LANGUAGES_DICT = dict([(_(language), language) for language in GetActionLanguages()])

def GetPouTypes():

return [_("function"), _("functionBlock"), _("program")]

POU_TYPES_DICT = dict([(_(pou_type), pou_type) for pou_type in GetPouTypes()])

def GetPouLanguages():

return [_("IL"), _("ST"), _("LD"), _("FBD"), _("SFC")]

def GetTransitionLanguages():

return [_("IL"), _("ST"), _("LD"), _("FBD")]

TRANSITION_LANGUAGES_DICT = dict([(_(language), language) for language in GetTransitionLanguages()])

Return SFC transition parameters defined in dialog

@return: {parameter_name: parameter_value,...}

"""

values["type"], values["value"] = self.GetTransitionType()

values["width"], values["height"] = self.Element.GetSize()

return values

def open_win_pdf(readerexepath, pdffile, pagenum = 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)

def open_lin_pdf(readerexepath, pdffile, pagenum = None):

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

else:

print "Open pdf %s at page %d" % (pdffile, pagenum)

def open_pdf(pdffile, pagenum = None):

try:

readerpath = get_acroversion()

except:

def open_win_svg(svgexepath, svgfile):

""" Open Inkscape on Windows platform """

popenargs = [svgexepath]

popenargs.append(svgfile)

subprocess.Popen(popenargs).pid

def open_lin_svg(svgexepath, svgfile):

""" Open Inkscape on Linux platform """

if os.path.isfile("/usr/bin/inkscape"):

def open_svg(svgfile):

""" Generic function to open SVG file """

try:

open_win_svg(get_inkscape_path(), svgfile)

except:

self.ParentWindow = window

self.Controler = controler

"Description":"", "OnChange":"", "Options":""}

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

self.ColAlignements = [wx.ALIGN_RIGHT] + \

self.Table.ResetView(self.VariablesGrid)

def GetVariableTableColnames(self):

return ["#", _("Name"),_("Type"), _("Initial"), _("Description"), _("OnChange"), _("Options")]

def RefreshModel(self):

if wx.Platform == '__WXMSW__':

faces = { 'times': 'Times New Roman',

'other': 'Comic Sans MS',

}

else:

faces = { 'times': 'Times',

'other': 'new century schoolbook',

}

SCROLLBAR_UNIT = 10

def GetElementsTableColnames():

return ["#", _("Name"), _("Type"), _("Initial Value")]

def GetDatatypeTypes():

return [_("Directly"), _("Subrange"), _("Enumerated"), _("Array"), _("Structure")]

DATATYPE_TYPES_DICT = dict([(_(datatype), datatype) for datatype in GetDatatypeTypes()])

if colname == "Type" and isinstance(value, TupleType):

if value[0] == "array":

return value

def SetValue(self, row, col, value):

def __init__(self, parent, tagname, window, controler):

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

self.StructureElementsTable = ElementsTable(self, [], GetElementsTableColnames())

self.StructureColSizes = [40, 150, 100, 250]

self.StructureColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]

self.EnumeratedInitialValue.SetStringSelection(type_infos["initial"])

elif type_infos["type"] == "Array":

self.ArrayBaseType.SetStringSelection(type_infos["base_type"])

self.ArrayInitialValue.SetValue(type_infos["initial"])

elif type_infos["type"] == "Structure":

self.StructureElementsTable.SetData(type_infos["elements"])

def RefreshTypeInfos(self):

selected = DATATYPE_TYPES_DICT[self.DerivationType.GetStringSelection()]

if selected == "Directly":

infos["base_type"] = self.DirectlyBaseType.GetStringSelection()

infos["initial"] = self.DirectlyInitialValue.GetValue()

self.StructureElementsTable.ClearHighlights(highlight_type)

self.RefreshView()

self.Highlights.append((infos, start, end, highlight_type))

self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)

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

def GetTasksTableColnames():

return [_("Name"), _("Triggering"), _("Single"), _("Interval"), _("Priority")]

def GetTaskTriggeringOptions():

return [_("Interrupt"), _("Cyclic")]

TASKTRIGGERINGOPTIONS_DICT = dict([(_(option), option) for option in GetTaskTriggeringOptions()])

def CheckSingle(single, varlist):

def GetInstancesTableColnames():

return [_("Name"), _("Type"), _("Task")]

self.RefreshHighlightsTimer = wx.Timer(self, -1)

self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)

self.TasksTable = ResourceTable(self, [], GetTasksTableColnames())

self.TasksTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_RIGHT, wx.ALIGN_RIGHT])

self.TasksTable.SetColSizes([200, 100, 100, 150, 100])

self.TasksTable.ResetView(self.TasksGrid)

self.TasksGrid.RefreshButtons()

self.InstancesTable = ResourceTable(self, [], GetInstancesTableColnames())

self.InstancesTable.SetColAlignements([wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT])

self.InstancesTable.SetColSizes([200, 150, 150])

message = _("\"%s\" is not a valid identifier!") % value

elif value.upper() in IEC_KEYWORDS:

message = _("\"%s\" is a keyword. It can't be used!") % value

message = _("An instance with the same name already exists!")

if message is not None:

event.Veto()

if wx.Platform == '__WXMSW__':

faces = { 'times': 'Times New Roman',

'other': 'Comic Sans MS',

}

else:

faces = { 'times': 'Times',

'other': 'new century schoolbook',

}

if wx.Platform == '__WXMSW__':

def loadInstance(self, instance, remaining_instances, selection):

self.current_id = max(self.current_id, instance.id)

creation_function = ElementCreationFunctions.get(instance.type, None)

specific_values = instance.specific_values

if creation_function is not None:

element = creation_function(self, instance.id, specific_values)

if element is None or element.TestHandle(event) == (0, 0):

connector = self.FindBlockConnector(pos, self.SelectedElement.GetConnectionDirection())

if connector is not None:

self.SelectedElement.OnMotion(event, dc, self.Scaling)

if self.SelectedElement.EndConnected is not None:

self.SelectedElement.ResetPoints()

dialog = FBDBlockDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(block.GetSize())

dialog.SetValues(old_values)

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

new_values = dialog.GetValues()

dialog = FBDVariableDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(variable.GetSize())

dialog.SetValues(old_values)

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

new_values = dialog.GetValues()

dialog = ConnectionDialog(self.ParentWindow, self.Controler, self.TagName, True)

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(connection.GetSize())

dialog.SetValues(values)

result = dialog.ShowModal()

dialog.Destroy()

dialog = LDElementDialog(self.ParentWindow, self.Controler, self.TagName, "contact")

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(contact.GetSize())

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

values = dialog.GetValues()

rect = contact.GetRedrawRect(1, 1)

dialog = LDElementDialog(self.ParentWindow, self.Controler, self.TagName, "coil")

dialog.SetPreviewFont(self.GetFont())

dialog.SetMinElementSize(coil.GetSize())

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

values = dialog.GetValues()

rect = coil.GetRedrawRect(1, 1)

dialog.SetMinElementSize(step.GetSize())

connectors = step.GetConnectors()

dialog.SetValues({

"input": len(connectors["inputs"]) > 0,

"output": len(connectors["outputs"]) > 0,

"action": step.GetActionConnector() != None})

# Returns all the block connectors

def GetConnectors(self):

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

def TestConnector(self, pt, direction = None, exclude = True):

return self.Description

# Adds an highlight to the block

if infos[0] in ["type", "name"] and start[0] == 0 and end[0] == 0:

highlights = self.Highlights.setdefault(infos[0], [])

AddHighlight(highlights, (start, end, highlight_type))

return connection

def GetConnectorTranslation(self, element):

# Unconnect connector

def Clean(self):

REFRESH_HIGHLIGHT_PERIOD = 0.1

HANDLE_CURSORS = {

}

position = connector.GetRelPosition()

self.RealConnectors.append(max(0., min(float(position.y - self.Extensions[0]) / float(height), 1.)))

elif len(self.Connectors) > 1:

else:

self.RealConnectors = [0.5]

Graphic_Element.OnLeftDown(self, event, dc, scaling)

return contact

def GetConnectorTranslation(self, element):

# Returns the RedrawRect

def GetRedrawRect(self, movex = 0, movey = 0):

return coil

def GetConnectorTranslation(self, element):

# Returns the RedrawRect

def GetRedrawRect(self, movex = 0, movey = 0):

return transition

def GetConnectorTranslation(self, element):

if self.Type == "connection" and self.Condition is not None:

connectors[self.Condition] = element.Condition

return connectors

self.Output.RefreshWires()

# Adds an highlight to the block

if infos[0] in ["reference", "inline", "priority"] and start[0] == 0 and end[0] == 0:

highlights = self.Highlights.setdefault(infos[0], [])

AddHighlight(highlights, (start, end, highlight_type))

return jump

def GetConnectorTranslation(self, element):

# Returns the RedrawRect

def GetRedrawRect(self, movex = 0, movey = 0):

return action_block

def GetConnectorTranslation(self, element):

# Returns the RedrawRect

def GetRedrawRect(self, movex = 0, movey = 0):

# m a k e P O ( ) -- Build the Portable Object file for the application --

# ^^^^^^^^^^^^^^^

#

"""Build the Portable Object Template file for the application.

makePO builds the .pot file for the application stored inside

if langCode == 'en':

pass

else:

if os.path.exists(langPOfileName):

cmd = 'msgmerge -s --no-wrap "%s" %s > "%s.new"' % (langPOfileName, fileout, langPOfileName)

if verbose: print cmd

os.chdir(currentDir)

"""Concatenate one or several PO files with the application domain files.

"""

if langCode == 'en':

pass

else:

if os.path.exists(langPOfileName):

fileList = ''

for fileName in listOf_extraPo:

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

if (langCode == 'en') and (forceEnglish==0):

pass

else:

if os.path.exists(langPOfileName):

mo_targetDir = "%s/%s/LC_MESSAGES" % (targetDir,langCode)

if not os.path.exists(mo_targetDir):

os.chdir(currentDir)

"""Displays how to use this script from the command line."""

print """

##################################################################################

print "\n ERROR: %s" % errorMsg

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

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

return os.path.basename(filename)

"""Create a directory (and possibly the entire tree).

The os.mkdir() will fail to create a directory if one of the

theDir += '/'

r"""Return a path name that contains Unix separator.

[Example]

LANGUAGES = ["IL","ST","FBD","LD","SFC"]

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

# Function Block Types definitions

"""

Dictionary that makes the relation between var names in plcopen and displayed values

"""

searchResultVarTypes = {

"outputVars": "var_output",

}

"""

# Array derived directly from an elementary type

else:

basetype_name = base_type_name

# Variable type is an elementary type

return vartype_content_name

setattr(cls, "gettypeAsText", gettypeAsText)

"ppx:interface/*[self::ppx:outputVars or self::ppx:inOutVars]/ppx:variable")

def getblockInfos(self):

block_infos = {

if self.interface is not None:

return_type = self.interface.getreturnType()

if return_type is not None:

def getconditionContent(self):

if self.condition is not None:

content = self.condition.getcontent()

if values["type"] == "reference":

values["value"] = content.getname()

elif values["type"] == "inline":

- The default modifier which can be "none", "negated", "rising" or "falling"

"""

for libname, tc6fname in StdTC6Libs}

[GetBlockInfos(pous) for pous in lib.getpous()]}

for libname, lib in StdBlckLibs.iteritems()]

Current_section = None

translate = {

"outputs":lambda x:[("OUT",x,"none")]}

for fields in table:

section_name = words[1]

else:

section_name = fields[0]

Standard_Functions_Decl.append(Current_section)

Function_decl_list = []

if Current_section:

Function_decl[param] = translate[param](value)

Function_decl["type"] = "function"

input_ovrloading_types = GetSubTypes(Function_decl["inputs"][0][1])

output_types = GetSubTypes(Function_decl["outputs"][0][1])

else:

for outype in output_types:

if outype != None:

decl_tpl = Function_decl["outputs"][0]

if funcdeclname_orig.endswith('*'):

funcdeclout = funcdeclin + '_' + outype

else:

store = True

for (InTypes, OutTypes) in ANY_TO_ANY_FILTERS.get(filter_name,[]):

outs = reduce(lambda a,b: a or b,

Function_decl["outputs"][0][1],

testtype), OutTypes))

inps = reduce(lambda a,b: a or b,

Function_decl["inputs"][0][1],

testtype), InTypes))

if inps and outs and Function_decl["outputs"][0][1] != Function_decl["inputs"][0][1]:

break

else:

store = False

# create the copy of decl dict to be appended to section

Function_decl_copy = Function_decl.copy()

Current_section["list"].append(Function_decl_copy)

configname = self.GetCTRoot().GetProjectConfigNames()[0]

pyextname = self.CTNName()

"name": variable.getname(),

"('"+variable.getname()+"')\"" \

if variable.getonchange() else '""',

if variable.getonchange() else None,

self.CodeFile.variables.variable)

# python side PLC global variables access stub

globalstubs = "\n".join(["""\

self._ResetLogCount()

def GetLogCount(self, level):

return int(self._GetLogCount(level))

elif self._loading_error is not None and level==0:

return 1

self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)

self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID")

self.PLC_ID.value = md5

self._startPLC = self.PLClibraryHandle.startPLC

class PLCSafeGlobals:

def __getattr__(_self, name):

t = self.python_runtime_vars["_"+name+"_ctype"]

except KeyError:

raise KeyError("Try to get unknown shared global variable : %s" % name)

r = self.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

return self.python_runtime_vars["_"+name+"_unpack"](v)