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

from __future__ import absolute_import

import sys

from types import TupleType

import base64

raise ValueError("Not possible")

if tab["size"][0] == rect.width:

if tab["pos"][1] == rect.y:

split_rect = wx.Rect(rect.x, rect.y + tab["size"][1] + TAB_BORDER,

rect.width, rect.height - tab["size"][1] - TAB_BORDER)

elif tab["pos"][1] == rect.height + 1 - tab["size"][1]:

split_rect = wx.Rect(rect.x, rect.y,

rect.width, rect.height - tab["size"][1] - TAB_BORDER)

split_id = idx

break

elif tab["size"][1] == rect.height:

if tab["pos"][0] == rect.x:

split_rect = wx.Rect(rect.x + tab["size"][0] + TAB_BORDER, rect.y,

rect.width - tab["size"][0] - TAB_BORDER, rect.height)

elif tab["pos"][0] == rect.width + 1 - tab["size"][0]:

split_rect = wx.Rect(rect.x, rect.y,

rect.width - tab["size"][0] - TAB_BORDER, rect.height)

split_id = idx

def UPPER_DIV(x, y):

class GraphicPrintout(wx.Printout):

ppiPrinterX, ppiPrinterY = self.GetPPIPrinter()

pw, ph = self.GetPageSizePixels()

dw, dh = dc.GetSizeTuple()

fontsize = self.FontSize * Yscale

# Calculate the position on the DC for centering the graphic

posX = area_width * ((page - 1) % self.PageGrid[0])

scale = min(scaleX, scaleY)

# Set the scale and origin

from __future__ import absolute_import

from types import TupleType

from copy import deepcopy

import os

x, y, width, height = bbox.bounding_box()

if middle:

else:

new_pos = map(lambda x: x + 30, new_pos)

if scaling[0] != 0 and scaling[1] != 0:

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

from __future__ import absolute_import

import os

import sys

import shutil

nodeid = self.CanFestivalNode.getNodeId()

if value != nodeid:

slaves = self.GetSlaveIDs()

while value in slaves and value >= 0:

value += dir

if value < 0:

from __future__ import absolute_import

import wx

import wx.lib.agw.customtreectrl as CT

if self.BackgroundAlign & wx.ALIGN_RIGHT:

x = client_size[0] - bitmap_size[0]

elif self.BackgroundAlign & wx.ALIGN_CENTER_HORIZONTAL:

else:

x = 0

if self.BackgroundAlign & wx.ALIGN_BOTTOM:

y = client_size[1] - bitmap_size[1]

elif self.BackgroundAlign & wx.ALIGN_CENTER_VERTICAL:

else:

y = 0

from __future__ import absolute_import

from types import TupleType

from time import time as gettime

from cycler import cycler

# Get Before which Viewer the variable has to be moved or added

# according to the position of mouse in Viewer.

target_idx += 1

# Drag'n Drop is an internal is an internal move inside Debug

x = rect.x + (- w - offset

if direction == wx.LEFT

else rect.width + offset)

offset += w

else:

y = rect.y + (- h - offset

if direction == wx.TOP

else rect.height + offset)

self.ParentWindow.SetCanvasPosition(

self.StartCursorTick +

(self.MouseStartPos.x - event.x) *

def OnCanvasScroll(self, event):

"""

tick = (start_tick + end_tick) / 2.

else:

tick = event.xdata

# Vetoing event to prevent parent panel to be scrolled

self.ParentWindow.VetoScrollEvent = True

# Mouse is over Viewer figure and graph is not 3D

bbox = self.GetAxesBoundingBox()

if bbox.InsideXY(x, y) and not self.Is3DCanvas():

# Mouse is over Viewer left part of figure

if rect.InsideXY(x, y):

self.SetHighlight(HIGHLIGHT_LEFT)

self.SetHighlight(HIGHLIGHT_RIGHT)

# Mouse is over upper part of Viewer

# Viewer is upper one in Debug Variable Panel, show highlight

if self.ParentWindow.IsViewerFirst(self):

self.SetHighlight(HIGHLIGHT_BEFORE)

destGC.SetPen(HIGHLIGHT['DROP_PEN'])

destGC.SetBrush(HIGHLIGHT['DROP_BRUSH'])

if self.Highlight == HIGHLIGHT_RIGHT

else 0)

destGC.DrawRectangle(bbox.x + x_offset, bbox.y,

# Draw other Viewer common elements

self.DrawCommonElements(destGC, self.GetButtons())

from __future__ import absolute_import

from types import TupleType

import numpy

# Calculate range to apply to data

self.CurrentRange = self.RANGE_VALUES[

def SetDataProducer(self, producer):

"""

cursor_tick_idx = numpy.argmin(numpy.abs(self.Ticks - cursor_tick))

if self.Ticks[cursor_tick_idx] == self.CursorTick:

cursor_tick_idx = max(0,

len(self.Ticks) - 1))

self.CursorTick = self.Ticks[cursor_tick_idx]

