# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

import os

import sys

import getopt

wx.Yield()

time.sleep(0.01);

def Usage(self):

print "Usage:"

print "%s [Options] [Projectpath] [Buildpath]" % sys.argv[0]

def Bpath(*args):

return os.path.join(beremiz_dir, *args)

import wx.lib.buttons

import wx.lib.statbmp

import wx.stc

# found here.

os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True):

# Add beremiz's icon in top left corner of the frame

self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

# Define locale domain

loc.AddCatalog(domain)

import locale

global default_locale

default_locale = locale.getdefaultlocale()[1]

# sys.stdout.encoding = default_locale

# if Beremiz_service is started from Beremiz IDE

# sys.stdout.encoding is None (that means 'ascii' encoding').

else:

event(self, function)

def __init__(self, parent, message, caption = _("Please enter text"), defaultValue = "",

style = wx.OK|wx.CANCEL|wx.CENTRE, pos = wx.DefaultPosition):

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

] = [wx.NewId() for _init_coll_DefaultEditorToolBar_Items in range(18)]

# Define behaviour of each Toolbar item according to current POU body type

# Informations meaning are in this order:

# - Item is toggled

self.AUIManager.Update()

## Constructor of the PLCOpenEditor class.

# @param parent The parent window.

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

"notebooks": notebooks,

}

# Initialize Printing configuring elements

self.PrintData = wx.PrintData()

self.PrintData.SetPaperId(wx.PAPER_A4)

else:

event.Veto()

def GetCopyBuffer(self, primary_selection=False):

data = None

if primary_selection and wx.Platform == '__WXMSW__':

else:

self.LastSave = -1

def Buffering(self, currentstate):

"""

Add a new state in buffer

self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

self.MinIndex = max(self.MinIndex, 0)

def Current(self):

"""

Return current state of buffer

return result

return None

# Return Data Type Object

def GetDataType(self, typename, debug = False):

project = self.GetProject(debug)

else:

app = wx.PySimpleApp()

from util.misc import InstallLocalRessources

InstallLocalRessources(beremiz_dir)

plc_file.close()

return True

def _Compile_ST_to_SoftPLC(self):

self.logger.write(_("Compiling IEC Program into C code...\n"))

buildpath = self._getBuildPath()

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

return plc_main_code

def _Build(self):

"""

Method called by user to (re)build SoftPLC and confnode tree

def UpdateButtons(self):

wx.CallAfter(self._UpdateButtons)

def UpdatePLCLog(self, log_count):

if log_count:

if self.AppFrame is not None:

# _("Cannot compare latest build to target. Please build.\n"))

self.EnableMethod("_Transfer", False)

def _Disconnect(self):

self._SetConnector(None)

},

]

def EnableMethod(self, method, value):

for d in self.StatusMethods:

if d["method"]==method:

else:

can_driver_name = ""

format_dict = {"locstr": "_".join(map(str, self.GetCurrentLocation())),

"candriver": can_driver_name,

"nodes_includes": "",

return len(nodeRpdoIndexes), len(nodeTpdoIndexes)

def PrepareMasterNode(self):

"""

Add mandatory entries for DCF generation into MasterNode.

self.MasterNode.SetEntry(0x1280 + idx, 0x02, TSDO_cobid)

self.MasterNode.SetEntry(0x1280 + idx, 0x03, nodeid)

def GetMasterNode(self):

"""

Return MasterNode.

else:

self.VLine.set_xdata((x_cursor, x_cursor))

# Define a horizontal line to display cursor y

# coordinate if no line is already defined

if self.HLine is None:

wx.EVT_SIZE(self, self.OnSize)

wx.CallAfter(self.OnSize, None)

def OnSize(self, event):

"""Handles The wx.EVT_SIZE Events For The StatusBar.

elif verticalalignment == ESB_ALIGN_BOTTOM:

widget.SetPosition((xpos, rect.height-widgetsize[1]))

if event is not None:

event.Skip()

