return '\n'.join(['%s%s: %s' % (indent, k, repr(v)[:10000]) for k, v in d.iteritems()])

def save_bug_report(e_type, e_value, e_traceback, bug_report_path,date):

info = {

output.close()

def handle_exception(e_type, e_value, e_traceback):

last_tb = get_last_traceback(e_traceback)

ex = (last_tb.tb_frame.f_code.co_filename, last_tb.tb_frame.f_lineno)

if ex not in ignored_exceptions:

opts, argv = getopt.getopt(sys.argv[1:], "i:p:n:x:t:a:w:c:e:h")

except getopt.GetoptError, err:

# print help information and exit:

usage()

sys.exit(2)

# Now, try to guess the nearest available channel

res = DesiredChannel

if res < 0 :

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

# Finally set IEC Channel

self.BaseParams.setIEC_Channel(res)

return res

# check name is unique

NewCTNName = _self.FindNewName(CTNName)

# If dir have already be made, and file exist

# Load the confnode.xml file into parameters members

_self.LoadXMLParams(NewCTNName)

# Basic check. Better to fail immediately.

kind=wx.ITEM_NORMAL, text=_(u'Redo') + '\tCTRL+Y')

#AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO,

# kind=wx.ITEM_CHECK, text=_(u'Enable Undo/Redo'))

parent.AppendSeparator()

AppendMenu(parent, help='', id=wx.ID_CUT,

kind=wx.ITEM_NORMAL, text=_(u'Cut') + '\tCTRL+X')

if self.ProjectTree.GetPyData(selected)["type"] != ITEM_PROJECT:

pou_type = self.ProjectTree.GetItemText(selected)

pou_type = {'Functions': 'function', 'Function Blocks': 'functionBlock', 'Programs': 'program'}[pou_type]

else:

pou_type = None

return '\n'.join(['%s%s: %s' % (indent, k, repr(v)[:10000]) for k, v in d.iteritems()])

def handle_exception(e_type, e_value, e_traceback):

last_tb = get_last_traceback(e_traceback)

ex = (last_tb.tb_frame.f_code.co_filename, last_tb.tb_frame.f_lineno)

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

if result:

ignored_exceptions.append(ex)