self.StartTick = max(

panel.ShowButtons(True)

merge_type = GRAPH_PARALLEL

if isinstance(panel, DebugVariableTextViewer) or panel.Is3DCanvas():

idx += 1

wx.CallAfter(self.MoveValue, variable, idx, True)

else:

rect = panel.GetAxesBoundingBox(True)

if rect.InsideXY(x_mouse, y_mouse):

if merge_rect.InsideXY(x_mouse, y_mouse):

merge_type = GRAPH_ORTHOGONAL

wx.CallAfter(self.MergeGraphs, variable, idx, merge_type, force=True)

else:

idx += 1

wx.CallAfter(self.MoveValue, variable, idx, True)

self.ForceRefresh()

tick_duration = int(tick * self.Ticktime)

not_null = False

duration = ""

if value > 0 or not_null:

duration += format % value

not_null = True

self.TickTimeLabel.SetLabel("t: %s" % duration)

else:

self.TickLabel.SetLabel("")

def OnRangeChanged(self, event):

try:

except ValueError:

self.CanvasRange.SetValue(str(self.CurrentRange))

wx.CallAfter(self.RefreshRange)

xstart, ystart = self.GraphicsWindow.GetViewStart()

window_size = self.GraphicsWindow.GetClientSize()

vwidth, vheight = self.GraphicsSizer.GetMinSize()

self.GraphicsWindow.Scroll(posx, posy)

self.GraphicsWindow.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

posx, posy)

def OnGraphicsWindowEraseBackground(self, event):

from __future__ import absolute_import

from types import TupleType

import wx

# according to the position of mouse in Viewer.

_width, height = self.ParentControl.GetSize()

target_idx = self.ParentControl.GetIndex()

target_idx += 1

# Drag'n Drop is an internal is an internal move inside Debug

# Draw item variable path at Viewer left side

w, h = gc.GetTextExtent(item_path)

# Update 'Release' button state and text color according to item forced

# flag value

# Draw item current value at right side of Viewer

item_value = item.GetValue()

w, h = gc.GetTextExtent(item_value)

# Draw other Viewer common elements

self.DrawCommonElements(gc)

from __future__ import absolute_import

from collections import OrderedDict

import wx

_width, height = self.GetSize()

# Mouse is in the first half of Viewer

# If Viewer is the upper one, draw drop before highlight

if self.ParentWindow.IsViewerFirst(self):

self.SetHighlight(HIGHLIGHT_BEFORE)