def AddWidget(self, widget, horizontalalignment=ESB_ALIGN_CENTER_HORIZONTAL,

verticalalignment=ESB_ALIGN_CENTER_VERTICAL, pos = -1):

"""Add A Widget To The EnhancedStatusBar.

'"ESB_ALIGN_CENTER_VERTICAL", "ESB_ALIGN_TOP", "ESB_ALIGN_BOTTOM"' \

'"ESB_EXACT_FIT"'

try:

self.RemoveChild(self._items[pos].widget)

self._items[pos].widget.Destroy()

def removeService(self, zeroconf, _type, name):

wx.CallAfter(self._removeService, name)

def _removeService(self, name):

'''

called when a service with the desired type goes offline.

if parent and parent.icon:

self.SetIcon(parent.icon)

def __init__(self, parent):

wx.Dialog.__init__(self, parent, title=_("Find"),

style=wx.CAPTION|wx.CLOSE_BOX|wx.CLIP_CHILDREN|wx.RESIZE_BORDER)

# clear message after dialog size calculation

self.SetStatusText("")

self.ParentWindow = parent

self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)

lineNum = lineNum + 1

def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):

lastChild = self.GetLastChild(line, level)

line = line + 1

sizer.Layout()

self.RefreshScrollbars()

def GetItemChannelChangedFunction(self, dir):

def OnConfNodeTreeItemChannelChanged(event):

confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

row_highlights.pop(col)

class ResourceEditor(EditorPanel):

VARIABLE_PANEL_TYPE = "resource"

message.Destroy()

class DebugInstanceName(DebugDataConsumer):

VALUE_TRANSLATION = {True: _("Active"), False: _("Inactive")}

# Refresh functions

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

def ElementNeedRefresh(self, element):

self.ElementRefreshList_lock.acquire()

self.ElementRefreshList.append(element)

# Model delete functions

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

def DeleteBlock(self, block):

elements = []

for output in block.GetConnectors()["outputs"]:

return pos

def DirectionChoice(v_base, v_target, dir_target):

"""

Function that choose a direction during the wire points generation

else:

return Graphic_Element.ProcessDragging(self, movex, movey, event, scaling)

# Refreshes the action block model

def RefreshModel(self, move=True):

self.Parent.RefreshActionBlockModel(self)

return languageDict

def processCustomFiles(filein, fileout, regexp, prefix = ''):

appfil_file = open(filein, 'r')

messages_file = open(fileout, 'r')

def _GetLibFileName(self):

return os.path.join(self.workingdir, self.CurrentPLCFilename)

def LoadPLC(self):

"""

Load PLC library

self.PlcStopping.set()

self._stopPLC = __StopPLC

self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

self._ResetDebugVariables.restype = None

self.PythonRuntimeCall("init")

def PythonRuntimeCleanup(self):

if self.python_runtime_vars is not None:

self.PythonRuntimeCall("cleanup")

self._TracesAutoSuspend()

self._TracesFlush()

def RemoteExec(self, script, *kwargs):

try:

exec script in kwargs

copy_boilerplate(data_dir, "tree_white.gif", output)

copy_boilerplate(data_dir, "history.html", output)

## all.cache.html

app_files = generateAppFiles(data_dir, js_includes, app_name, debug,

output, dynamic, cache_buster, optimize)

return "unrecognised command"

# The following is incredibly convenient for saving vast amounts of

# coding, avoiding doing silly things like this:

# jsonresult = {'field1': djangoobject.field1,

if decl:

print >>self.output, decl

if self.debug:

haltException = self.module_prefix + "HaltException"

print >>self.output, haltException + ' = function () {'

print >>self.output, "};"

print >>self.output, "%s.__name__ = '%s';\n" % (function_name, node.name)

self._kwargs_parser(node, function_name, normal_arg_names, None)

def _return(self, node, current_klass):

expr = self.expr(node.value, current_klass)

# in python a function call always returns None, so we do it

# here too

print >>self.output, " return " + expr + ";"

def _break(self, node, current_klass):

print >>self.output, " break;"

def _continue(self, node, current_klass):

print >>self.output, " continue;"

def _callfunc(self, v, current_klass):

if isinstance(v.node, ast.Name):

else:

raise TranslationError("unsupported type (in _getattr)", v.expr)

def modpfx(self):

return strip_py(self.module_prefix)

return call_name

def _getattr2(self, v, current_klass, attr_name):

if isinstance(v.expr, ast.Getattr):

call_name = self._getattr2(v.expr, current_klass, v.attrname + "." + attr_name)

return call_name

def _class(self, node):

"""

