def _init_coll_FileMenu_Items(self, parent):

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

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

parent.AppendMenu(ID_FILEMENURECENTPROJECTS, _("&Recent Projects"), self.RecentProjectsMenu)

parent.AppendSeparator()

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

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

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

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

parent.AppendSeparator()

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

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

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

parent.AppendSeparator()

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

self.Bind(wx.EVT_MENU, self.OnNewProjectMenu, id=wx.ID_NEW)

self.Bind(wx.EVT_MENU, self.OnOpenProjectMenu, id=wx.ID_OPEN)

self._RecursiveAddMenuItems(new_menu, children)

else:

AppendMenu(menu, help=help, id=new_id,

self.Bind(wx.EVT_MENU, self.GetAddConfNodeFunction(name),

id=new_id)

self.Bind(wx.EVT_MENU, handler, id=id)

parent.Append(help='', id=wx.ID_ABOUT,

self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

def _init_coll_ConnectionStatusBar_Fields(self, parent):

#self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogViewer), wx.RIGHT)

StatusToolBar = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,

StatusToolBar.SetToolBitmapSize(wx.Size(25, 25))

StatusToolBar.Realize()

self.Panes["StatusToolBar"] = StatusToolBar

self.AUIManager.AddPane(StatusToolBar, wx.aui.AuiPaneInfo().

self.AUIManager.Update()

# choose an arbitrary random port for runtime

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

# launch local runtime

"\"%s\" \"%s\" -p %s -i localhost %s %s" % (

sys.executable,

Bpath("Beremiz_service.py"),

for confnode_method in self.CTR.StatusMethods:

if "method" in confnode_method and confnode_method.get("shown", True):

id = wx.NewId()

confnode_method["tooltip"])

self.Bind(wx.EVT_MENU, self.GetMenuCallBackFunction(confnode_method["method"]), id=id)

self.ProjectTree.SelectItem(root)

self.ResetSelectedItem()

else:

elif words[0] == "R":

return self.RecursiveProjectTreeItemSelection(root, [(words[2], ITEM_RESOURCE)])

elif not os.path.exists(words[0]):

def DeleteConfNode(self, confnode):

if self.CTR.CheckProjectPathPerm():

_("Really delete node '%s'?") % confnode.CTNName(),

_("Remove %s node") % confnode.CTNType,

wx.YES_NO | wx.NO_DEFAULT)

if cap:

cap.ReleaseMouse()

_("""

An unhandled exception (bug) occured. Bug report saved at :

(%s)

variable.getinitial())

for variable in variables]

ret.extend([("On"+variable.getname()+"Change", "python_poll", "")

return ret

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

def _init_coll_AddMenu_Items(self, parent, add_config=True):

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDDATATYPE,

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDFUNCTION,

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDFUNCTIONBLOCK,

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDPROGRAM,

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDRESOURCE,

if add_config:

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUADDCONFIGURATION,

def _init_coll_EditMenu_Items(self, parent):

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

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

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

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

enable_undo_redo = _(u'Enable Undo/Redo') # Keeping text in translations for possible menu reactivation

parent.AppendSeparator()

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

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

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

parent.AppendSeparator()

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

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUFINDNEXT,

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUFINDPREVIOUS,

parent.AppendSeparator()

AppendMenu(parent, help='', id=ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT,

parent.AppendSeparator()

add_menu = wx.Menu(title='')

self._init_coll_AddMenu_Items(add_menu)

parent.AppendMenu(wx.ID_ADD, _(u"&Add Element"), add_menu)

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

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

self.Bind(wx.EVT_MENU, self.OnUndoMenu, id=wx.ID_UNDO)

self.Bind(wx.EVT_MENU, self.OnRedoMenu, id=wx.ID_REDO)

#self.Bind(wx.EVT_MENU, self.OnEnableUndoRedoMenu, id=ID_PLCOPENEDITOREDITMENUENABLEUNDOREDO)

self.Bind(wx.EVT_MENU, self.OnPasteMenu, id=wx.ID_PASTE)

self.Bind(wx.EVT_MENU, self.OnFindMenu, id=wx.ID_FIND)

self.Bind(wx.EVT_MENU, self.OnFindNextMenu,

self.Bind(wx.EVT_MENU, self.OnFindPreviousMenu,

self.Bind(wx.EVT_MENU, self.OnSearchInProjectMenu,

self.Bind(wx.EVT_MENU, self.OnSearchInProjectMenu,

self.Bind(wx.EVT_MENU, self.OnAddDataTypeMenu,

self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("function"),

self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("functionBlock"),

self.Bind(wx.EVT_MENU, self.GenerateAddPouFunction("program"),

self.Bind(wx.EVT_MENU, self.AddResourceMenu,

self.Bind(wx.EVT_MENU, self.OnAddConfigurationMenu,

self.Bind(wx.EVT_MENU, self.OnSelectAllMenu, id=wx.ID_SELECTALL)

self.Bind(wx.EVT_MENU, self.OnDeleteMenu, id=wx.ID_DELETE)

def _init_coll_DisplayMenu_Items(self, parent):

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

if self.EnableDebug:

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

parent.AppendSeparator()

zoommenu = wx.Menu(title='')

parent.AppendMenu(wx.ID_ZOOM_FIT, _("Zoom"), zoommenu)

for idx, value in enumerate(ZOOM_FACTORS):

new_id = wx.NewId()

AppendMenu(zoommenu, help='', id=new_id,

self.Bind(wx.EVT_MENU, self.GenerateZoomFunction(idx), id=new_id)

parent.AppendSeparator()

self.Bind(wx.EVT_MENU, self.SwitchFullScrMode, id=ID_PLCOPENEDITORDISPLAYMENUSWITCHPERSPECTIVE)

AppendMenu(parent, help='', id=ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE,

self.Bind(wx.EVT_MENU, self.OnResetPerspective, id=ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE)

self.Bind(wx.EVT_MENU, self.OnRefreshMenu, id=wx.ID_REFRESH)

def _init_ctrls(self, prnt):

wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name='IDEFrame',

self._init_icon(prnt)

self.SetClientSize(wx.Size(1000, 600))

self.Bind(wx.EVT_ACTIVATE, self.OnActivated)

self.AUIManager.SetDockSizeConstraint(0.5, 0.5)

self.Panes = {}

self.LeftNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.BottomNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.RightNoteBook.Bind(wx.aui.EVT_AUINOTEBOOK_ALLOW_DND,

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGING,

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED,

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CLOSE,

self.TabsOpened.Bind(wx.aui.EVT_AUINOTEBOOK_END_DRAG,

self.AUIManager.AddPane(self.TabsOpened,

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

# Creating PLCopen Project Types Tree

self.MainTabs = {}

self.ProjectTree = CustomTree(id=ID_PLCOPENEDITORPROJECTTREE,

self.ProjectTree.SetBackgroundBitmap(GetBitmap("custom_tree_background"),

wx.ALIGN_RIGHT | wx.ALIGN_BOTTOM)

add_menu = wx.Menu()

self._init_coll_AddMenu_Items(add_menu)

self.ProjectTree.SetAddMenu(add_menu)

self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnProjectTreeRightUp,

self.ProjectTree.Bind(wx.EVT_LEFT_UP, self.OnProjectTreeLeftUp)

self.Bind(wx.EVT_TREE_SEL_CHANGING, self.OnProjectTreeItemChanging,

self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnProjectTreeBeginDrag,

self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnProjectTreeItemBeginEdit,

self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnProjectTreeItemEndEdit,

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnProjectTreeItemActivated,

self.ProjectTree.Bind(wx.EVT_MOTION, self.OnProjectTreeMotion)

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

# Creating Tool Bar

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

MenuToolBar.SetToolBitmapSize(wx.Size(25, 25))

MenuToolBar.Realize()

self.Panes["MenuToolBar"] = MenuToolBar

self.AUIManager.AddPane(MenuToolBar, wx.aui.AuiPaneInfo().

EditorToolBar.SetToolBitmapSize(wx.Size(25, 25))

EditorToolBar.AddRadioTool(ID_PLCOPENEDITOREDITORTOOLBARSELECTION,

EditorToolBar.Realize()

self.Panes["EditorToolBar"] = EditorToolBar

self.AUIManager.AddPane(EditorToolBar, wx.aui.AuiPaneInfo().

self.Bind(wx.EVT_MENU, self.OnSelectionTool,

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

# Creating Search Panel

# self.Controler.IsProjectBufferEnabled())

self.EditMenu.Enable(wx.ID_FIND, selected > -1)

self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUFINDNEXT,

self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUFINDPREVIOUS,

self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, True)

MenuToolBar.EnableTool(ID_PLCOPENEDITOREDITMENUSEARCHINPROJECT, True)

self.EditMenu.Enable(wx.ID_ADD, True)

self.ProjectTree.SetItemTextColour(root, highlight_colours[1])

self.ProjectTree.SetItemExtraImage(root, None)

if infos["type"] == ITEM_POU:

if item_alone:

self.ProjectTree.SetItemExtraImage(root, self.Controler.GetPouType(infos["name"]))

elif "icon" in infos and infos["icon"] is not None:

root = self.ProjectTree.GetRootItem()

if root is not None and root.IsOk():

words = tagname.split("::")

return result

def RecursiveProjectTreeItemSelection(self, root, items):

self.EditProjectSettings()

else:

if item_infos["type"] in [ITEM_DATATYPE, ITEM_POU,

self.EditProjectElement(item_infos["type"], item_infos["tagname"])

event.Skip()

block_type = "Action"

self.LastToolTipItem = item

wx.CallAfter(self.ProjectTree.SetToolTipString,

elif self.LastToolTipItem is not None:

self.ProjectTree.SetToolTip(None)

self.LastToolTipItem = None

if not check_function(name):

return True

_("\"%s\" is used by one or more POUs. Do you wish to continue?") % name,

title, wx.YES_NO | wx.ICON_QUESTION)

answer = dialog.ShowModal()

_Point = namedtuple("Point", ["x", "y"])

["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

_BlockSpecificValues = (

[lambda x: x]),

}

["name", "negated", "edge", "position", "links"])

["refLocalId", "formalParameter", "points"])

infos = {"name": project.getname(), "type": ITEM_PROJECT}

datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values": []}

for datatype in project.getdataTypes():

pou_types = {

"function": {

"name": FUNCTIONS,

if pou.getbodyType() == "SFC":

transitions = []

for transition in pou.gettransitionList():

"tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()),

"values": []})

pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})

actions = []

for action in pou.getactionList():

"tagname": self.ComputePouActionName(pou.getname(), action.getname()),

"values": []})

pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})

configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}

for config in project.getconfigurations():

config_name = config.getname()

"tagname": self.ComputeConfigurationName(config.getname()),

"values": []}

resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}

for resource in config.getresource():

resource_name = resource.getname()

"tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()),

"values": []}

resources["values"].append(resource_infos)

extensions={

("instances_ns", "AddInstance"): factory.AddInstance})

return instances

"ActionTagName",

"TransitionTagName"]})

return factory.GetTagName()

os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),

parser),

extensions={("var_infos_ns", name): getattr(factory, name)

return variables

if config_name is None or config_name == configuration.getname():

variables.extend(

[var.getname() for var in reduce(

for varlist in configuration.globalVars],

[])])

return variables

return []

# Return resource variable names

variables = []

project = self.GetProject(debug)

if project is not None:

if resource_name is None or resource.getname() == resource_name:

variables.extend(

[var.getname() for var in reduce(

for varlist in resource.globalVars],

[])])

return variables

extensions={("var_infos_ns", name): getattr(factory, name)

for name in ["SetType", "AddDimension",

"AddTree", "AddVarToTree"]})

if tree:

return [factory.GetType(), factory.GetTree()]

return factory.GetType()

return blocktype_infos

if inputs == tuple([var_type

return blocktype_infos

return None

"list": [block for block in category["list"]

if block["type"] in filter]}

for category in self.TotalTypes]

"list": [pou.getblockInfos()

for pou in project.getpous(name, filter)

if (name is None or

return blocktypes

return self.TotalTypes

if block["type"] == "functionBlock":

blocktypes.append(block["name"])

if project is not None:

for pou in project.getpous(name, ["functionBlock"])

if (name is None or

len(self.GetInstanceList(pou, name, debug)) == 0)])

base_type = basetype_content.baseType.getcontent()

base_type_type = base_type.getLocalTag()

infos["base_type"] = (base_type.getname()

elif basetype_content_type == "enum":

infos["type"] = "Enumerated"

infos["values"] = []

base_type = basetype_content.baseType.getcontent()

base_type_type = base_type.getLocalTag()

infos["base_type"] = (base_type.getname()

elif basetype_content_type == "struct":

infos["type"] = "Structure"

infos["elements"] = []

base_type = element_type.baseType.getcontent()

base_type_type = base_type.getLocalTag()

element_infos["Type"] = ("array",

elif element_type_type == "derived":

element_infos["Type"] = element_type.getname()

else:

else:

infos["type"] = "Directly"

infos["base_type"] = (basetype_content.getname()

if datatype.initialValue is not None:

infos["initial"] = datatype.initialValue.getvalue()

element = self.GetEditedElement(tagname, debug)

if element is not None and element.getbodyType() not in ["ST", "IL"]:

for instance in element.getinstances():

names[instance.getname().upper()] = True

else:

project = self.GetProject(debug)

values = [[(value.getname(), (tagname, "value", i))]

for i, value in enumerate(

basetype_content.xpath("ppx:values/ppx:value",

datatype_def += [("(", ())]

datatype_def += JoinList([(", ", ())], values)

datatype_def += [(")", ())]

SelectionConvergenceClass, SelectionDivergenceClass,

SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [

PLCOpenParser.GetElementClass(instance_name, "sfcObjects")

TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions")

ActionObjClass = PLCOpenParser.GetElementClass("action", "actions")

parameter = link.getformalParameter()

instance = body.getcontentInstance(link.getrefLocalId())

if isinstance(instance, (InVariableClass, InOutVariableClass,

return instance.connectionPointOut

elif isinstance(instance, BlockClass):

outputvariables = instance.outputVariables.getvariable()

self.GenerateSFCAction(action["value"], pou)

else:

action_name = "%s_INLINE%d" % (step_name.upper(), self.GetActionNumber())

("\n", ())], ())

action_infos["content"] = action_name

self.SFCNetworks["Steps"][step_name]["actions"].append(action_infos)

def _init_coll_FileMenu_Items(self, parent):

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

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

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

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

parent.AppendSeparator()

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

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

AppendMenu(parent, help='', id=ID_PLCOPENEDITORFILEMENUGENERATE,

parent.AppendSeparator()

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

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

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

parent.AppendSeparator()

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

parent.AppendSeparator()

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

self.Bind(wx.EVT_MENU, self.OnNewProjectMenu, id=wx.ID_NEW)

self.Bind(wx.EVT_MENU, self.OnOpenProjectMenu, id=wx.ID_OPEN)

self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)

self.Bind(wx.EVT_MENU, self.OnSaveProjectAsMenu, id=wx.ID_SAVEAS)

self.Bind(wx.EVT_MENU, self.OnGenerateProgramMenu,

self.Bind(wx.EVT_MENU, self.OnPageSetupMenu, id=wx.ID_PAGE_SETUP)

self.Bind(wx.EVT_MENU, self.OnPreviewMenu, id=wx.ID_PREVIEW)

self.Bind(wx.EVT_MENU, self.OnPrintMenu, id=wx.ID_PRINT)

def _init_coll_HelpMenu_Items(self, parent):

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

#AppendMenu(parent, help='', id=wx.ID_HELP_CONTENTS,

# kind=wx.ITEM_NORMAL, text=u'PLCOpen\tF2')

#AppendMenu(parent, help='', id=wx.ID_HELP_CONTEXT,

self.Bind(wx.EVT_MENU, handler, id=id)

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

self.Bind(wx.EVT_MENU, self.OnPLCOpenEditorMenu, id=wx.ID_HELP)

#self.Bind(wx.EVT_MENU, self.OnPLCOpenMenu, id=wx.ID_HELP_CONTENTS)

self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

if cap:

cap.ReleaseMouse()

_("""

An unhandled exception (bug) occured. Bug report saved at :

(%s)

try:

# Invoke compiler. Output files are listed to stdout, errors to stderr

status, result, err_result = ProcessLogger(None, buildcmd,

except Exception, e:

return buildopt

# Timer to pull PLC status

self.StatusTimer = wx.Timer(self.AppFrame, -1)

self.AppFrame.Bind(wx.EVT_TIMER,

if self._connector is not None:

frame.LogViewer.SetLogSource(self._connector)

# Timer to dispatch debug values to consumers

self.DispatchDebugValuesTimer = wx.Timer(self.AppFrame, -1)

self.AppFrame.Bind(wx.EVT_TIMER,

self.RefreshConfNodesBlockLists()

if CheckPathPerm(self.ProjectPath):

return True

if self.AppFrame is not None:

answer = dialog.ShowModal()

dialog.Destroy()

if answer == wx.ID_YES:

try:

# Invoke compiler. Output files are listed to stdout, errors to stderr

status, result, err_result = ProcessLogger(self.logger, buildcmd,

except Exception, e:

self.logger.write_error(buildcmd + "\n")

self.logger.write_error(repr(e) + "\n")

return ([(C_file_name, self.plcCFLAGS)

for C_file_name in self.PLCGeneratedCFiles],

def ResetIECProgramsAndVariables(self):

"""

# filter location that are related to code that will be called

# in retreive, publish, init, cleanup

locstrs = map(lambda x: "_".join(map(str, x)),

# Generate main, based on template

if not self.BeremizRoot.getDisable_Extensions():

editor_name = editors.keys()[0]

elif len(editors) > 0:

names = editors.keys()

if dialog.ShowModal() == wx.ID_OK:

editor_name = names[dialog.GetSelection()]

dialog.Destroy()

def SnapshotAndResetDebugValuesBuffers(self):

buffers, self.DebugValuesBuffers = (self.DebugValuesBuffers,

ticks, self.DebugTicks = self.DebugTicks, []

return ticks, buffers

class CppEditor(CodeEditor):

KEYWORDS = ["asm", "auto", "bool", "break", "case", "catch", "char", "class",

COMMENT_HEADER = "/"

def SetCodeLexer(self):

(_("CANOpen network"), "_create_NetworkEditor")]

def _create_NetworkEditor(self, prnt):

NetworkEditorTemplate._init_ctrls(self, self.NetworkEditor)

@param pdomapping: list od variables to map with PDO

"""

# Add an entry to MasterMapping

# Return the data to add to DCF

if sync_TPDOs:

w, h = button.GetSize()

if direction in [wx.LEFT, wx.RIGHT]:

x = rect.x + (- w - offset

y = rect.y + (rect.height - h) / 2

offset += w

else:

# Start a drag'n drop from mouse position in wx coordinate of

# parent

xw, yw = self.GetPosition()

x + xw, y + yw, # Current mouse position

x + xw, y + yw) # Mouse position when button was clicked

item = self.ParentWindow.DraggingAxesPanel.ItemsDict.values()[0]

# Give mouse position in wx coordinate of parent

self.ParentWindow.StopDragNDrop(item.GetVariable(),

else:

# Reset any move in progress

if self.GraphType == GRAPH_PARALLEL: # Graph is parallel

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

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

else: # Graph is orthogonal in 3D

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

elif self.MouseStartPos is not None and len(self.Items) == 1:

xw, yw = self.GetPosition()

self.ParentWindow.SetCursorTick(self.StartCursorTick)

# Current mouse position

event.x + xw, height - event.y + yw,

# Mouse position when button was clicked

# The minimum height take in account the height of all items, padding

# inside figure and border around figure

return wx.Size(200,

def SetCanvasHeight(self, height):

"""

self.CanvasRange = wx.ComboBox(self, style=wx.CB_READONLY)

self.Bind(wx.EVT_COMBOBOX, self.OnRangeChanged, self.CanvasRange)

graphics_button_sizer.AddWindow(self.CanvasRange, 1,

self.CanvasRange.Clear()

default_range_idx = 0

for name, bitmap, help in [

("CurrentButton", "current", _("Go to current value")),

("ExportGraphButton", "export_graph", _("Export graph values to clipboard"))]:

button.SetToolTipString(help)

setattr(self, name, button)

self.Bind(wx.EVT_BUTTON, getattr(self, "On" + name), button)

graphics_button_sizer.AddWindow(button, border=5, flag=wx.LEFT)

self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK,

self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP,

self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN,

self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP,

self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN,

main_sizer.AddWindow(self.CanvasPosition, border=5, flag=wx.GROW | wx.LEFT | wx.RIGHT | wx.BOTTOM)

self.TickSizer = wx.BoxSizer(wx.HORIZONTAL)

def MoveCursorTick(self, move):

if self.CursorTick is not None:

cursor_tick = max(self.Ticks[0],

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

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

cursor_tick_idx = max(0,

self.CursorTick = self.Ticks[cursor_tick_idx]

self.RefreshCanvasPosition()

self.UpdateCursorTick()

for panel in self.GraphicPanels:

items.extend(panel.GetItems())

if len(items) > 1:

elif len(items) > 0:

self.VariableNameMask = items[0].GetVariable().split('.')[:-1] + ['*']

else:

posy = max(0, min(ystart, (vheight - window_size[1]) / SCROLLBAR_UNIT))

self.GraphicsWindow.Scroll(posx, posy)

self.GraphicsWindow.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT,

def OnGraphicsWindowEraseBackground(self, event):

pass

# create location text control

self.Duration = wx.TextCtrl(self, size=wx.Size(0, -1),

self.Duration.Bind(wx.EVT_KEY_DOWN, self.OnDurationChar)

main_sizer.AddWindow(self.Duration, flag=wx.GROW)

main_sizer = wx.BoxSizer(wx.VERTICAL)

self.Tree = wx.TreeCtrl(self,

if wx.Platform == '__WXMSW__':

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemExpanded, self.Tree)

self.Tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)

event.Skip()

else:

message = wx.MessageDialog(self,

message.ShowModal()

message.Destroy()

event.Veto()

# Add TreeCtrl for functions and function blocks library in splitter

# window

self.Tree = wx.TreeCtrl(splitter_window,

self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnTreeItemSelected, self.Tree)

self.Tree.Bind(wx.EVT_CHAR, self.OnKeyDown)

# If drag'n drop is enabled, bind event generated when a drag begins on

# Add TextCtrl for function and function block informations

self.Comment = wx.TextCtrl(splitter_window, size=wx.Size(0, 80),

splitter_window.SplitHorizontally(self.Tree, self.Comment, -80)

# Don't save selected item if it is a category

selected_infos = ((self.Tree.GetItemText(selected_item),

selected_pydata["inputs"])

# Get TreeCtrl root item (hidden)

root = self.Tree.GetRootItem()

for name, type, modifier

in blocktype["inputs"]]),

"extension": (len(blocktype["inputs"])

"comment": _(comment) + blocktype.get("usage", "")

}

self.Tree.SetPyData(blocktype_item, block_data)

# create location text control

self.Location = wx.TextCtrl(self, size=wx.Size(0, -1),

self.Location.Bind(wx.EVT_KEY_DOWN, self.OnLocationChar)

main_sizer.AddWindow(self.Location, flag=wx.GROW)

location = infos["location"]

# set the location

if not infos["location"].startswith("%"):

if dialog.ShowModal() == wx.ID_OK:

selected = dialog.GetSelection()

else:

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

dc.DrawText(self.Label,

DATE_INFO_SIZE = 10

self.SearchMessage.ShowCancelButton(True)

self.Bind(wx.EVT_TEXT_ENTER, self.OnSearchMessageChanged, self.SearchMessage)

self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN,

self.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,

filter_sizer.AddWindow(self.SearchMessage, 3, border=5, flag=wx.RIGHT | wx.ALIGN_CENTER_VERTICAL)

self.CleanButton = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap("Clean"),

self.CleanButton.SetToolTipString(_("Clean log messages"))

self.Bind(wx.EVT_BUTTON, self.OnCleanButton, self.CleanButton)

filter_sizer.AddWindow(self.CleanButton)

def __init__(self, parent, window, controller, debug):

wx.Panel.__init__(self, name='PouInstanceTreePanel',

self.ParentButton.SetToolTipString(_("Parent instance"))

self.Bind(wx.EVT_BUTTON, self.OnParentButtonClick,

self.InstanceChoice = wx.ComboBox(self, size=wx.Size(0, 0), style=wx.CB_READONLY)

self.Bind(wx.EVT_COMBOBOX, self.OnInstanceChoiceChanged,

self.DebugButton.SetToolTipString(_("Debug instance"))

self.Bind(wx.EVT_BUTTON, self.OnDebugButtonClick,

self.VariablesList.SetIndent(0)

self.VariablesList.SetSpacing(5)

self.VariablesList.DoSelectItem = lambda *x, **y: True

self.VariablesList.Bind(CT.EVT_TREE_ITEM_ACTIVATED,

self.VariablesList.Bind(wx.EVT_LEFT_DOWN, self.OnVariablesListLeftDown)

self.VariablesList.Bind(wx.EVT_KEY_DOWN, self.OnVariablesListKeyDown)

st = wx.StaticText(parent, label=label)

sizer.AddWindow(st, border=10,

tc = wx.TextCtrl(parent, style=wx.TE_PROCESS_ENTER)

setattr(self, name, tc)

self.Bind(wx.EVT_TEXT_ENTER, callback, tc)

tc.Bind(wx.EVT_KILL_FOCUS, callback)

sizer.AddWindow(tc, border=10,

def __init__(self, parent, controller=None, window=None, enable_required=True):

wx.Notebook.__init__(self, parent)

self.ProjectPanel.SetSizer(projectpanel_sizer)

self.AddSizerParams(self.ProjectPanel, projectpanel_sizer,

self.AddPage(self.ProjectPanel, _("Project"))

self.AuthorPanel.SetSizer(authorpanel_sizer)

self.AddSizerParams(self.AuthorPanel, authorpanel_sizer,

self.AddPage(self.AuthorPanel, _("Author"))

self.GraphicsPanel.SetSizer(graphicpanel_sizer)

pageSize_st = wx.StaticText(self.GraphicsPanel,

pageSize_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=5)

pageSize_sizer.AddGrowableCol(1)

graphicpanel_sizer.AddSizer(pageSize_sizer, border=10,

for name, label in [('PageWidth', _('Width:')),

('PageHeight', _('Height:'))]:

st = wx.StaticText(self.GraphicsPanel, label=label)

pageSize_sizer.AddWindow(st, border=12,

sp = wx.SpinCtrl(self.GraphicsPanel,

setattr(self, name, sp)

callback = self.GetPageSizeChangedFunction(sp, name)

self.Bind(wx.EVT_TEXT_ENTER, callback, sp)

pageSize_sizer.AddWindow(sp, flag=wx.GROW)

scaling_st = wx.StaticText(self.GraphicsPanel,

graphicpanel_sizer.AddWindow(scaling_st, border=10,

scaling_nb = wx.Notebook(self.GraphicsPanel)

graphicpanel_sizer.AddWindow(scaling_nb, border=10,

self.Scalings = {}

for language, translation in [("FBD", _("FBD")), ("LD", _("LD")), ("SFC", _("SFC"))]:

border = wx.BOTTOM

st = wx.StaticText(scaling_panel, label=label)

sp = wx.SpinCtrl(scaling_panel,

scaling_controls.append(sp)

callback = self.GetScalingChangedFunction(sp, language, name)

self.Bind(wx.EVT_TEXT_ENTER, callback, sp)

sp.Bind(wx.EVT_KILL_FOCUS, callback)

scalingpanel_sizer.AddWindow(sp, border=10,

self.Scalings[language] = scaling_controls

scaling_nb.AddPage(scaling_panel, translation)

# Miscellaneous Panel elements

miscellaneouspanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=15)

miscellaneouspanel_sizer.AddGrowableCol(1)

miscellaneouspanel_sizer.AddGrowableRow(1)

self.MiscellaneousPanel.SetSizer(miscellaneouspanel_sizer)

language_label = wx.StaticText(self.MiscellaneousPanel,

miscellaneouspanel_sizer.AddWindow(language_label, border=10,

self.Language = wx.ComboBox(self.MiscellaneousPanel,

self.Bind(wx.EVT_COMBOBOX, self.OnLanguageChanged, self.Language)

miscellaneouspanel_sizer.AddWindow(self.Language, border=10,

miscellaneouspanel_sizer.AddWindow(description_label, border=10,

self.Bind(wx.EVT_TEXT_ENTER, self.OnContentDescriptionChanged,

self.ContentDescription.Bind(wx.EVT_KILL_FOCUS,

miscellaneouspanel_sizer.AddWindow(self.ContentDescription, border=10,

self.AddPage(self.MiscellaneousPanel, _("Miscellaneous"))

if old_value != new_value:

self.Controller.SetProjectProperties(properties={name: new_value})

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

wx.CallAfter(self.RefreshView)

event.Skip()

return TextCtrlChangedFunction

if old_value != new_value:

self.Controller.SetProjectProperties(properties={"pageSize": new_value})

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

wx.CallAfter(self.RefreshView)

event.Skip()

return PageSizeChangedFunction

if old_value != new_value:

self.Controller.SetProjectProperties(properties={"scaling": {language: new_value}})

self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

wx.CallAfter(self.RefreshView)

event.Skip()

return ScalingChangedFunction

def _init_ctrls(self, prnt):

wx.Panel.__init__(self, id=ID_SEARCHRESULTPANEL,

self.HeaderLabel = wx.StaticText(id=ID_SEARCHRESULTPANELHEADERLABEL,

search_results_tree_style = CT.TR_HAS_BUTTONS | CT.TR_NO_LINES | CT.TR_HAS_VARIABLE_ROW_HEIGHT

self.SearchResultsTree = CT.CustomTreeCtrl(id=ID_SEARCHRESULTPANELSEARCHRESULTSTREE,

if wx.VERSION >= (2, 8, 11):

self.SearchResultsTree.SetAGWWindowStyleFlag(search_results_tree_style)

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnSearchResultsTreeItemActivated,

self.ResetButton.SetToolTipString(_("Reset search result"))

self.Bind(wx.EVT_BUTTON, self.OnResetButton, self.ResetButton)

if wx.Platform != '__WXMSW__' or len(text.splitlines()) > 1:

text_ctrl_style |= wx.TE_MULTILINE

text_ctrl = wx.TextCtrl(id=-1, parent=self.SearchResultsTree, pos=wx.Point(0, 0),

width, height = text_ctrl.GetTextExtent(text)

text_ctrl.SetClientSize(wx.Size(width + 1, height))

text_ctrl.SetBackgroundColour(self.SearchResultsTree.GetBackgroundColour())

message = _("Incompatible size of data between \"{a1}\" and \"{a2}\"").\

format(a1=location, a2=variable_type)

else:

if dialog.ShowModal() == wx.ID_OK:

selected = dialog.GetSelection()

else:

dlg.Destroy()

if var_name is None:

return

message = _("\"%s\" pou already exists!") % var_name

for name in self.ParentWindow.Controler.

var_infos = self.ParentWindow.DefaultValue.copy()

var_infos.Name = var_name

var_infos.Type = values[2]

if values[1] == "location":

location = values[0]

if not location.startswith("%"):

if dialog.ShowModal() == wx.ID_OK:

selected = dialog.GetSelection()

else:

self.ParentWindow.Debug)

if len(configs) == 0:

return

self.ParentWindow.Controler.AddConfigurationGlobalVar(

configs[0], values[2], var_name, location, "")

var_infos.Class = "External"

controls_sizer.AddWindow(self.ReturnTypeLabel, flag=wx.ALIGN_CENTER_VERTICAL)

self.ReturnType = wx.ComboBox(self,

self.Bind(wx.EVT_COMBOBOX, self.OnReturnTypeChanged, self.ReturnType)

controls_sizer.AddWindow(self.ReturnType)

controls_sizer.AddWindow(self.DescriptionLabel, flag=wx.ALIGN_CENTER_VERTICAL)

self.Description = wx.TextCtrl(self,

self.Bind(wx.EVT_TEXT_ENTER, self.OnDescriptionChanged, self.Description)

self.Description.Bind(wx.EVT_KILL_FOCUS, self.OnDescriptionChanged)

controls_sizer.AddWindow(self.Description)

controls_sizer.AddWindow(class_filter_label, flag=wx.ALIGN_CENTER_VERTICAL)

self.ClassFilter = wx.ComboBox(self,

self.Bind(wx.EVT_COMBOBOX, self.OnClassFilter, self.ClassFilter)

controls_sizer.AddWindow(self.ClassFilter)

("UpButton", "up", _("Move variable up")),

("DownButton", "down", _("Move variable down"))]:

button = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap(bitmap),

button.SetToolTipString(help)

setattr(self, name, button)

controls_sizer.AddWindow(button)

self.VariablesGrid = CustomGrid(self, style=wx.VSCROLL | wx.HSCROLL)

self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE,

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

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

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

self.SetSizer(self.MainSizer)

self.RefreshHighlightsTimer = wx.Timer(self, -1)

self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer,

self.Filter = "All"

self.FilterChoices = []

top_sizer.AddGrowableCol(0)

top_sizer.AddGrowableRow(0)

main_sizer.AddSizer(top_sizer, border=20,

actions_label = wx.StaticText(self, label=_('Actions:'))

top_sizer.AddWindow(actions_label, flag=wx.ALIGN_BOTTOM)

("DeleteButton", "remove_element", _("Remove action")),

("UpButton", "up", _("Move action up")),

("DownButton", "down", _("Move action down"))]:

button.SetToolTipString(help)

setattr(self, name, button)

top_sizer.AddWindow(button)

self.ActionsGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE,

self.OnActionsGridCellChange)

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

button_sizer = self.CreateButtonSizer(wx.OK | wx.CANCEL | wx.CENTRE)

self.Bind(wx.EVT_BUTTON, self.OnOK, button_sizer.GetAffirmativeButton())

main_sizer.AddSizer(button_sizer, border=20,

self.SetSizer(main_sizer)

top_sizer = wx.BoxSizer(wx.HORIZONTAL)

main_sizer.AddSizer(top_sizer, border=20,

basetype_label = wx.StaticText(self, label=_('Base Type:'))

top_sizer.AddWindow(basetype_label, 1, flag=wx.ALIGN_BOTTOM)

top_sizer.AddWindow(self.BaseType, 1, flag=wx.GROW)

self.Dimensions = CustomEditableListBox(self, label=_("Dimensions:"),

for func in ["_OnLabelEndEdit",

"_OnAddButton",

"_OnDelButton",

"_OnDownButton"]:

setattr(self.Dimensions, func, self.OnDimensionsChanged)

main_sizer.AddSizer(self.Dimensions, border=20,

button_sizer = self.CreateButtonSizer(wx.OK | wx.CANCEL | wx.CENTRE)

self.Bind(wx.EVT_BUTTON, self.OnOK, button_sizer.GetAffirmativeButton())

main_sizer.AddSizer(button_sizer, border=20,

self.SetSizer(main_sizer)

# Create a sizer for dividing parameters in two columns

self.ColumnSizer = wx.BoxSizer(wx.HORIZONTAL)

self.MainSizer.AddSizer(self.ColumnSizer, border=20,

# Create a sizer for left column

self.LeftGridSizer = wx.FlexGridSizer(cols=1, hgap=0,

if left_growable_row is not None:

self.LeftGridSizer.AddGrowableRow(left_growable_row)

self.ColumnSizer.AddSizer(self.LeftGridSizer, 1, border=5,

# Create a sizer for right column

self.RightGridSizer = wx.FlexGridSizer(cols=1, hgap=0,

if right_growable_row is not None:

self.RightGridSizer.AddGrowableRow(right_growable_row)

self.ColumnSizer.AddSizer(self.RightGridSizer, 1, border=5,

self.SetSizer(self.MainSizer)

# calculate preview panel scale so that graphic element fit inside

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

bbox.height * 1.1 > client_size.height) \

scale = (max(float(bbox.width) / client_size.width,

float(bbox.height) / client_size.height) * k)

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

def __init__(self, parent, var_type, controller):

wx.Dialog.__init__(self, parent, title=_('Browse Locations'),

main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=3, vgap=10)

main_sizer.AddGrowableCol(0)

locations_label = wx.StaticText(self, label=_('Locations available:'))

main_sizer.AddWindow(locations_label, border=20,

self.LocationsTree = wx.TreeCtrl(self,

self.LocationsTree.SetInitialSize(wx.Size(-1, 300))

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnLocationsTreeItemActivated,

self.LocationsTree)

main_sizer.AddWindow(self.LocationsTree, border=20,

button_gridsizer = wx.FlexGridSizer(cols=5, hgap=5, rows=1, vgap=0)

button_gridsizer.AddGrowableCol(1)

button_gridsizer.AddGrowableCol(3)

button_gridsizer.AddGrowableRow(0)

main_sizer.AddSizer(button_gridsizer, border=20,

direction_label = wx.StaticText(self, label=_('Direction:'))

button_gridsizer.AddWindow(direction_label,

self.DirFilterChoice = wx.ComboBox(self, style=wx.CB_READONLY)

self.Bind(wx.EVT_COMBOBOX, self.OnFilterChoice, self.DirFilterChoice)

button_gridsizer.AddWindow(self.DirFilterChoice,

filter_label = wx.StaticText(self, label=_('Type:'))

button_gridsizer.AddWindow(filter_label,

self.TypeFilterChoice = wx.ComboBox(self, style=wx.CB_READONLY)

self.Bind(wx.EVT_COMBOBOX, self.OnFilterChoice, self.TypeFilterChoice)

button_gridsizer.AddWindow(self.TypeFilterChoice,

button_sizer = self.CreateButtonSizer(wx.OK | wx.CANCEL | wx.CENTRE)

self.Bind(wx.EVT_BUTTON, self.OnOK, button_sizer.GetAffirmativeButton())

def __init__(self, parent, name, library, default=None):

wx.Dialog.__init__(self,

self.staticText1 = wx.StaticText(

label=_('Choose a value for %s:') % name, name='staticText1', parent=self,

to all connector having the same name in POU (default: False)

"""

BlockPreviewDialog.__init__(self, parent, controller, tagname,

# Init common sizers

self._init_sizers(2, 0, 7, 1, 0, None)

for type, label in [(CONNECTOR, _('Connector')),

(CONTINUATION, _('Continuation'))]:

radio_button = wx.RadioButton(self, label=label,

radio_button.SetValue(first)

self.Bind(wx.EVT_RADIOBUTTON, self.OnTypeChanged, radio_button)

self.LeftGridSizer.AddWindow(radio_button, flag=wx.GROW)

self.LeftGridSizer.AddWindow(self.Preview, flag=wx.GROW)

# Add buttons sizer to sizers

self.ColumnSizer.RemoveSizer(self.RightGridSizer)

# Add button for applying connection name modification to all connection

"""

# Set graphic element displayed, creating a FBD connection element

self.Element = FBD_Connector(self.Preview,

# Call BlockPreviewDialog function

BlockPreviewDialog.RefreshPreview(self)

self.SetSizer(self.MainSizer)

def _init_ctrls(self, prnt):

# Set up list control

self.ServicesList.InsertColumn(0, _('NAME'))

self.ServicesList.InsertColumn(1, _('TYPE'))

self.ServicesList.InsertColumn(2, _('IP'))

listmix.ColumnSorterMixin.__init__(self, 4)

self.Bind(wx.EVT_BUTTON, self.OnRefreshButton, id=ID_DISCOVERYDIALOGREFRESHBUTTON)

self.Bind(wx.EVT_BUTTON, self.OnLocalButton, id=ID_DISCOVERYDIALOGLOCALBUTTON)

self.Bind(wx.EVT_BUTTON, self.OnIpButton, id=ID_DISCOVERYDIALOGIPBUTTON)

self.ButtonSizer = self.CreateButtonSizer(wx.OK | wx.CANCEL | wx.CENTER)