"""

from __future__ import absolute_import

import wx

# Horizontal Alignment Constants

widget.SetPosition((xpos, rect.y-1))

elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:

if widgetsize[1] < rect.height - 1:

widget.SetPosition((xpos, rect.y+diffs))

else:

widget.SetSize((widgetsize[0], rect.height-2))

widget.SetPosition((xpos, rect.y-1))

elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:

if widgetsize[1] < rect.height - 1:

widget.SetPosition((xpos, rect.y+diffs))

else:

widget.SetSize((widgetsize[0], rect.height-2))

elif horizontalalignment == ESB_ALIGN_CENTER_HORIZONTAL:

if verticalalignment == ESB_EXACT_FIT:

widget.SetSize((widgetsize[0], rect.height))

widget.SetPosition((xpos, rect.y))

elif verticalalignment == ESB_ALIGN_CENTER_VERTICAL:

if widgetsize[1] < rect.height - 1:

widget.SetPosition((xpos, rect.y+diffs))

else:

widget.SetSize((widgetsize[0], rect.height-1))

from __future__ import absolute_import

from datetime import datetime

from time import time as gettime

from weakref import proxy

def ArrowPoints(direction, width, height, xoffset, yoffset):

if direction == wx.TOP:

return [wx.Point(xoffset + 1, yoffset + height - 2),

wx.Point(xoffset + width - 1, yoffset + height - 2)]

else:

return [wx.Point(xoffset + 1, yoffset - height + 1),

wx.Point(xoffset + width - 1, yoffset - height + 1)]

thumb_size = range_rect.height * THUMB_SIZE_RATIO

thumb_range = range_rect.height - thumb_size

self.RefreshThumbPosition(

event.Skip()

def OnResize(self, event):

gc.SetPen(wx.Pen(wx.NamedColour("GREY"), 3))

gc.SetBrush(wx.GREY_BRUSH)

thumb_rect = self.GetThumbRect()

exclusion_rect = wx.Rect(thumb_rect.x, thumb_rect.y,

w, h = dc.GetTextExtent(self.Label)

dc.DrawText(self.Label,

DATE_INFO_SIZE = 10

if draw_date:

datetime_text = self.Date.strftime("%d/%m/%y %H:%M")

dw, dh = dc.GetTextExtent(datetime_text)

offset += DATE_INFO_SIZE

seconds_text = "%12.9f" % self.Seconds

sw, sh = dc.GetTextExtent(seconds_text)

bw, bh = self.LevelBitmap.GetWidth(), self.LevelBitmap.GetHeight()

text = self.Message.replace("\n", " ")

_mw, mh = dc.GetTextExtent(text)

def GetHeight(self, draw_date):

if draw_date:

def ScrollMessagePanelByPage(self, page):

if self.CurrentMessage is not None:

_width, height = self.MessagePanel.GetClientSize()

self.ScrollMessagePanel(page * message_per_page)

def ScrollMessagePanelByTimestamp(self, seconds):

event.Skip()

def OnMessagePanelMouseWheel(self, event):

event.Skip()

def OnMessagePanelEraseBackground(self, event):

from __future__ import absolute_import

from collections import namedtuple

import wx

bbox_width = (r_image_w + 4) * len(rightimages) + 4

bbox_height = r_image_h + 8

bbox_x = w - bbox_width

return wx.Rect(bbox_x, bbox_y, bbox_width, bbox_height)

self.InstanceChoice.SetFocusFromKbd()

size = self.InstanceChoice.GetSize()

event = wx.MouseEvent(wx.EVT_LEFT_DOWN._getEvtType())

event.SetEventObject(self.InstanceChoice)

# event = wx.KeyEvent(wx.EVT_KEY_DOWN._getEvtType())

# event.m_keyCode = wx.WXK_SPACE

from __future__ import absolute_import

import re

from types import TupleType, StringType, UnicodeType

from builtins import str as text

self.VariablesGrid.SetColAttr(col, attr)

self.VariablesGrid.SetColMinimalWidth(col, self.ColSettings["size"][col])

if (panel_width > self.PanelWidthMin) and not self.ColSettings["fixed_size"][col]:

else:

self.VariablesGrid.SetColSize(col, self.ColSettings["size"][col])

from __future__ import absolute_import

import wx

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

k = 1.1 if (bbox.width * 1.1 > client_size.width or

bbox.height * 1.1 > client_size.height) \

else 1.0

dc.SetUserScale(1.0 / scale, 1.0 / scale)

# Center graphic element in preview panel

self.Element.SetPosition(x, y)

# Draw graphic element

from __future__ import absolute_import

import re

import wx

not_null = False

duration = "T#"

if value > 0 or not_null:

duration += format % value

from __future__ import absolute_import

import re

from builtins import str as text

section_comment = " %s section " % (section)

len_headers = EDGE_COLUMN - len(section_comment)

section_comment = \

section_comment + \

self.SectionsComments[section] = {

"comment": section_comment,

from __future__ import absolute_import

import types

import wx

if not self.up:

dw = dy = self.labelDelta

if bmp is not None:

dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

pos_y += bh + 2

dc.DrawText(label, pos_x, pos_y) # draw the text

self.Thaw()

def GenerateMethodButtonSizer(self):

msizer = wx.BoxSizer(wx.HORIZONTAL)

xstart, ystart = self.ParamsEditor.GetViewStart()

window_size = self.ParamsEditor.GetClientSize()

maxx, maxy = self.ParamsEditorSizer.GetMinSize()

self.ParamsEditor.Scroll(posx, posy)

self.ParamsEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

posx, posy)

def OnParamsEditorResize(self, event):

from __future__ import absolute_import

from types import *

import wx

return

if not parts:

parts = 1

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

contact = LD_Contact(self, CONTACT_NORMAL, var_name, id)

width, height = contact.GetMinSize()

if scaling is not None:

contact.SetPosition(x, y)

contact.SetSize(width, height)

self.AddBlock(contact)

coil = LD_Coil(self, COIL_NORMAL, var_name, id)

width, height = coil.GetMinSize()

if scaling is not None:

coil.SetPosition(x, y)

coil.SetSize(width, height)

self.AddBlock(coil)

# Create Coil

id = self.GetNewId()

coil = LD_Coil(self, values["type"], values["name"], id)

coil_connectors = coil.GetConnectors()

self.AddBlock(coil)

rung.SelectElement(coil)

points = wires[0].GetSelectedSegmentPoints()

id = self.GetNewId()

contact = LD_Contact(self, values["type"], values["name"], id)

self.AddBlock(contact)

self.Controler.AddEditedElementContact(self.TagName, id)

rungindex = self.FindRung(wires[0])

from __future__ import absolute_import

from types import *

import wx

pos = connectors["action"].GetPosition(False)

id = self.GetNewId()

actionblock = SFC_ActionBlock(self, [], id)

actionblock_connector = actionblock.GetConnector()

wire = self.ConnectConnectors(actionblock_connector, connectors["action"])

wire.SetPoints([wx.Point(pos.x + SFC_WIRE_MIN_SIZE, pos.y), wx.Point(pos.x, pos.y)])

from __future__ import absolute_import

import re

from types import *

if self.TextSyntax in ["ST", "ALL"]:

indent = self.Editor.GetLineIndentation(line)

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

self.Editor.AddText("\n" + " " * indent)

key_handled = True

elif key == wx.WXK_BACK:

indent = self.Editor.GetColumn(self.Editor.GetCurrentPos())

if lineText.strip() == "" and len(lineText) > 0 and indent > 0:

self.Editor.DelLineLeft()

key_handled = True

if not key_handled:

event.Skip()

from __future__ import absolute_import

import math

from time import time as gettime

from types import TupleType

block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs=blockinputs)

width, height = block.GetMinSize()

if scaling is not None:

block.SetPosition(x, y)

block.SetSize(width, height)

self.ParentWindow.AddBlock(block)

self.Editor.Freeze()

if mouse_event is None:

client_size = self.Editor.GetClientSize()

mouse_event = wx.MouseEvent(wx.EVT_MOUSEWHEEL.typeId)

mouse_event.x = mouse_pos.x

mouse_event.y = mouse_pos.y

maxy = int(maxy * self.ViewScale[1])

self.Editor.SetScrollbars(

SCROLLBAR_UNIT, SCROLLBAR_UNIT,

xstart, ystart, True)

def EnsureVisible(self, block):

xpos, ypos = xstart, ystart

if block_minx < screen_minx and block_maxx < screen_maxx:

elif block_maxx > screen_maxx and block_minx > screen_minx:

if block_miny < screen_miny and block_maxy < screen_maxy:

elif block_maxy > screen_maxy and block_miny > screen_miny:

self.Scroll(xpos, ypos)

def SelectInGroup(self, element):

new_pos = event.GetPosition()

xmax = self.GetScrollRange(wx.HORIZONTAL) - self.GetScrollThumb(wx.HORIZONTAL)

ymax = self.GetScrollRange(wx.VERTICAL) - self.GetScrollThumb(wx.VERTICAL)

if scrollx > xmax or scrolly > ymax:

self.RefreshScrollBars(max(0, scrollx - xmax), max(0, scrolly - ymax))

self.Scroll(scrollx, scrolly)

variable = FBD_Variable(self, var_class, var_name, var_type, id)

width, height = variable.GetMinSize()

if scaling is not None:

variable.SetPosition(x, y)

variable.SetSize(width, height)

self.AddBlock(variable)

def GetScaledSize(self, width, height):

if self.Scaling is not None:

return width, height

def AddNewElement(self, element, bbox, wire=None, connector=None):

# See COPYING file for copyrights details.

from __future__ import absolute_import

from builtins import str as text

import wx

if (value_len % 2) == 0:

hex_len = value_len

else:

hex_data = ("{:0>"+str(hex_len)+"x}").format(decnum)

eeprom_list = []

if direction is 0 or 1:

if data == "":

eeprom_list.append("00")

else:

for eeprom_element in device.getEeprom().getcontent():

if eeprom_element["name"] == "ByteSize":

eeprom_size = int(str(eeprom_element))

if data == "":

eeprom.append("00")

else:

length += length % 4

padflag = True

# total numbers of strings

eeprom.append("{:0>2x}".format(count))

for element in [vendor_specific_data,

dc_related_elements,

input_elements,

output_elements]:

if element == "":

eeprom.append("00")

else:

# category length

if count % 2 == 1:

padflag = True

else:

for dummy in range(count):

if data == "":

eeprom.append("00")

eeprom.append("29")

eeprom.append("00")

# category length

if data == "":

eeprom.append("00")

else:

eeprom.append("00")

eeprom.append("00")

# category length

data = str(data.lower())

if data == "":

eeprom.append("00")

else:

eeprom.append("3c")

eeprom.append("00")

# category length

data = str(data.lower())

if data == "":

eeprom.append("00")

else:

# See COPYING file for copyrights details.

from __future__ import absolute_import

import os

import re

from types import TupleType

xstart, ystart = self.EtherCATManagementEditor.GetViewStart()

window_size = self.EtherCATManagementEditor.GetClientSize()

maxx, maxy = self.EtherCATManagementEditor.GetMinSize()

self.EtherCATManagementEditor.Scroll(posx, posy)

self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

posx, posy)

event.Skip()

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

xstart, ystart = self.EthercatMasterEditor.GetViewStart()

window_size = self.EthercatMasterEditor.GetClientSize()

maxx, maxy = self.EthercatMasterEditorSizer.GetMinSize()

self.EthercatMasterEditor.Scroll(posx, posy)

self.EthercatMasterEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

posx, posy)

event.Skip()

xstart, ystart = self.ModuleLibraryEditor.GetViewStart()

window_size = self.ModuleLibraryEditor.GetClientSize()

maxx, maxy = self.ModuleLibraryEditor.GetMinSize()

self.ModuleLibraryEditor.Scroll(posx, posy)

self.ModuleLibraryEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

posx, posy)

event.Skip()

# See COPYING file for copyrights details.

from __future__ import absolute_import

import os

import string

from xml.dom import minidom

self.Controler.CommonMethod.SaveSDOData[self.AllSDOData].append(self.Data)

(keep_going, _skip) = slaveSDO_progress.Update(count, "Please waiting a moment!!")

else:

(keep_going, _skip) = slaveSDO_progress.Update(count)

# Config Data: EEPROM Size, PDI Type, Device Emulation

# EEPROM's data in address '0x003f' is Size of EEPROM in KBit-1

# Find PDI Type in pdiType dictionary

cnt_pdi_type = int(self.GetWordAddressData(sii_dict.get('PDIControl'), 16).split('x')[1][2:4], 16)

for i in self.PDIType.keys():

for col in range(self.Col):

if col == 16:

self.SetColLabelValue(16, "Text View")

else:

self.SetColLabelValue(col, '%s' % col)

# set data into table

row = col = 0

# See COPYING file for copyrights details.

from __future__ import absolute_import

import os

from etherlab.EthercatSlave import ExtractHexDecValue, DATATYPECONVERSION, ExtractName

subindex = initCmd["Subindex"]

entry = device_entries.get((index, subindex), None)

if entry is not None:

data_str = ("0x%%.%dx" % (data_size * 2)) % initCmd["Value"]

init_cmd_infos = {

"index": index,

elif pdo_type == "Outputs" and entry.getDataType() is not None and device_coe is not None:

data_type = entry.getDataType().getcontent()

entry_infos["dir"] = "Q"

entry_infos["data_type"] = DATATYPECONVERSION.get(data_type)

entry_infos["var_type"] = data_type

entry_infos["real_var"] = "slave%(slave)d_%(index).4x_%(subindex).2x_default" % entry_infos

from __future__ import absolute_import

import datetime

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

data = "TOD#"

for val, format in [

(microseconds % SECOND, "%6.6d")]: # Microseconds

# Add value to TIME_OF_DAY literal

from __future__ import absolute_import

import wx

from six.moves import xrange

def GetTextBoundingBox(self):

# Calculate the size of the name outside the block

text_width, text_height = self.NameSize

self.Pos.y - (text_height + 2),

text_width,

text_height)

# Calculate the size for the connector lines

lines = max(len(self.Inputs), len(self.Outputs))

if lines > 0:

# Update inputs and outputs positions

for i in xrange(lines):

if scaling is not None:

ypos = round_scaling(self.Pos.y + position, scaling[1]) - self.Pos.y

# Draw a rectangle with the block size

dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

# Draw block name and block type

self.Pos.y - (name_size[1] + 2))

self.Pos.y + 5)

dc.DrawText(self.Name, name_pos[0], name_pos[1])

dc.DrawText(self.Type, type_pos[0], type_pos[1])

bbx_width = self.Size[0] + 2 * CONNECTOR_SIZE

else:

bbx_width = self.Size[0] + CONNECTOR_SIZE

bbx_width = max(bbx_width, self.NameSize[0])

bbx_height = self.Size[1]

if self.ExecutionOrder != 0:

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

else:

if self.Input:

self.Input.SetPosition(wx.Point(0, position))

if self.Output:

name_size = self.NameSize

executionorder_size = self.ExecutionOrderSize

# Draw a rectangle with the variable size

dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

# Draw variable name

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

else:

if self.Type == CONNECTOR:

self.Connector.SetPosition(wx.Point(0, position))

else:

# Draw a rectangle with the connection size with arrows inside

dc.DrawRectangle(self.Pos.x, self.Pos.y, self.Size[0] + 1, self.Size[1] + 1)

dc.DrawLine(self.Pos.x, self.Pos.y, self.Pos.x + arrowsize,

self.Pos.x, self.Pos.y + self.Size[1])

dc.DrawLine(self.Pos.x + self.Size[0] - arrowsize, self.Pos.y,

self.Pos.x + self.Size[0] - arrowsize, self.Pos.y + self.Size[1])

# Draw connection name

dc.DrawText(self.Name, text_pos[0], text_pos[1])

# Draw connector

if self.Connector:

from __future__ import absolute_import

from math import *

from types import *

from six.moves import xrange

def round_scaling(x, n, constraint=0):

if constraint == -1:

xround = int(fraction)

else:

"""