Handle a class definition.

if child.name == "__init__":

init_method = child

if len(node.bases) == 0:

base_class = "pyjslib.__Object"

elif len(node.bases) == 1:

print >> self.output, class_name_+".__initialize__();"

def classattr(self, node, current_klass):

self._assign(node, current_klass, True)

self._varargs_handler(node, varargname, declared_arg_names, current_klass)

local_arg_names.append(varargname)

# stack of local variable names for this function call

self.local_arg_stack.append(local_arg_names)

print >>self.output, ' }'

print >>self.output, ' }'

def get_line_trace(self, node):

lineNum = "Unknown"

srcLine = ""

rhs = self.expr(node.expr, current_klass)

print >>self.output, " " + lhs + " " + op + " " + rhs + ";"

def _assign(self, node, current_klass, top_level = False):

if len(node.nodes) != 1:

tempvar = '__temp'+str(node.lineno)

print "b", repr(node.expr), rhs

print >>self.output, " " + lhs + " " + op + " " + rhs + ";"

def _discard(self, node, current_klass):

if isinstance(node.expr, ast.CallFunc):

else:

raise TranslationError("unsupported type (in _discard)", node.expr)

def _if(self, node, current_klass):

for i in range(len(node.tests)):

test, consequence = node.tests[i]

self._if_test(keyword, test, consequence, current_klass)

def _if_test(self, keyword, test, consequence, current_klass):

if test:

expr = self.expr(test, current_klass)

print >>self.output, " }"

def _from(self, node):

for name in node.names:

# look up "hack" in AppTranslator as to how findFile gets here

else:

self.imported_classes[name[0]] = node.modname

def _compare(self, node, current_klass):

lhs = self.expr(node.expr, current_klass)

return "(" + lhs + " " + op + " " + rhs + ")"

def _not(self, node, current_klass):

expr = self.expr(node.expr, current_klass)

}

""" % locals()

def _while(self, node, current_klass):

test = self.expr(node.test, current_klass)

print >>self.output, " while (pyjslib.bool(" + test + ")) {"

raise TranslationError("unsupported type (in _while)", node.body)

print >>self.output, " }"

def _const(self, node):

if isinstance(node.value, int):

return str(node.value)

raise TranslationError("unsupported type (in expr)", node)

import cStringIO

return imported_modules_str + module_str

def translate(self, module_name, is_app=True, debug=False,

library_modules=[]):

app_code = cStringIO.StringIO()

return None

LogLevels = ["CRITICAL", "WARNING", "INFO", "DEBUG"]

LogLevelsCount = len(LogLevels)

LogLevelsDict = dict(zip(LogLevels, range(LogLevelsCount)))

self.errt.start()

self.startsem.release()

def output(self, v):

self.outdata.append(v)

self.outlen += 1

self.kill()

self.finishsem.release()

def spin(self):

self.finishsem.acquire()

return [self.exitcode, "".join(self.outdata), "".join(self.errdata)]

"Edouard Tisserant <edouard.tisserant@gmail.com>",

"Laurent Bessard <laurent.bessard@gmail.com>")

info.License = ('\n This program is free software; you can redistribute it and/or\n'

' modify it under the terms of the GNU General Public License\n'

' as published by the Free Software Foundation; either version 2\n'

# define name for wxGlade gui file

return os.path.join(project_path, "hmi.wxg")

def GetWxGladePath(self):

path = None

try: