doc/locale/**

C_runtime/**/*.d

\ No newline at end of file

uint32_t PLCObject::LoadPLC(void)

{

// Load the last transferred PLC md5 hex digest

std::string md5sum;

try {

uint32_t SetTraceVariablesList(const list_trace_order_1_t * orders, int32_t * debugtoken);

uint32_t StartPLC(void);

uint32_t StopPLC(bool * success);

uint32_t AutoLoad();

private:

// A map of all the blobs

uint32_t BlobAsFile(const binary_t * BlobID, std::filesystem::path filename);

uint32_t LoadPLC(void);

uint32_t UnLoadPLC(void);

uint32_t PurgePLC(void);

void PurgeTraceBuffer(void);

void TraceThreadProc(void);

};

\ No newline at end of file

filepath = self.CodeFileName()

if os.path.isfile(filepath):

codefile_xml = xmlfile.read()

xmlfile.close()

printout2 = GraphicPrintout(window, page_size, margins, True)

preview = wx.PrintPreview(printout, printout2, data)

preview_frame = wx.PreviewFrame(preview, self, _("Print preview"), style=wx.DEFAULT_FRAME_STYLE | wx.FRAME_FLOAT_ON_PARENT)

preview_frame.Initialize()

self.PageSize = page_size

if self.PageSize[0] == 0 or self.PageSize[1] == 0:

self.PageSize = (1050, 1485)

self.Margins = margins

self.FontSize = 5

self.TextMargin = 3

def OnBeginDocument(self, startPage, endPage):

dc = self.GetDC()

dc.SetResolution(720)

def OnPrintPage(self, page):

dc = self.GetDC()

dc.Clear()

dc.SetUserScale(1.0, 1.0)

dc.SetDeviceOrigin(0, 0)

# Get the size of the DC in pixels

ppiPrinterX, ppiPrinterY = self.GetPPIPrinter()

pw, ph = self.GetPageSizePixels()

Xscale = (dw * ppiPrinterX) / (pw * 25.4)

Yscale = (dh * ppiPrinterY) / (ph * 25.4)

dc.SetPen(MiterPen(wx.BLACK))

dc.SetBrush(wx.TRANSPARENT_BRUSH)

# Set the scale and origin

dc.SetDeviceOrigin(-posX + margin_left, -posY + margin_top)

dc.SetUserScale(scale, scale)

self.Viewer.DoDrawing(dc, True)

# shutdown local runtime

self.local_runtime.kill(gently=False)

# clear temp dir

self.local_runtime = None

return False

def IsEndType(self, typename):

return not typename.startswith("ANY")

return True

self._setBuildPath(BuildPath)

# get confnodes bloclist (is that usefull at project creation?)

self.RefreshConfNodesBlockLists()

# this will create files base XML files

self.SaveProject()

return None

# use only to enable drag'n'drop

# self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

self.VariablesGrid.Bind(

# self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnVariablesGridCellLeftClick)

# self.VariablesGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, self.OnVariablesGridEditorShown)

self.MainSizer.Add(self.VariablesGrid, flag=wx.GROW)

var_type = self.CellControl.GetVarType()

if var_type is not None:

self.Table.SetValueByName(row, 'Type', var_type)

self.CellControl.Disable()

return changed

"type": ITEM_PROJECT,

"data": None,

"text": None,

}

search_results_tree_children = search_results_tree_infos.setdefault("children", [])

for tagname in self.ElementsOrder:

start_idx = start[1]

end_idx = reduce(lambda x, y: x + y, [len(x) + 1 for x in text_lines[:end[0] - start[0]]], end[1] + 1)

style = wx.TextAttr(wx.BLACK, wx.Colour(206, 204, 247))

text = _("(%d matches)") % infos["matches"]

start_idx, end_idx = 0, len(text)

style = wx.TextAttr(wx.Colour(0, 127, 174))

self.ActionsGrid = CustomGrid(self, size=wx.Size(-1, 250), style=wx.VSCROLL)

self.ActionsGrid.DisableDragGridSize()

self.ActionsGrid.EnableScrolling(False, True)

self.OnActionsGridCellChange)