pos = event.GetLogicalPosition(dc)

if scaling:

return pos

pt = wx.Point(*self.Parent.CalcUnscrolledPosition(pos.x, pos.y))

left = (self.BoundingBox.x - 2) * scalex - HANDLE_SIZE

right = (self.BoundingBox.x + self.BoundingBox.width + 2) * scalex

top = (self.BoundingBox.y - 2) * scaley - HANDLE_SIZE

bottom = (self.BoundingBox.y + self.BoundingBox.height + 2) * scaley

extern_rect = wx.Rect(left, top, right + HANDLE_SIZE - left, bottom + HANDLE_SIZE - top)

dc.SetBrush(wx.BLACK_BRUSH)

left = (self.BoundingBox.x - 2) * scalex - HANDLE_SIZE

right = (self.BoundingBox.x + self.BoundingBox.width + 2) * scalex

top = (self.BoundingBox.y - 2) * scaley - HANDLE_SIZE

bottom = (self.BoundingBox.y + self.BoundingBox.height + 2) * scaley

for x, y in [(left, top), (center, top), (right, top),

if horizontally == ALIGN_LEFT:

movex = minx - posx

elif horizontally == ALIGN_CENTER:

elif horizontally == ALIGN_RIGHT:

movex = maxx - width - posx

if vertically == ALIGN_TOP:

movey = miny - posy

elif vertically == ALIGN_MIDDLE:

elif vertically == ALIGN_BOTTOM:

movey = maxy - height - posy

if movex != 0 or movey != 0:

rect = rect.Union(

wx.Rect(

parent_pos[0] + self.Pos.x + CONNECTOR_SIZE * self.Direction[0] +

parent_pos[1] + self.Pos.y + CONNECTOR_SIZE * self.Direction[1] +

height * (self.Direction[1] - 1),

width, height))

if self.Negated:

# If connector is negated, draw a circle

else:

xstart = parent_pos[0] + self.Pos.x

ystart = parent_pos[1] + self.Pos.y

yend = ystart + CONNECTOR_SIZE * self.Direction[1]

dc.DrawLine(xstart + self.Direction[0], ystart + self.Direction[1], xend, yend)

if self.Direction[0] != 0:

if self.Direction[0] < 0:

xtext = parent_pos[0] + self.Pos.x + 5

else:

xtext = parent_pos[0] + self.Pos.x - (name_size[0] + 5)

if self.Direction[1] != 0:

if self.Direction[1] < 0:

ytext = parent_pos[1] + self.Pos.y + 5

else:

width, height = self.ValueSize

dc.DrawText(self.ComputedValue,

parent_pos[0] + self.Pos.x + CONNECTOR_SIZE * self.Direction[0] +

parent_pos[1] + self.Pos.y + CONNECTOR_SIZE * self.Direction[1] +

height * (self.Direction[1] - 1))

dc.SetFont(self.ParentBlock.Parent.GetFont())

if self.ValueSize is not None:

width, height = self.ValueSize

if self.BoundingBox[2] > width * 4 or self.BoundingBox[3] > height * 4:

y = self.Points[0].y + height * (self.StartPoint[1][1] - 1)

rect = rect.Union(wx.Rect(x, y, width, height))

y = self.Points[-1].y + height * (self.EndPoint[1][1] - 1)

rect = rect.Union(wx.Rect(x, y, width, height))

else:

if self.BoundingBox[3] > height and self.Segments[middle] in [NORTH, SOUTH]:

else:

y = self.Points[middle].y - height

rect = rect.Union(wx.Rect(x, y, width, height))

# Current point is positioned in the middle of start point

# and end point on the current direction and a point is added

if self.Segments[0][0] != 0:

if self.Segments[0][1] != 0:

self.Points.insert(2, wx.Point(self.Points[1].x, self.Points[1].y))

self.Segments.insert(2, DirectionChoice(

(self.Segments[1][1],

# Current point is positioned in the middle of previous point

# and end point on the current direction and a point is added

if self.Segments[1][0] != 0:

if self.Segments[1][1] != 0:

self.Points.insert(3, wx.Point(self.Points[2].x, self.Points[2].y))

self.Segments.insert(

3,

# Current point is positioned in the middle of previous point

# and end point on the current direction

if self.Segments[i - 1][0] != 0:

if self.Segments[i - 1][1] != 0:

# A point is added

self.Points.insert(i + 1, wx.Point(self.Points[i].x, self.Points[i].y))

self.Segments.insert(

dir = self.EndPoint[1]

else:

dir = (0, 0)

width - dir[0] * MIN_SEGMENT_SIZE))

height - dir[1] * MIN_SEGMENT_SIZE))

self.Points[i] = wx.Point(minx + x + pointx, miny + y + pointy)

self.StartPoint[0] = self.Points[0]

# during a resize dragging

for i, point in enumerate(self.RealPoints):

if not (i == 0 and self.StartConnected) and not (i == len(self.Points) - 1 and self.EndConnected):

# Calculate the correct position of the points from real points

for i, point in enumerate(self.RealPoints):

if not (i == 0 and self.StartConnected) and not (i == len(self.Points) - 1 and self.EndConnected):

pointx = self.Points[segment].x

pointy = self.Points[segment].y

if dir[0] != 0:

if dir[1] != 0:

self.Points.insert(segment + 1, wx.Point(pointx, pointy))

self.Segments.insert(segment + 1, (dir[1], dir[0]))

self.Points.insert(segment + 2, wx.Point(pointx, pointy))

p1x = p2x = self.Points[segment].x

p1y = p2y = self.Points[segment].y

if dir[0] != 0:

if dir[1] != 0:

self.Points.insert(segment + 1, wx.Point(p1x, p1y))

self.Segments.insert(segment + 1, (dir[1], dir[0]))

self.Points.insert(segment + 2, wx.Point(p1x, p1y))

if event.ControlDown():

direction = (self.StartPoint[1], self.EndPoint[1])

if direction in [(EAST, WEST), (WEST, EAST)]:

if scaling is not None:

if self.StartConnected is not None:

movey = avgy - self.StartPoint[0].y

startblock = self.StartConnected.GetParentBlock()

self.MoveEndPoint(wx.Point(self.EndPoint[0].x, avgy))

self.Parent.RefreshBuffer()

elif direction in [(NORTH, SOUTH), (SOUTH, NORTH)]:

if scaling is not None:

if self.StartConnected is not None:

movex = avgx - self.StartPoint[0].x

startblock = self.StartConnected.GetParentBlock()

if self.ValueSize is not None:

width, height = self.ValueSize

if self.BoundingBox[2] > width * 4 or self.BoundingBox[3] > height * 4:

y = self.Points[0].y + height * (self.StartPoint[1][1] - 1)

dc.DrawText(self.ComputedValue, x, y)

y = self.Points[-1].y + height * (self.EndPoint[1][1] - 1)

dc.DrawText(self.ComputedValue, x, y)

else:

if self.BoundingBox[3] > height and self.Segments[middle] in [NORTH, SOUTH]:

else:

y = self.Points[middle].y - height

dc.DrawText(self.ComputedValue, x, y)

from __future__ import absolute_import

import wx

from six.moves import xrange

self.Connectors = []

self.RealConnectors = None

self.Id = id

self.SetType(type, connectors)

def Flush(self):

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

height = self.Size[1] - self.Extensions[0] - self.Extensions[1]

for i, connector in enumerate(self.Connectors):

if self.RealConnectors:

position = self.Extensions[0] + int(round(self.RealConnectors[i] * height))

else:

position = self.Extensions[0] + int(round(i * interval))

if scaling is not None:

if self.Type == LEFTRAIL:

connector.SetPosition(wx.Point(self.Size[0], position))

elif self.Type == RIGHTRAIL:

if height > 0:

for connector in self.Connectors:

position = connector.GetRelPosition()

elif len(self.Connectors) > 1:

self.RealConnectors = map(lambda x: x * 1 / (len(self.Connectors) - 1), xrange(len(self.Connectors)))

else:

movey = max(-self.BoundingBox.y, movey)

if scaling is not None:

position = handle.GetRelPosition()

self.MoveConnector(handle, movey)

return 0, movey

elif self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

self.Size = wx.Size(LD_ELEMENT_SIZE[0], LD_ELEMENT_SIZE[1])

self.Highlights = {}

# Create an input and output connector

self.PreviousValue = False

self.PreviousSpreading = False

self.RefreshNameSize()

text_width, text_height = self.Parent.GetTextExtent(self.Name)

# Calculate the bounding box size

if self.Name != "":

bbx_width = max(self.Size[0], text_width)

bbx_y = self.Pos.y - (text_height + 2)

bbx_height = self.Size[1] + (text_height + 2)

# Refresh the positions of the block connectors

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

self.Input.SetPosition(wx.Point(0, position))

self.Output.SetPosition(wx.Point(self.Size[0], position))

self.RefreshConnected()

dc.DrawRectangle(self.Pos.x, self.Pos.y, 2, self.Size[1] + 1)

dc.DrawRectangle(self.Pos.x + self.Size[0] - 1, self.Pos.y, 2, self.Size[1] + 1)

# Draw contact name

self.Pos.y - (name_size[1] + 2))

dc.DrawText(self.Name, name_pos[0], name_pos[1])

# Draw the modifier symbol in the middle of contact

if typetext != "":

dc.DrawText(typetext, type_pos[0], type_pos[1])

# Draw input and output connectors

self.Input.Draw(dc)

self.Size = wx.Size(LD_ELEMENT_SIZE[0], LD_ELEMENT_SIZE[1])

self.Highlights = {}

# Create an input and output connector

self.Value = None

self.PreviousValue = False

self.RefreshNameSize()

text_width, text_height = self.Parent.GetTextExtent(self.Name)

# Calculate the bounding box size

if self.Name != "":

bbx_width = max(self.Size[0], text_width)

bbx_y = self.Pos.y - (text_height + 2)

bbx_height = self.Size[1] + (text_height + 2)

# Refresh the positions of the block connectors

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

self.Input.SetPosition(wx.Point(0, position))

self.Output.SetPosition(wx.Point(self.Size[0], position))

self.RefreshConnected()

dc.SetPen(MiterPen(wx.GREEN))

else:

dc.SetPen(MiterPen(wx.BLACK))

name_size = self.NameSize

if typetext != "":

type_size = self.TypeSize

# Draw coil name

self.Pos.y - (name_size[1] + 2))