info = {

'app-version' : app_version,

'wx-version' : wx.VERSION_STRING,

'wx-platform' : wx.Platform,

'platform' : platform.platform(),

'e-type' : e_type,

'e-value' : e_value,

if e_traceback:

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

last_tb = get_last_traceback(e_traceback)

info['locals'] = format_namespace(exception_locals)

if 'self' in exception_locals:

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

if first_line <= i <= last_line:

if last_section is not None:

self.logger.write_warning("In section: " + last_section)

self.logger.write_warning("%04d: %s" % (i, line))

f.close()

return ([(C_file_name, self.plcCFLAGS)

for C_file_name in self.PLCGeneratedCFiles ],

def ResetIECProgramsAndVariables(self):

"""

"void __publish_%(s)s(void);") % {'s':locstr} for locstr in locstrs]),

"retrieve_calls":"\n ".join([

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

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

"init_calls":"\n ".join([

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

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

if IECdebug_data is None:

IECdebug_data = [

None,

buffer_list] # Forced value

self.IECdebug_datas[IECPath] = IECdebug_data

self.TracedIECPath,

self.DebugValuesBuffers,

debug_vars):

if IECdebug_data is not None and value is not None:

forced = IECdebug_data[2:4] == ["Forced", value]

if not IECdebug_data[4] and len(values_buffer) > 0:

profile, filepath = dialog.GetProfile()

NMT = dialog.GetNMTManagement()

options = dialog.GetOptions()

else:

self.CreateNewNode("SlaveNode", # Name - will be changed at build time

0x00, # NodeID - will be changed at build time

"slave", # Type

"", # description

"None", # profile

"heartbeat", # NMT

[]) # options

dialog.Destroy()

from controls.CustomStyledTextCtrl import faces

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

# Custom ToolTip

# Canvas height

[SIZE_MINI, SIZE_MIDDLE, SIZE_MAXI] = [0, 100, 200]

# Colors used cyclically for graph curves

COLOR_CYCLE = ['r', 'b', 'g', 'm', 'y', 'k']

xw, yw = self.GetPosition()

self.ParentWindow.StartDragNDrop(self,

self.ItemsDict.values()[item_idx],

# Don't handle mouse button if canvas is 3D and let matplotlib do

# the default behavior (rotate 3D axes)

# highlight

elif event.button is None:

# Compute direction for items label according graph type

directions = [wx.RIGHT] * len(self.AxesLabels) + \

[wx.LEFT] * len(self.Labels)

directions = [wx.LEFT] * len(self.Labels)

# Find if mouse is over an item label

self.Axes.tick_params(axis='y', labelsize='small')

# Init variables storing graphical elements added to figure

# Get function to add a text in figure according to graph type

add_text_func = self.GetAddTextFunction()

# expressed border and text position in pixel on screen and apply the

# ratio calculated hereafter to get border and text position in

# matplotlib coordinate

graph_ratio = 1. / (

(1.0 - (CANVAS_BORDER[0] + CANVAS_BORDER[1]) * canvas_ratio)

* height) # Divide by figure height in pixel

from DebugVariableTextViewer import DebugVariableTextViewer

from DebugVariableGraphicViewer import *

# List of values possible for graph range

# Format is [(time_in_plain_text, value_in_nanosecond),...]

main_sizer = wx.BoxSizer(wx.VERTICAL)

self.DraggingAxesPanel = None

self.DraggingAxesBoundingBox = None

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

self.Bind(wx.EVT_SIZE, self.OnResize)

self.ThumbScrollingStartPos = None

def GetRangeRect(self):

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

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

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

VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().iterkeys()])

VARIABLE_CLASSES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().itervalues()])

self.Table = VariableTable(self, [], GetVariableTableColnames(True))

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

else:

self.FilterChoices = ["All",

"Interface", " Input", " Output", " InOut", " External",

# these condense the ColAlignements list

l = wx.ALIGN_LEFT

pos_x = (width-bw)/2+dw # adjust for bitmap and text to centre

pos_y = (height-bh-th)/2+dy

if bmp !=None:

pos_x = (width-tw)/2+dw # adjust for bitmap and text to centre

pos_y += bh + 2

import wx

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

# Debug Viewer Class

not_null = False

for val, format in [

# Add value to TIME literal if value is non-null or another non-null

# value have already be found

def __init__(self, workingdir, daemon, argv, statuschange, evaluator, pyruntimevars):

pyro.ObjBase.__init__(self)

self.evaluator = evaluator

self.workingdir = workingdir

self.PLCStatus = "Empty"

self.PLClibraryHandle = None

self._LogMessage.restype = ctypes.c_int

self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]

self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

self._GetLogMessage.restype = ctypes.c_uint32

self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]

self.TraceLock.acquire()

self.Traces = []

self.TraceLock.release()

self.TraceWakeup.clear()

self.TraceWakeup.wait()

def _TracesFlush(self):

self.TraceLock.acquire()

#time.sleep(0)

if mod_list:

ordered_deps.reverse()

'DateField': ['input_formats'],

'DateTimeField': ['input_formats'],

'TimeField': ['input_formats'],

'EmailField': ['max_length', 'min_length'],

'URLField': ['max_length', 'min_length', 'verify_exists', 'user_agent'],

'ChoiceField': ['choices'],

f = self.formcls(params)

if not f.is_valid():

return {'success':False, 'errors': builderrors(f)}

return {'success':True}

elif command.has_key('save'):

if not f.is_valid():

return {'success':False, 'errors': builderrors(f)}

return {'success': True, 'instance': json_convert(instance) }

elif command.has_key('html'):

# the platform name (PyV8, smjs, Mozilla, IE6, Opera, Safari etc.)

# a dictionary of module override names (platform-specific)

# the remote path for loading modules

loadpath = None

self._class(child)

elif isinstance(child, ast.Import):

importName = child.names[0][0]

pass

elif importName.endswith('.js'):

self.imported_js.add(importName)

else:

self.add_imported_module(strip_py(importName))

elif isinstance(child, ast.From):

pass

else:

self.add_imported_module(child.modname)

cls_name_ = cls_name.name_

cls_name = cls_name.name

else:

name = UU+cls_name_ + ".prototype.__class__." \

+ v.name

if v.name == 'listener':

call_name = UU+self.imported_classes[obj] + '.__' + obj + attr_str

elif obj in self.module_imports():

call_name = obj + "." + attr_name

call_name = UU + self.modpfx() + "__" + obj + ".prototype.__class__." + attr_name

else:

call_name = UU+self._name(v, current_klass) + "." + attr_name

print >>self.output, "sys.popstack();\n"

elif isinstance(node.expr, ast.Const):

print >>self.output, self._const(node.expr)

else:

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

def _mod(self, node, current_klass):

if isinstance(node.left, ast.Const) and isinstance(node.left.value, StringType):

return "sprintf("+self.expr(node.left, current_klass) + ", " + self.expr(node.right, current_klass)+")"

return self.expr(node.left, current_klass) + " % " + self.expr(node.right, current_klass)

target.code = source.code

target.argnames = source.argnames

target.defaults = source.defaults

def dotreplace(fname):

"name" : _("Import SVG"),

"tooltip" : _("Import SVG"),

"method" : "_ImportSVG"},

"name" : _("Inkscape"),

"tooltip" : _("Create HMI"),

"method" : "_StartInkscape"},

"""

Must be changed according to changes in iec_types.h

"""

def _t(t, u=lambda x:x.value, p=lambda t,x:t(x)): return (t, u, p)

_MDNS_ADDR = '224.0.0.251'

_MDNS_PORT = 5353;

_DNS_PORT = 53;

_MAX_MSG_ABSOLUTE = 8972

_CLASS_IN = 1

_CLASS_CS = 2

self.size -= 2

length = len(''.join(self.data[index:]))

def packet(self):

"""Returns a string containing the packet's bytes

def __init__(self, zeroconf):

threading.Thread.__init__(self)

self.zeroconf = zeroconf

self.timeout = 5

self.condition = threading.Condition()

self.start()