return False

def progress(self, text):

self.output.AnnotationSetText(l, text)

self.output.AnnotationSetVisible(wx.stc.STC_ANNOTATION_BOXED)

self.output.AnnotationSetStyle(l, self.black_white)

self.local_runtime_tmpdir = tempfile.mkdtemp()

# choose an arbitrary random port for runtime

self.runtime_port = int(random.random() * 1000) + 61131

# launch local runtime

self.local_runtime = ProcessLogger(

self.Log,

from datetime import datetime

from weakref import WeakKeyDictionary

from functools import reduce

from distutils.dir_util import copy_tree

from six.moves import xrange

for debug_tick, debug_buff in Traces:

debug_vars = UnpackDebugBuffer(

debug_buff, self.TracedIECTypes)

self.TracedIECPath,

self.DebugValuesBuffers,

debug_vars):

WeakKeyDictionary(), # Callables

[], # Data storage [(tick, data),...]

"Registered", # Variable status

self.IECdebug_datas[IECPath] = IECdebug_data

else:

IECdebug_data[4] |= buffer_list

return self._connector.RemoteExec(script, **kwargs)

def DispatchDebugValuesProc(self, event):

start_time = time.time()

if self.debug_status == PlcStatus.Broken:

self.logger.write_warning(

_("Debug: token rejected - other debug took over - reconnect to recover\n"))

def KillDebugThread(self):

if self.DispatchDebugValuesTimer is not None:

from __future__ import absolute_import

from datetime import timedelta

import binascii

from graphics.DebugDataConsumer import DebugDataConsumer, TYPE_TRANSLATOR

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

# Constant for calculate CRC for string variables

@return: Data as numpy.array([(tick, value, forced),...])

"""

# Return immediately if data empty or none

# Find nearest data outside given range indexes

start_idx = (self.GetNearestData(start_tick, -1)

else len(self.Data))

# Return data between indexes

def GetRawValue(self, index):

"""

if len(values) > 0:

# Return value range for data in given tick range

return (data,

# Return default values

return data, None, None

"""

if self.StoreData and self.IsNumVariable():

# Init table storing data

# Init table storing raw data if variable is strin

self.RawData = ([]

[float(tick), num_value, extra_value])

# Add New data to stored data table

# Signal to debug variable panel to refresh

self.Parent.HasNewData = True

if tick is not None and self.Data is not None:

# Return current value and forced flag if data empty

return self.Value, self.IsForced()

# Get index of nearest data from tick given

# Get value and forced flag at given index

value, forced = \

if self.VariableType in ["STRING", "WSTRING"] \

if self.VariableType in ["TIME", "TOD", "DT", "DATE"]:

value = timedelta(seconds=value)

return None

# Extract data ticks

# Get nearest data from tick

# Adjust data index according to constraint

if adjust < 0 and ticks[idx] > tick and idx > 0 or \

from __future__ import absolute_import

from __future__ import division

from functools import reduce

import wx

import wx.lib.buttons

from controls.DebugVariablePanel.DebugVariableItem import DebugVariableItem

from controls.DebugVariablePanel.DebugVariableTextViewer import DebugVariableTextViewer

from controls.DebugVariablePanel.DebugVariableGraphicViewer import *

MILLISECOND = 1000000 # Number of nanosecond in a millisecond

main_sizer = wx.BoxSizer(wx.VERTICAL)

self.StartTick = 0 # Tick starting range of data displayed

self.Fixed = False # Flag that range of data is fixed

self.CursorTick = None # Tick of cursor for displaying values

tick = ticks[-1]

# Save tick as start tick for range if data is still empty

self.StartTick = ticks[0]

# Add tick to list of ticks received

# Update start tick for range if range follow ticks received

if not self.Fixed or tick < self.StartTick + self.CurrentRange:

# Force refresh if graph is fixed because range of data received

# is too small to fill data range selected

self.HasNewData = False

self.RefreshView()

def MoveCursorTick(self, move):

if self.CursorTick is not None:

cursor_tick_idx = max(0,

min(cursor_tick_idx + abs(move) // move,

self.StartTick = max(

min(self.StartTick, self.CursorTick))

self.RefreshCanvasPosition()

self.UpdateCursorTick()

if self.CursorTick is not None:

tick = self.CursorTick

else:

tick = None

if tick is not None:

self.RefreshGraphicsSizer()

def SetCanvasPosition(self, tick):

self.Fixed = True

self.RefreshCanvasPosition()

self.ForceRefresh()

def RefreshCanvasPosition(self):

else:

pos = 0

range = 0

if new_range_idx != current_range_idx:

self.CanvasRange.SetSelection(new_range_idx)

self.CurrentRange = self.RANGE_VALUES[new_range_idx][1] / self.Ticktime

if tick is None:

tick = self.StartTick + self.CurrentRange / 2.

new_start_tick = min(tick - (tick - self.StartTick) * self.CurrentRange / current_range,

self.ForceRefresh()

def RefreshRange(self):

self.Fixed = False

if self.Fixed:

else:

self.ForceRefresh()

def OnRangeChanged(self, event):

event.Skip()

def OnCurrentButton(self, event):

self.ResetCursorTick()

event.Skip()

event.Skip()

def OnPositionChanging(self, event):

self.Fixed = True

self.ForceRefresh()

event.Skip()

self.ForceRefresh()

def ResetGraphicsValues(self):

self.StartTick = 0

for panel in self.GraphicPanels:

panel.ResetItemsData()

"""

# Execute callback on button under mouse pointer if it exists

x, y = event.GetPosition()

event.Skip()

def OnLeftDClick(self, event):

buffoffset += sizeof(c_type) if iectype != "STRING" else len(value)+1

res.append(value)

else:

if buffoffset and buffoffset == buffsize:

return res

return None