dc.DrawText(self.Name, name_pos[0], name_pos[1])

# Draw the modifier symbol in the middle of coil

if typetext != "":

dc.DrawText(typetext, type_pos[0], type_pos[1])

# Draw input and output connectors

self.Input.Draw(dc)

from __future__ import absolute_import

import wx

from six.moves import xrange

self.Size = wx.Size(SFC_STEP_DEFAULT_SIZE[0], SFC_STEP_DEFAULT_SIZE[1])

# Create an input and output connector

if not self.Initial:

else:

self.Input = None

self.Output = None

# Add output connector to step

def AddInput(self):

if not self.Input:

self.RefreshBoundingBox()

# Remove output connector from step

# Add output connector to step

def AddOutput(self):

if not self.Output:

self.RefreshBoundingBox()

# Remove output connector from step

# Add action connector to step

def AddAction(self):

if not self.Action:

self.RefreshBoundingBox()

# Remove action connector from step

# Refresh the positions of the step connectors

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

# Update input position if it exists

if self.Input:

self.Input.SetPosition(wx.Point(horizontal_pos, 0))

# Updates the step size

def UpdateSize(self, width, height):

diffy = height - self.Size.GetHeight()

self.Move(diffx, 0)

Graphic_Element.SetSize(self, width, height)