main_sizer.Add(self.ActionsGrid, border=20,

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

# Get variable expression and select corresponding value in name list

# box if it exists

selected = self.Expression.GetValue()

# Disable name list box if no name present inside

self.VariableName.Enable(self.VariableName.GetCount() > 0)

# Set expression text control value

self.Expression.ChangeValue(value)

# Select corresponding text in name list box if it exists

# Parameter is variable execution order

elif name == "executionOrder":

"""

# Select the corresponding value in name list box if it exists

self.VariableName.SetSelection(

self.Refresh()

event.Skip()

lineText = self.Editor.GetTextRange(start_pos, end_pos).replace("\t", " ")

# Code completion

words = lineText.split(" ")

words = [word for i, word in enumerate(words) if word != '' or i == len(words) - 1]

kw = []

if self.TextSyntax == "IL":

if len(words) == 1:

kw = self.Keywords

kw = self.Keywords + list(self.Variables.keys()) + list(self.Functions.keys())

if len(kw) > 0:

if len(words[-1]) > 0:

kw.sort()

self.Editor.AutoCompSetIgnoreCase(True)

self.Editor.AutoCompShow(len(words[-1]), " ".join(kw))

key_handled = True

elif key == wx.WXK_RETURN or key == wx.WXK_NUMPAD_ENTER:

indent = self.Editor.GetLineIndentation(line)

if LineStartswith(lineText.strip(), self.BlockStartKeywords):

indent = (indent // 2 + 1) * 2

# Popup menu functions

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

return ForceVariableFunction

def GetReleaseVariableMenuFunction(self, iec_path):

def PopupForceMenu(self):

iec_path = self.GetElementIECPath(self.SelectedElement)

if iec_path is not None:

menu = wx.Menu(title='')

ritem = self.AppendItem(menu,

_("Release value"),

ritem.Enable(True)

else:

ritem.Enable(False)

if self.Editor.HasCapture():

self.Editor.ReleaseMouse()

self.Editor.PopupMenu(menu)

self.ProcessVariablesGrid = CustomGrid(self.EthercatMasterEditor, style=wx.VSCROLL)

self.ProcessVariablesGrid.SetMinSize(wx.Size(0, 150))

self.ProcessVariablesGrid.SetDropTarget(ProcessVariableDropTarget(self))

self.OnProcessVariablesGridCellChange)

self.ProcessVariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK,

self.OnProcessVariablesGridCellLeftClick)

self.StartupCommandsGrid = CustomGrid(self.EthercatMasterEditor, style=wx.VSCROLL)

self.StartupCommandsGrid.SetDropTarget(StartupCommandDropTarget(self))

self.StartupCommandsGrid.SetMinSize(wx.Size(0, 150))

self.OnStartupCommandsGridCellChange)

self.StartupCommandsGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN,

self.OnStartupCommandsGridEditorShow)

posx, posy = self.GetPosition()

min_width, min_height = self.GetMinSize()

if width < min_width:

width = min_width

if height < min_height:

height = min_height

if scaling is not None:

self.Pos.x = round_scaling(self.Pos.x, scaling[0])

"""

# Create a new connector

DebugDataConsumer.__init__(self)

ToolTipProducer.__init__(self, parent.Parent)

self.ParentBlock = parent

self.Name = name

self.Pos = position

self.Direction = direction

self.Wires = []

self.Negated = negated

self.Edge = edge

else:

return self.ParentBlock.IsOfType(type, reference) or self.ParentBlock.IsOfType(reference, type)

# Changes the connector name

for wire, _handle in self.Wires:

wire.SetValid(wire.IsConnectedCompatible())

dc.SetBrush(wx.Brush(HIGHLIGHTCOLOR))

dc.SetLogicalFunction(wx.AND)

# Draw two rectangles for representing the contact

dc.DrawRectangle(left_left, top, width, height)

dc.DrawRectangle(right_left, top, width, height)

elif self.Type == COIL_FALLING:

typetext = "N"

# Draw coil name

name_pos = (self.Pos.x + (self.Size[0] - name_size[0]) // 2,

ST_BLOCK_START_KEYWORDS = ["IF", "ELSIF", "ELSE", "CASE", "FOR", "WHILE", "REPEAT"]

ST_BLOCK_END_KEYWORDS = ["END_IF", "END_CASE", "END_FOR", "END_WHILE", "END_REPEAT"]

ST_KEYWORDS = [

"RETURN", "NOT", "MOD", "AND", "XOR", "OR"

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

lxml==4.9.2

matplotlib==3.7.1

msgpack==1.0.5

numpy==1.24.3

packaging==23.1

Pillow==9.5.0

if _debug and self.logger:

self.logger.write("(DEBUG) launching:\n" + self.Command_str + "\n")

self.outt = outputThread(

self.Proc,