movex = max(-self.BoundingBox.x, movex)

movey = max(-self.BoundingBox.y, movey)

if scaling is not None:

if self.Parent.GetDrawingMode() == FREEDRAWING_MODE:

self.Move(movex, movey)

self.RefreshConnected()

if self.Initial:

dc.DrawRectangle(self.Pos.x + 2, self.Pos.y + 2, self.Size[0] - 3, self.Size[1] - 3)

# Draw step name

dc.DrawText(self.Name, name_pos[0], name_pos[1])

# Draw input and output connectors

if self.Input:

self.Priority = 0

self.Size = wx.Size(SFC_TRANSITION_SIZE[0], SFC_TRANSITION_SIZE[1])

# Create an input and output connector

self.SetType(type, condition)

self.SetPriority(priority)

self.Highlights = {}

# Calculate the bounding box of the condition outside the transition

text_width, text_height = self.ConditionSize

text_bbx = wx.Rect(self.Pos.x + self.Size[0] + 5,

text_width,

text_height)

test_text = text_bbx.InsideXY(pt.x, pt.y)

text_width, text_height = self.ConditionSize

# Calculate the bounding box size

bbx_width = max(bbx_width, self.Size[0] + 5 + text_width)

self.BoundingBox = wx.Rect(bbx_x, bbx_y, bbx_width + 1, bbx_height + 1)

# Returns the connector connected to input

# Refresh the positions of the transition connectors

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

# Update input position

self.Input.SetPosition(wx.Point(horizontal_pos, 0))

# Update output position

self.Condition.UnConnect(delete=self.Parent.GetDrawingMode() == FREEDRAWING_MODE)

self.Type = type

if type == "connection":

else:

if condition is None:

condition = ""

if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

movex = max(-self.BoundingBox.x, movex)

if scaling is not None:

self.Move(movex, 0)

self.RefreshInputPosition()

self.RefreshOutputPosition()

# Draw plain rectangle for representing the transition

dc.DrawRectangle(self.Pos.x,

self.Size[0] + 1,

SFC_TRANSITION_SIZE[1] + 1)

vertical_line_x = self.Input.GetPosition()[0]

else:

condition = "Transition"

condition_pos = (self.Pos.x + self.Size[0] + 5,

dc.DrawText(condition, condition_pos[0], condition_pos[1])

# Draw priority number

if self.Priority != 0:

self.Size = wx.Size((number - 1) * SFC_DEFAULT_SEQUENCE_INTERVAL, self.GetMinSize()[1])

# Create an input and output connector

if self.Type in [SELECTION_DIVERGENCE, SIMULTANEOUS_DIVERGENCE]:

self.Outputs = []

for i in xrange(number):

self.Outputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, self.Size[1]), SOUTH, onlyone=True))

self.Inputs = []

for i in xrange(number):

self.Inputs.append(Connector(self, "", None, wx.Point(i * SFC_DEFAULT_SEQUENCE_INTERVAL, 0), NORTH, onlyone=True))

self.Value = None

self.PreviousValue = None

if self.RealConnectors:

input.SetPosition(wx.Point(int(round(self.RealConnectors["Inputs"][i] * width)), 0))

else:

input.MoveConnected()

for i, output in enumerate(self.Outputs):

position = output.GetRelPosition()

if self.RealConnectors:

output.SetPosition(wx.Point(int(round(self.RealConnectors["Outputs"][i] * width)), height))

else:

output.MoveConnected()

self.Size = wx.Size(width, height)

self.RefreshBoundingBox()

self.RealConnectors = {"Inputs": [], "Outputs": []}

for input in self.Inputs:

position = input.GetRelPosition()

for output in self.Outputs:

position = output.GetRelPosition()

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

# Method called when a LeftUp event have been generated

if handle_type == HANDLE_CONNECTOR:

movex = max(-self.BoundingBox.x, movex)

if scaling is not None:

self.MoveConnector(handle, movex)

if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

self.RefreshConnectedPosition(handle)

self.Size = wx.Size(SFC_JUMP_SIZE[0], SFC_JUMP_SIZE[1])

self.Highlights = []

# Create an input and output connector

self.Value = None

self.PreviousValue = None

# Calculate the bounding box of the condition outside the transition

text_width, text_height = self.TargetSize

text_bbx = wx.Rect(self.Pos.x + self.Size[0] + 2,

text_width,

text_height)

return text_bbx.InsideXY(pt.x, pt.y) or Graphic_Element.HitTest(self, pt, connectors)

# Refresh the element connectors position

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

self.Input.SetPosition(wx.Point(horizontal_pos, 0))

self.RefreshConnected()

if self.Parent.GetDrawingMode() != FREEDRAWING_MODE:

movex = max(-self.BoundingBox.x, movex)

if scaling is not None:

self.Move(movex, 0)

self.RefreshInputPosition()

return movex, 0

target_size = self.TargetSize

# Draw plain rectangle for representing the divergence

points = [wx.Point(self.Pos.x, self.Pos.y),

wx.Point(self.Pos.x + self.Size[0], self.Pos.y),

dc.DrawPolygon(points)

target_pos = (self.Pos.x + self.Size[0] + 2,

dc.DrawText(self.Target, target_pos[0], target_pos[1])

# Draw input connector

if self.Input:

self.MinSize = wx.Size(SFC_ACTION_MIN_SIZE[0], SFC_ACTION_MIN_SIZE[1])

self.Highlights = {}

# Create an input and output connector

self.SetActions(actions)

self.Value = None

self.PreviousValue = None

def GetLineSize(self):

if len(self.Actions) > 0:

else:

return SFC_ACTION_MIN_SIZE[1]

# Refresh the element connectors position

def RefreshConnectors(self):

scaling = self.Parent.GetScaling()

if scaling is not None:

self.Input.SetPosition(wx.Point(0, vertical_pos))

self.RefreshConnected()

if handle_type == HANDLE_MOVE:

movex = max(-self.BoundingBox.x, movex)

if scaling is not None:

wires = self.Input.GetWires()

if len(wires) == 1:

input_pos = wires[0][0].GetOtherConnected(self.Input).GetPosition(False)

self.Pos.x + self.Size[0], self.Pos.y + i * line_size)

qualifier_size = dc.GetTextExtent(action.qualifier)

if action.duration != "":

duration_size = dc.GetTextExtent(action.duration)

dc.DrawText(action.duration, duration_pos[0], duration_pos[1])

else:

dc.DrawText(action.qualifier, qualifier_pos[0], qualifier_pos[1])

content_size = dc.GetTextExtent(action.value)

dc.DrawText(action.value, content_pos[0], content_pos[1])

if action.indicator != "":

indicator_size = dc.GetTextExtent(action.indicator)

dc.DrawText(action.indicator, indicator_pos[0], indicator_pos[1])

if not getattr(dc, "printing", False):

# used in safety-critical situations without a full and competent review.

from __future__ import absolute_import

from six.moves import xrange

# dictionary implementing:

{%(buffer)s}, {%(buffer)s}}'''

timeout = int(GetCTVal(child, 4))

timeout_ms = timeout - (timeout_s * 1000)

timeout_ns = timeout_ms * 1000000

from __future__ import absolute_import

from types import *

import re

from collections import OrderedDict

text += "%ds" % time_values[2]

if time_values[3] != 0:

if time_values[3] % 1000 != 0:

else:

task.set("interval", text)

# Update resources pou instance attributes

enable=$enable,W1648 # (bad-python3-import) Module moved in Python 3

enable=$enable,W1613 # (xrange-builtin) xrange built-in referenced

enable=$enable,W1612 # (unicode-builtin) unicode built-in referenced

# enable=

options=

from __future__ import absolute_import

import unittest

import time

def testCorrectValue(self):

"""Test case if no limiting is necessary"""

self.AddControls()

self.int_ctrl.SetValue(val)

self.ProcessEvents()

self.int_ctrl.Bind(controls.CustomIntCtrl.EVT_CUSTOM_INT, EventHandler)

self.int_ctrl.SetValue(val)

self.ProcessEvents()