diff -r b579e2155d02 -r 09d5d1456616 etherlab/ConfigEditor.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/etherlab/ConfigEditor.py Sat Jun 23 09:17:20 2018 +0200 @@ -0,0 +1,1404 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# This file is part of Beremiz +# +# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT +# RTES Lab : CRKim, JBLee, youcu +# Higen Motor : Donggu Kang +# +# See COPYING file for copyrights details. + +import os +import re +from types import TupleType + +import wx +import wx.grid +import wx.gizmos +import wx.lib.buttons + +from plcopen.structures import IEC_KEYWORDS, TestIdentifier +from controls import CustomGrid, CustomTable, FolderTree +from editors.ConfTreeNodeEditor import ConfTreeNodeEditor, SCROLLBAR_UNIT +from util.BitmapLibrary import GetBitmap +from controls.CustomStyledTextCtrl import NAVIGATION_KEYS + +# ----------------------------------------------------------------------- +from EtherCATManagementEditor import EtherCATManagementTreebook, MasterStatePanelClass +# ----------------------------------------------------------------------- + +[ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE] = range(3) + +def AppendMenu(parent, help, id, kind, text): + if wx.VERSION >= (2, 6, 0): + parent.Append(help=help, id=id, kind=kind, text=text) + else: + parent.Append(helpString=help, id=id, kind=kind, item=text) + +def GetVariablesTableColnames(position=False): + _ = lambda x : x + colname = ["#"] + if position: + colname.append(_("Position")) + return colname + [_("Name"), _("Index"), _("SubIndex"), _("Type"), _("Access")] + +ACCESS_TYPES = { + 'ro': 'R', + 'wo': 'W', + 'rw': 'R/W'} + +def GetAccessValue(access, pdo_mapping): + value = "SDO: %s" % ACCESS_TYPES.get(access, "") + if pdo_mapping != "": + value += ", PDO: %s" % pdo_mapping + return value + +VARIABLES_FILTERS = [ + (_("All"), (0x0000, 0xffff)), + (_("Communication Parameters"), (0x1000, 0x1fff)), + (_("Manufacturer Specific"), (0x2000, 0x5fff)), + (_("Standardized Device Profile"), (0x6000, 0x9fff))] + +VARIABLE_INDEX_FILTER_FORMAT = _("Variable Index: #x%4.4X") + +ETHERCAT_INDEX_MODEL = re.compile("#x([0-9a-fA-F]{0,4})$") +ETHERCAT_SUBINDEX_MODEL = re.compile("#x([0-9a-fA-F]{0,2})$") +LOCATION_MODEL = re.compile("(?:%[IQM](?:[XBWLD]?([0-9]+(?:\.[0-9]+)*)))$") + +class NodeVariablesSizer(wx.FlexGridSizer): + + def __init__(self, parent, controler, position_column=False): + wx.FlexGridSizer.__init__(self, cols=1, hgap=0, rows=2, vgap=5) + self.AddGrowableCol(0) + self.AddGrowableRow(1) + + self.Controler = controler + self.PositionColumn = position_column + + self.VariablesFilter = wx.ComboBox(parent, style=wx.TE_PROCESS_ENTER) + self.VariablesFilter.Bind(wx.EVT_COMBOBOX, self.OnVariablesFilterChanged) + self.VariablesFilter.Bind(wx.EVT_TEXT_ENTER, self.OnVariablesFilterChanged) + self.VariablesFilter.Bind(wx.EVT_CHAR, self.OnVariablesFilterKeyDown) + self.AddWindow(self.VariablesFilter, flag=wx.GROW) + + self.VariablesGrid = wx.gizmos.TreeListCtrl(parent, + style=wx.TR_DEFAULT_STYLE | + wx.TR_ROW_LINES | + wx.TR_COLUMN_LINES | + wx.TR_HIDE_ROOT | + wx.TR_FULL_ROW_HIGHLIGHT) + self.VariablesGrid.GetMainWindow().Bind(wx.EVT_LEFT_DOWN, + self.OnVariablesGridLeftClick) + self.AddWindow(self.VariablesGrid, flag=wx.GROW) + + self.Filters = [] + for desc, value in VARIABLES_FILTERS: + self.VariablesFilter.Append(desc) + self.Filters.append(value) + + self.VariablesFilter.SetSelection(0) + self.CurrentFilter = self.Filters[0] + self.VariablesFilterFirstCharacter = True + + if position_column: + for colname, colsize, colalign in zip(GetVariablesTableColnames(position_column), + [40, 80, 350, 80, 100, 80, 150], + [wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_LEFT, + wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_LEFT, + wx.ALIGN_LEFT]): + self.VariablesGrid.AddColumn(_(colname), colsize, colalign) + self.VariablesGrid.SetMainColumn(2) + else: + for colname, colsize, colalign in zip(GetVariablesTableColnames(), + [40, 350, 80, 100, 80, 150], + [wx.ALIGN_RIGHT, wx.ALIGN_LEFT, wx.ALIGN_RIGHT, + wx.ALIGN_RIGHT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]): + self.VariablesGrid.AddColumn(_(colname), colsize, colalign) + self.VariablesGrid.SetMainColumn(1) + + def RefreshView(self): + entries = self.Controler.GetSlaveVariables(self.CurrentFilter) + self.RefreshVariablesGrid(entries) + + def RefreshVariablesGrid(self, entries): + root = self.VariablesGrid.GetRootItem() + if not root.IsOk(): + root = self.VariablesGrid.AddRoot(_("Slave entries")) + self.GenerateVariablesGridBranch(root, entries, GetVariablesTableColnames(self.PositionColumn)) + self.VariablesGrid.Expand(root) + + def GenerateVariablesGridBranch(self, root, entries, colnames, idx=0): + item, root_cookie = self.VariablesGrid.GetFirstChild(root) + + no_more_items = not item.IsOk() + for entry in entries: + idx += 1 + if no_more_items: + item = self.VariablesGrid.AppendItem(root, "") + for col, colname in enumerate(colnames): + if col == 0: + self.VariablesGrid.SetItemText(item, str(idx), 0) + else: + value = entry.get(colname, "") + if colname == "Access": + value = GetAccessValue(value, entry.get("PDOMapping", "")) + self.VariablesGrid.SetItemText(item, value, col) + if entry["PDOMapping"] == "": + self.VariablesGrid.SetItemBackgroundColour(item, wx.LIGHT_GREY) + else: + self.VariablesGrid.SetItemBackgroundColour(item, wx.WHITE) + self.VariablesGrid.SetItemPyData(item, entry) + idx = self.GenerateVariablesGridBranch(item, entry["children"], colnames, idx) + if not no_more_items: + item, root_cookie = self.VariablesGrid.GetNextChild(root, root_cookie) + no_more_items = not item.IsOk() + + if not no_more_items: + to_delete = [] + while item.IsOk(): + to_delete.append(item) + item, root_cookie = self.VariablesGrid.GetNextChild(root, root_cookie) + for item in to_delete: + self.VariablesGrid.Delete(item) + + return idx + + def OnVariablesFilterChanged(self, event): + filter = self.VariablesFilter.GetSelection() + if filter != -1: + self.CurrentFilter = self.Filters[filter] + self.RefreshView() + else: + try: + value = self.VariablesFilter.GetValue() + if value == "": + self.CurrentFilter = self.Filters[0] + self.VariablesFilter.SetSelection(0) + else: + result = ETHERCAT_INDEX_MODEL.match(value) + if result is not None: + value = result.group(1) + index = int(value, 16) + self.CurrentFilter = (index, index) + self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % index) + self.RefreshView() + except: + if self.CurrentFilter in self.Filters: + self.VariablesFilter.SetSelection(self.Filters.index(self.CurrentFilter)) + else: + self.VariablesFilter.SetValue(VARIABLE_INDEX_FILTER_FORMAT % self.CurrentFilter[0]) + self.VariablesFilterFirstCharacter = True + event.Skip() + + def OnVariablesFilterKeyDown(self, event): + if self.VariablesFilterFirstCharacter: + keycode = event.GetKeyCode() + if keycode not in [wx.WXK_RETURN, + wx.WXK_NUMPAD_ENTER]: + self.VariablesFilterFirstCharacter = False + if keycode not in NAVIGATION_KEYS: + self.VariablesFilter.SetValue("") + if keycode not in [wx.WXK_DELETE, + wx.WXK_NUMPAD_DELETE, + wx.WXK_BACK]: + event.Skip() + else: + event.Skip() + + def OnVariablesGridLeftClick(self, event): + item, flags, col = self.VariablesGrid.HitTest(event.GetPosition()) + if item.IsOk(): + entry = self.VariablesGrid.GetItemPyData(item) + data_type = entry.get("Type", "") + data_size = self.Controler.GetSizeOfType(data_type) + + if col == -1 and data_size is not None: + pdo_mapping = entry.get("PDOMapping", "") + access = entry.get("Access", "") + entry_index = self.Controler.ExtractHexDecValue(entry.get("Index", "0")) + entry_subindex = self.Controler.ExtractHexDecValue(entry.get("SubIndex", "0")) + location = self.Controler.GetCurrentLocation() + if self.PositionColumn: + slave_pos = self.Controler.ExtractHexDecValue(entry.get("Position", "0")) + location += (slave_pos,) + node_name = self.Controler.GetSlaveName(slave_pos) + else: + node_name = self.Controler.CTNName() + + if pdo_mapping != "": + var_name = "%s_%4.4x_%2.2x" % (node_name, entry_index, entry_subindex) + if pdo_mapping == "T": + dir = "%I" + else: + dir = "%Q" + location = "%s%s" % (dir, data_size) + \ + ".".join(map(lambda x:str(x), location + (entry_index, entry_subindex))) + + data = wx.TextDataObject(str((location, "location", data_type, var_name, "", access))) + dragSource = wx.DropSource(self.VariablesGrid) + dragSource.SetData(data) + dragSource.DoDragDrop() + return + + elif self.PositionColumn: + location = self.Controler.GetCurrentLocation() +\ + (slave_pos, entry_index, entry_subindex) + data = wx.TextDataObject(str((location, "variable", access))) + dragSource = wx.DropSource(self.VariablesGrid) + dragSource.SetData(data) + dragSource.DoDragDrop() + return + + event.Skip() + +class NodeEditor(ConfTreeNodeEditor): + + CONFNODEEDITOR_TABS = [ + (_("Ethercat node"), "_create_EthercatNodeEditor"), + # Add Notebook Tab for EtherCAT Management Treebook + (_("EtherCAT Management"), "_create_EtherCATManagementEditor") + ] + + def _create_EthercatNodeEditor(self, prnt): + self.EthercatNodeEditor = wx.Panel(prnt, style=wx.TAB_TRAVERSAL) + + main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5) + main_sizer.AddGrowableCol(0) + main_sizer.AddGrowableRow(1) + + variables_label = wx.StaticText(self.EthercatNodeEditor, + label=_('Variable entries:')) + main_sizer.AddWindow(variables_label, border=10, flag=wx.TOP|wx.LEFT|wx.RIGHT) + + self.NodeVariables = NodeVariablesSizer(self.EthercatNodeEditor, self.Controler) + main_sizer.AddSizer(self.NodeVariables, border=10, + flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT) + + self.EthercatNodeEditor.SetSizer(main_sizer) + + return self.EthercatNodeEditor + + def __init__(self, parent, controler, window): + ConfTreeNodeEditor.__init__(self, parent, controler, window) + + # add Contoler for use EthercatSlave.py Method + self.Controler = controler + + def GetBufferState(self): + return False, False + + def RefreshView(self): + ConfTreeNodeEditor.RefreshView(self) + + self.NodeVariables.RefreshView() + + # -------------------For EtherCAT Management ---------------------------------------------- + def _create_EtherCATManagementEditor(self, prnt): + self.EtherCATManagementEditor = wx.ScrolledWindow(prnt, + style=wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL) + self.EtherCATManagementEditor.Bind(wx.EVT_SIZE, self.OnResize) + + self.EtherCATManagermentEditor_Main_Sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5) + self.EtherCATManagermentEditor_Main_Sizer.AddGrowableCol(0) + self.EtherCATManagermentEditor_Main_Sizer.AddGrowableRow(0) + + self.EtherCATManagementTreebook = EtherCATManagementTreebook(self.EtherCATManagementEditor, self.Controler, self) + + self.EtherCATManagermentEditor_Main_Sizer.AddSizer(self.EtherCATManagementTreebook, border=10, flag=wx.GROW) + + self.EtherCATManagementEditor.SetSizer(self.EtherCATManagermentEditor_Main_Sizer) + return self.EtherCATManagementEditor + + def OnResize(self, event): + self.EtherCATManagementEditor.GetBestSize() + xstart, ystart = self.EtherCATManagementEditor.GetViewStart() + window_size = self.EtherCATManagementEditor.GetClientSize() + maxx, maxy = self.EtherCATManagementEditor.GetMinSize() + posx = max(0, min(xstart, (maxx - window_size[0]) / SCROLLBAR_UNIT)) + posy = max(0, min(ystart, (maxy - window_size[1]) / SCROLLBAR_UNIT)) + self.EtherCATManagementEditor.Scroll(posx, posy) + self.EtherCATManagementEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, + maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy) + event.Skip() + # ------------------------------------------------------------------------------------------------------- + +CIA402NodeEditor = NodeEditor + + +def GetProcessVariablesTableColnames(): + _ = lambda x : x + return ["#", _("Name"), + _("Read from (nodeid, index, subindex)"), + _("Write to (nodeid, index, subindex)"), + _("Description")] + +class ProcessVariablesTable(CustomTable): + + def GetValue(self, row, col): + if row < self.GetNumberRows(): + if col == 0: + return row + 1 + colname = self.GetColLabelValue(col, False) + if colname.startswith("Read from"): + value = self.data[row].get("ReadFrom", "") + if value == "": + return value + return "%d, #x%0.4X, #x%0.2X" % value + elif colname.startswith("Write to"): + value = self.data[row].get("WriteTo", "") + if value == "": + return value + return "%d, #x%0.4X, #x%0.2X" % value + return self.data[row].get(colname, "") + + def SetValue(self, row, col, value): + if col < len(self.colnames): + colname = self.GetColLabelValue(col, False) + if colname.startswith("Read from"): + self.data[row]["ReadFrom"] = value + elif colname.startswith("Write to"): + self.data[row]["WriteTo"] = value + else: + self.data[row][colname] = value + + def _updateColAttrs(self, grid): + """ + wx.grid.Grid -> update the column attributes to add the + appropriate renderer given the column name. + + Otherwise default to the default renderer. + """ + for row in range(self.GetNumberRows()): + for col in range(self.GetNumberCols()): + editor = None + renderer = None + colname = self.GetColLabelValue(col, False) + if colname in ["Name", "Description"]: + editor = wx.grid.GridCellTextEditor() + renderer = wx.grid.GridCellStringRenderer() + grid.SetReadOnly(row, col, False) + else: + grid.SetReadOnly(row, col, True) + + grid.SetCellEditor(row, col, editor) + grid.SetCellRenderer(row, col, renderer) + + self.ResizeRow(grid, row) + +class ProcessVariableDropTarget(wx.TextDropTarget): + + def __init__(self, parent): + wx.TextDropTarget.__init__(self) + self.ParentWindow = parent + + def OnDropText(self, x, y, data): + self.ParentWindow.Select() + x, y = self.ParentWindow.ProcessVariablesGrid.CalcUnscrolledPosition(x, y) + col = self.ParentWindow.ProcessVariablesGrid.XToCol(x) + row = self.ParentWindow.ProcessVariablesGrid.YToRow(y - self.ParentWindow.ProcessVariablesGrid.GetColLabelSize()) + message = None + try: + values = eval(data) + except: + message = _("Invalid value \"%s\" for process variable")%data + values = None + if not isinstance(values, TupleType): + message = _("Invalid value \"%s\" for process variable")%data + values = None + if values is not None and col != wx.NOT_FOUND and row != wx.NOT_FOUND and 2 <= col <= 3: + location = None + if values[1] == "location": + result = LOCATION_MODEL.match(values[0]) + if result is not None: + location = map(int, result.group(1).split('.')) + master_location = self.ParentWindow.GetMasterLocation() + if (master_location == tuple(location[:len(master_location)]) and + len(location) - len(master_location) == 3): + values = tuple(location[len(master_location):]) + var_type = self.ParentWindow.Controler.GetSlaveVariableDataType(*values) + if col == 2: + other_values = self.ParentWindow.ProcessVariablesTable.GetValueByName(row, "WriteTo") + else: + other_values = self.ParentWindow.ProcessVariablesTable.GetValueByName(row, "ReadFrom") + if other_values != "": + other_type = self.ParentWindow.Controler.GetSlaveVariableDataType(*other_values) + else: + other_type = None + if other_type is None or var_type == other_type: + if col == 2: + self.ParentWindow.ProcessVariablesTable.SetValueByName(row, "ReadFrom", values) + else: + self.ParentWindow.ProcessVariablesTable.SetValueByName(row, "WriteTo", values) + self.ParentWindow.SaveProcessVariables() + self.ParentWindow.RefreshProcessVariables() + else: + message = _("'Read from' and 'Write to' variables types are not compatible") + else: + message = _("Invalid value \"%s\" for process variable")%data + + if message is not None: + wx.CallAfter(self.ShowMessage, message) + + def ShowMessage(self, message): + message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR) + message.ShowModal() + message.Destroy() + +def GetStartupCommandsTableColnames(): + _ = lambda x : x + return [_("Position"), _("Index"), _("Subindex"), _("Value"), _("Description")] + +class StartupCommandDropTarget(wx.TextDropTarget): + + def __init__(self, parent): + wx.TextDropTarget.__init__(self) + self.ParentWindow = parent + + def OnDropText(self, x, y, data): + self.ParentWindow.Select() + message = None + try: + values = eval(data) + except: + message = _("Invalid value \"%s\" for startup command")%data + values = None + if not isinstance(values, TupleType): + message = _("Invalid value \"%s\" for startup command")%data + values = None + if values is not None: + location = None + if values[1] == "location": + result = LOCATION_MODEL.match(values[0]) + if result is not None and len(values) > 5: + location = map(int, result.group(1).split('.')) + access = values[5] + elif values[1] == "variable": + location = values[0] + access = values[2] + if location is not None: + master_location = self.ParentWindow.GetMasterLocation() + if (master_location == tuple(location[:len(master_location)]) and + len(location) - len(master_location) == 3): + if access in ["wo", "rw"]: + self.ParentWindow.AddStartupCommand(*location[len(master_location):]) + else: + message = _("Entry can't be write through SDO") + else: + message = _("Invalid value \"%s\" for startup command")%data + + if message is not None: + wx.CallAfter(self.ShowMessage, message) + + def ShowMessage(self, message): + message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR) + message.ShowModal() + message.Destroy() + +class StartupCommandsTable(CustomTable): + + """ + A custom wx.grid.Grid Table using user supplied data + """ + def __init__(self, parent, data, colnames): + # The base class must be initialized *first* + CustomTable.__init__(self, parent, data, colnames) + self.old_value = None + + def GetValue(self, row, col): + if row < self.GetNumberRows(): + colname = self.GetColLabelValue(col, False) + value = self.data[row].get(colname, "") + if colname == "Index": + return "#x%0.4X" % value + elif colname == "Subindex": + return "#x%0.2X" % value + return value + + def SetValue(self, row, col, value): + if col < len(self.colnames): + colname = self.GetColLabelValue(col, False) + if colname in ["Index", "Subindex"]: + if colname == "Index": + result = ETHERCAT_INDEX_MODEL.match(value) + else: + result = ETHERCAT_SUBINDEX_MODEL.match(value) + if result is None: + return + value = int(result.group(1), 16) + elif colname == "Value": + value = int(value) + elif colname == "Position": + self.old_value = self.data[row][colname] + value = int(value) + self.data[row][colname] = value + + def GetOldValue(self): + return self.old_value + + def _updateColAttrs(self, grid): + """ + wx.grid.Grid -> update the column attributes to add the + appropriate renderer given the column name. + + Otherwise default to the default renderer. + """ + for row in range(self.GetNumberRows()): + for col in range(self.GetNumberCols()): + editor = None + renderer = None + colname = self.GetColLabelValue(col, False) + if colname in ["Position", "Value"]: + editor = wx.grid.GridCellNumberEditor() + renderer = wx.grid.GridCellNumberRenderer() + else: + editor = wx.grid.GridCellTextEditor() + renderer = wx.grid.GridCellStringRenderer() + + grid.SetCellEditor(row, col, editor) + grid.SetCellRenderer(row, col, renderer) + grid.SetReadOnly(row, col, False) + + self.ResizeRow(grid, row) + + def GetCommandIndex(self, position, command_idx): + for row, command in enumerate(self.data): + if command["Position"] == position and command["command_idx"] == command_idx: + return row + return None + +class MasterNodesVariablesSizer(NodeVariablesSizer): + + def __init__(self, parent, controler): + NodeVariablesSizer.__init__(self, parent, controler, True) + + self.CurrentNodesFilter = {} + + def SetCurrentNodesFilter(self, nodes_filter): + self.CurrentNodesFilter = nodes_filter + + def RefreshView(self): + if self.CurrentNodesFilter is not None: + args = self.CurrentNodesFilter.copy() + args["limits"] = self.CurrentFilter + entries = self.Controler.GetNodesVariables(**args) + self.RefreshVariablesGrid(entries) + +NODE_POSITION_FILTER_FORMAT = _("Node Position: %d") + +class MasterEditor(ConfTreeNodeEditor): + + CONFNODEEDITOR_TABS = [ + (_("Network"), "_create_EthercatMasterEditor"), + (_("Master State"), "_create_MasterStateEditor") + ] + + def _create_MasterStateEditor(self, prnt): + self.MasterStateEditor = wx.ScrolledWindow(prnt, style=wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL) + self.MasterStateEditor.Bind(wx.EVT_SIZE, self.OnResize) + + self.MasterStateEditor_Panel_Main_Sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5) + self.MasterStateEditor_Panel_Main_Sizer.AddGrowableCol(0) + self.MasterStateEditor_Panel_Main_Sizer.AddGrowableRow(0) + + self.MasterStateEditor_Panel = MasterStatePanelClass(self.MasterStateEditor, self.Controler) + + self.MasterStateEditor_Panel_Main_Sizer.AddSizer(self.MasterStateEditor_Panel, border=10, flag=wx.GROW) + + self.MasterStateEditor.SetSizer(self.MasterStateEditor_Panel_Main_Sizer) + return self.MasterStateEditor + + def OnResize(self, event): + self.MasterStateEditor.GetBestSize() + xstart, ystart = self.MasterStateEditor.GetViewStart() + window_size = self.MasterStateEditor.GetClientSize() + maxx, maxy = self.MasterStateEditor.GetMinSize() + posx = max(0, min(xstart, (maxx - window_size[0]) / SCROLLBAR_UNIT)) + posy = max(0, min(ystart, (maxy - window_size[1]) / SCROLLBAR_UNIT)) + self.MasterStateEditor.Scroll(posx, posy) + self.MasterStateEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, + maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy) + event.Skip() + + def _create_EthercatMasterEditor(self, prnt): + self.EthercatMasterEditor = wx.ScrolledWindow(prnt, + style=wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL) + self.EthercatMasterEditor.Bind(wx.EVT_SIZE, self.OnResize) + + self.EthercatMasterEditorSizer = wx.BoxSizer(wx.VERTICAL) + + self.NodesFilter = wx.ComboBox(self.EthercatMasterEditor, + style=wx.TE_PROCESS_ENTER) + self.Bind(wx.EVT_COMBOBOX, self.OnNodesFilterChanged, self.NodesFilter) + self.Bind(wx.EVT_TEXT_ENTER, self.OnNodesFilterChanged, self.NodesFilter) + self.NodesFilter.Bind(wx.EVT_CHAR, self.OnNodesFilterKeyDown) + + process_variables_header = wx.BoxSizer(wx.HORIZONTAL) + + process_variables_label = wx.StaticText(self.EthercatMasterEditor, + label=_("Process variables mapped between nodes:")) + process_variables_header.AddWindow(process_variables_label, 1, + flag=wx.ALIGN_CENTER_VERTICAL) + + for name, bitmap, help in [ + ("AddVariableButton", "add_element", _("Add process variable")), + ("DeleteVariableButton", "remove_element", _("Remove process variable")), + ("UpVariableButton", "up", _("Move process variable up")), + ("DownVariableButton", "down", _("Move process variable down"))]: + button = wx.lib.buttons.GenBitmapButton(self.EthercatMasterEditor, bitmap=GetBitmap(bitmap), + size=wx.Size(28, 28), style=wx.NO_BORDER) + button.SetToolTipString(help) + setattr(self, name, button) + process_variables_header.AddWindow(button, border=5, flag=wx.LEFT) + + self.ProcessVariablesGrid = CustomGrid(self.EthercatMasterEditor, style=wx.VSCROLL) + self.ProcessVariablesGrid.SetMinSize(wx.Size(0, 150)) + self.ProcessVariablesGrid.SetDropTarget(ProcessVariableDropTarget(self)) + self.ProcessVariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, + self.OnProcessVariablesGridCellChange) + self.ProcessVariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, + self.OnProcessVariablesGridCellLeftClick) + self.ProcessVariablesGrid.Bind(wx.EVT_KEY_DOWN, self.OnProcessVariablesGridKeyDown) + + startup_commands_header = wx.BoxSizer(wx.HORIZONTAL) + + startup_commands_label = wx.StaticText(self.EthercatMasterEditor, + label=_("Startup service variables assignments:")) + startup_commands_header.AddWindow(startup_commands_label, 1, + flag=wx.ALIGN_CENTER_VERTICAL) + + for name, bitmap, help in [ + ("AddCommandButton", "add_element", _("Add startup service variable")), + ("DeleteCommandButton", "remove_element", _("Remove startup service variable"))]: + button = wx.lib.buttons.GenBitmapButton(self.EthercatMasterEditor, bitmap=GetBitmap(bitmap), + size=wx.Size(28, 28), style=wx.NO_BORDER) + button.SetToolTipString(help) + setattr(self, name, button) + startup_commands_header.AddWindow(button, border=5, flag=wx.LEFT) + + self.StartupCommandsGrid = CustomGrid(self.EthercatMasterEditor, style=wx.VSCROLL) + self.StartupCommandsGrid.SetDropTarget(StartupCommandDropTarget(self)) + self.StartupCommandsGrid.SetMinSize(wx.Size(0, 150)) + self.StartupCommandsGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, + self.OnStartupCommandsGridCellChange) + self.StartupCommandsGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, + self.OnStartupCommandsGridEditorShow) + + self.NodesVariables = MasterNodesVariablesSizer(self.EthercatMasterEditor, self.Controler) + + main_staticbox = wx.StaticBox(self.EthercatMasterEditor, label=_("Node filter:")) + staticbox_sizer = wx.StaticBoxSizer(main_staticbox, wx.VERTICAL) + self.EthercatMasterEditorSizer.AddSizer(staticbox_sizer, 0, border=10, flag=wx.GROW|wx.ALL) + + main_staticbox_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=6, vgap=0) + main_staticbox_sizer.AddGrowableCol(0) + main_staticbox_sizer.AddGrowableRow(2) + main_staticbox_sizer.AddGrowableRow(4) + main_staticbox_sizer.AddGrowableRow(5) + staticbox_sizer.AddSizer(main_staticbox_sizer, 1, flag=wx.GROW) + main_staticbox_sizer.AddWindow(self.NodesFilter, border=5, flag=wx.GROW|wx.ALL) + main_staticbox_sizer.AddSizer(process_variables_header, border=5, + flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM) + main_staticbox_sizer.AddWindow(self.ProcessVariablesGrid, 1, + border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM) + main_staticbox_sizer.AddSizer(startup_commands_header, + border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM) + main_staticbox_sizer.AddWindow(self.StartupCommandsGrid, 1, + border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM) + + second_staticbox = wx.StaticBox(self.EthercatMasterEditor, label=_("Nodes variables filter:")) + second_staticbox_sizer = wx.StaticBoxSizer(second_staticbox, wx.VERTICAL) + second_staticbox_sizer.AddSizer(self.NodesVariables, 1, border=5, flag=wx.GROW|wx.ALL) + + main_staticbox_sizer.AddSizer(second_staticbox_sizer, 1, + border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM) + + self.EthercatMasterEditor.SetSizer(self.EthercatMasterEditorSizer) + + return self.EthercatMasterEditor + + def __init__(self, parent, controler, window): + ConfTreeNodeEditor.__init__(self, parent, controler, window) + + # ------------------------------------------------------------------ + self.Controler = controler + # ------------------------------------------------------------------ + + self.ProcessVariables = [] + self.CellShown = None + self.NodesFilterFirstCharacter = True + + self.ProcessVariablesDefaultValue = {"Name": "", "ReadFrom": "", "WriteTo": "", "Description": ""} + self.ProcessVariablesTable = ProcessVariablesTable(self, [], GetProcessVariablesTableColnames()) + self.ProcessVariablesColSizes = [40, 100, 150, 150, 200] + self.ProcessVariablesColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT] + + self.ProcessVariablesGrid.SetTable(self.ProcessVariablesTable) + self.ProcessVariablesGrid.SetButtons({"Add": self.AddVariableButton, + "Delete": self.DeleteVariableButton, + "Up": self.UpVariableButton, + "Down": self.DownVariableButton}) + + def _AddVariablesElement(new_row): + self.ProcessVariablesTable.InsertRow(new_row, self.ProcessVariablesDefaultValue.copy()) + self.SaveProcessVariables() + self.ProcessVariablesTable.ResetView(self.ProcessVariablesGrid) + return new_row + setattr(self.ProcessVariablesGrid, "_AddRow", _AddVariablesElement) + + def _DeleteVariablesElement(row): + self.ProcessVariablesTable.RemoveRow(row) + self.SaveProcessVariables() + self.ProcessVariablesTable.ResetView(self.ProcessVariablesGrid) + setattr(self.ProcessVariablesGrid, "_DeleteRow", _DeleteVariablesElement) + + def _MoveVariablesElement(row, move): + new_row = self.ProcessVariablesTable.MoveRow(row, move) + if new_row != row: + self.SaveProcessVariables() + self.ProcessVariablesTable.ResetView(self.ProcessVariablesGrid) + return new_row + setattr(self.ProcessVariablesGrid, "_MoveRow", _MoveVariablesElement) + + _refresh_buttons = getattr(self.ProcessVariablesGrid, "RefreshButtons") + def _RefreshButtons(): + if self.NodesFilter.GetSelection() == 0: + _refresh_buttons() + else: + self.AddVariableButton.Enable(False) + self.DeleteVariableButton.Enable(False) + self.UpVariableButton.Enable(False) + self.DownVariableButton.Enable(False) + setattr(self.ProcessVariablesGrid, "RefreshButtons", _RefreshButtons) + + self.ProcessVariablesGrid.SetRowLabelSize(0) + for col in range(self.ProcessVariablesTable.GetNumberCols()): + attr = wx.grid.GridCellAttr() + attr.SetAlignment(self.ProcessVariablesColAlignements[col], wx.ALIGN_CENTRE) + self.ProcessVariablesGrid.SetColAttr(col, attr) + self.ProcessVariablesGrid.SetColMinimalWidth(col, self.ProcessVariablesColSizes[col]) + self.ProcessVariablesGrid.AutoSizeColumn(col, False) + self.ProcessVariablesGrid.RefreshButtons() + + self.StartupCommandsDefaultValue = {"Position": 0, "Index": 0, "Subindex": 0, "Value": 0, "Description": ""} + self.StartupCommandsTable = StartupCommandsTable(self, [], GetStartupCommandsTableColnames()) + self.StartupCommandsColSizes = [100, 100, 50, 100, 200] + self.StartupCommandsColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_RIGHT, wx.ALIGN_LEFT] + + self.StartupCommandsGrid.SetTable(self.StartupCommandsTable) + self.StartupCommandsGrid.SetButtons({"Add": self.AddCommandButton, + "Delete": self.DeleteCommandButton}) + + def _AddCommandsElement(new_row): + command = self.StartupCommandsDefaultValue.copy() + command_idx = self.Controler.AppendStartupCommand(command) + self.RefreshStartupCommands() + self.RefreshBuffer() + return self.StartupCommandsTable.GetCommandIndex(command["Position"], command_idx) + setattr(self.StartupCommandsGrid, "_AddRow", _AddCommandsElement) + + def _DeleteCommandsElement(row): + command = self.StartupCommandsTable.GetRow(row) + self.Controler.RemoveStartupCommand(command["Position"], command["command_idx"]) + self.RefreshStartupCommands() + self.RefreshBuffer() + setattr(self.StartupCommandsGrid, "_DeleteRow", _DeleteCommandsElement) + + self.StartupCommandsGrid.SetRowLabelSize(0) + for col in range(self.StartupCommandsTable.GetNumberCols()): + attr = wx.grid.GridCellAttr() + attr.SetAlignment(self.StartupCommandsColAlignements[col], wx.ALIGN_CENTRE) + self.StartupCommandsGrid.SetColAttr(col, attr) + self.StartupCommandsGrid.SetColMinimalWidth(col, self.StartupCommandsColSizes[col]) + self.StartupCommandsGrid.AutoSizeColumn(col, False) + self.StartupCommandsGrid.RefreshButtons() + + def RefreshBuffer(self): + self.ParentWindow.RefreshTitle() + self.ParentWindow.RefreshFileMenu() + self.ParentWindow.RefreshEditMenu() + self.ParentWindow.RefreshPageTitles() + + def GetBufferState(self): + return self.Controler.GetBufferState() + + def Undo(self): + self.Controler.LoadPrevious() + self.RefreshView() + + def Redo(self): + self.Controler.LoadNext() + self.RefreshView() + + def RefreshView(self): + ConfTreeNodeEditor.RefreshView(self) + + self.RefreshNodesFilter() + self.RefreshProcessVariables() + self.RefreshStartupCommands() + self.NodesVariables.RefreshView() + + def RefreshNodesFilter(self): + value = self.NodesFilter.GetValue() + self.NodesFilter.Clear() + self.NodesFilter.Append(_("All")) + self.NodesFilterValues = [{}] + for vendor_id, vendor_name in self.Controler.GetLibraryVendors(): + self.NodesFilter.Append(_("%s's nodes") % vendor_name) + self.NodesFilterValues.append({"vendor": vendor_id}) + self.NodesFilter.Append(_("CIA402 nodes")) + self.NodesFilterValues.append({"slave_profile": 402}) + if value in self.NodesFilter.GetStrings(): + self.NodesFilter.SetStringSelection(value) + else: + try: + int(value) + self.NodesFilter.SetValue(value) + except: + self.NodesFilter.SetSelection(0) + self.RefreshCurrentNodesFilter() + + def RefreshCurrentNodesFilter(self): + filter = self.NodesFilter.GetSelection() + if filter != -1: + self.CurrentNodesFilter = self.NodesFilterValues[filter] + else: + try: + value = self.NodesFilter.GetValue() + if value == "": + self.CurrentNodesFilter = self.NodesFilterValues[0] + self.NodesFilter.SetSelection(0) + else: + position = int(self.NodesFilter.GetValue()) + self.CurrentNodesFilter = {"slave_pos": position} + self.NodesFilter.SetValue(NODE_POSITION_FILTER_FORMAT % position) + except: + if self.CurrentNodesFilter in self.NodesFilterValues: + self.NodesFilter.SetSelection(self.NodesFilterValues.index(self.CurrentNodesFilter)) + else: + self.NodesFilter.SetValue(NODE_POSITION_FILTER_FORMAT % self.CurrentNodesFilter["slave_pos"]) + self.NodesFilterFirstCharacter = True + self.NodesVariables.SetCurrentNodesFilter(self.CurrentNodesFilter) + + def RefreshProcessVariables(self): + if self.CurrentNodesFilter is not None: + self.ProcessVariables = self.Controler.GetProcessVariables() + slaves = self.Controler.GetSlaves(**self.CurrentNodesFilter) + data = [] + for variable in self.ProcessVariables: + if (variable["ReadFrom"] == "" or variable["ReadFrom"][0] in slaves or + variable["WriteTo"] == "" or variable["WriteTo"][0] in slaves): + data.append(variable) + self.ProcessVariablesTable.SetData(data) + self.ProcessVariablesTable.ResetView(self.ProcessVariablesGrid) + self.ProcessVariablesGrid.RefreshButtons() + + def SaveProcessVariables(self): + if self.CurrentNodesFilter is not None: + if len(self.CurrentNodesFilter) > 0: + self.Controler.SetProcessVariables(self.ProcessVariables) + else: + self.Controler.SetProcessVariables(self.ProcessVariablesTable.GetData()) + self.RefreshBuffer() + + def RefreshStartupCommands(self, position=None, command_idx=None): + if self.CurrentNodesFilter is not None: + col = max(self.StartupCommandsGrid.GetGridCursorCol(), 0) + self.StartupCommandsTable.SetData( + self.Controler.GetStartupCommands(**self.CurrentNodesFilter)) + self.StartupCommandsTable.ResetView(self.StartupCommandsGrid) + if position is not None and command_idx is not None: + self.SelectStartupCommand(position, command_idx, col) + + def SelectStartupCommand(self, position, command_idx, col): + self.StartupCommandsGrid.SetSelectedCell( + self.StartupCommandsTable.GetCommandIndex(position, command_idx), + col) + + def GetMasterLocation(self): + return self.Controler.GetCurrentLocation() + + def AddStartupCommand(self, position, index, subindex): + col = max(self.StartupCommandsGrid.GetGridCursorCol(), 0) + command = self.StartupCommandsDefaultValue.copy() + command["Position"] = position + command["Index"] = index + command["Subindex"] = subindex + command_idx = self.Controler.AppendStartupCommand(command) + self.RefreshStartupCommands() + self.RefreshBuffer() + self.SelectStartupCommand(position, command_idx, col) + + def OnNodesFilterChanged(self, event): + self.RefreshCurrentNodesFilter() + if self.CurrentNodesFilter is not None: + self.RefreshProcessVariables() + self.RefreshStartupCommands() + self.NodesVariables.RefreshView() + event.Skip() + + def OnNodesFilterKeyDown(self, event): + if self.NodesFilterFirstCharacter: + keycode = event.GetKeyCode() + if keycode not in [wx.WXK_RETURN, + wx.WXK_NUMPAD_ENTER]: + self.NodesFilterFirstCharacter = False + if keycode not in NAVIGATION_KEYS: + self.NodesFilter.SetValue("") + if keycode not in [wx.WXK_DELETE, + wx.WXK_NUMPAD_DELETE, + wx.WXK_BACK]: + event.Skip() + else: + event.Skip() + + def OnProcessVariablesGridCellChange(self, event): + row, col = event.GetRow(), event.GetCol() + colname = self.ProcessVariablesTable.GetColLabelValue(col, False) + value = self.ProcessVariablesTable.GetValue(row, col) + message = None + if colname == "Name": + if not TestIdentifier(value): + message = _("\"%s\" is not a valid identifier!") % value + elif value.upper() in IEC_KEYWORDS: + message = _("\"%s\" is a keyword. It can't be used!") % value + elif value.upper() in [var["Name"].upper() for idx, var in enumerate(self.ProcessVariablesTable.GetData()) if idx != row]: + message = _("An variable named \"%s\" already exists!") % value + if message is None: + self.SaveProcessVariables() + wx.CallAfter(self.ProcessVariablesTable.ResetView, self.ProcessVariablesGrid) + event.Skip() + else: + dialog = wx.MessageDialog(self, message, _("Error"), wx.OK|wx.ICON_ERROR) + dialog.ShowModal() + dialog.Destroy() + event.Veto() + + def OnProcessVariablesGridCellLeftClick(self, event): + row = event.GetRow() + if event.GetCol() == 0: + var_name = self.ProcessVariablesTable.GetValueByName(row, "Name") + var_type = self.Controler.GetSlaveVariableDataType( + *self.ProcessVariablesTable.GetValueByName(row, "ReadFrom")) + data_size = self.Controler.GetSizeOfType(var_type) + number = self.ProcessVariablesTable.GetValueByName(row, "Number") + location = "%%M%s" % data_size + \ + ".".join(map(lambda x:str(x), self.Controler.GetCurrentLocation() + (number,))) + + data = wx.TextDataObject(str((location, "location", var_type, var_name, ""))) + dragSource = wx.DropSource(self.ProcessVariablesGrid) + dragSource.SetData(data) + dragSource.DoDragDrop() + event.Skip() + + def OnProcessVariablesGridKeyDown(self, event): + keycode = event.GetKeyCode() + col = self.ProcessVariablesGrid.GetGridCursorCol() + row = self.ProcessVariablesGrid.GetGridCursorRow() + colname = self.ProcessVariablesTable.GetColLabelValue(col, False) + if (keycode in (wx.WXK_DELETE, wx.WXK_NUMPAD_DELETE) and + (colname.startswith("Read from") or colname.startswith("Write to"))): + self.ProcessVariablesTable.SetValue(row, col, "") + self.SaveProcessVariables() + wx.CallAfter(self.ProcessVariablesTable.ResetView, self.ProcessVariablesGrid) + else: + event.Skip() + + def OnStartupCommandsGridEditorShow(self, event): + self.CellShown = event.GetRow(), event.GetCol() + event.Skip() + + def OnStartupCommandsGridCellChange(self, event): + row, col = event.GetRow(), event.GetCol() + if self.CellShown == (row, col): + self.CellShown = None + colname = self.StartupCommandsTable.GetColLabelValue(col, False) + value = self.StartupCommandsTable.GetValue(row, col) + message = None + if colname == "Position": + if value not in self.Controler.GetSlaves(): + message = _("No slave defined at position %d!") % value + old_value = self.StartupCommandsTable.GetOldValue() + command = self.StartupCommandsTable.GetRow(row) + if message is None and old_value != command["Position"]: + self.Controler.RemoveStartupCommand( + self.StartupCommandsTable.GetOldValue(), + command["command_idx"], False) + command_idx = self.Controler.AppendStartupCommand(command) + wx.CallAfter(self.RefreshStartupCommands, command["Position"], command_idx) + else: + command = self.StartupCommandsTable.GetRow(row) + self.Controler.SetStartupCommandInfos(command) + if colname in ["Index", "SubIndex"]: + wx.CallAfter(self.RefreshStartupCommands, command["Position"], command["command_idx"]) + if message is None: + self.RefreshBuffer() + event.Skip() + else: + dialog = wx.MessageDialog(self, message, _("Error"), wx.OK|wx.ICON_ERROR) + dialog.ShowModal() + dialog.Destroy() + event.Veto() + else: + event.Veto() + + def OnResize(self, event): + self.EthercatMasterEditor.GetBestSize() + xstart, ystart = self.EthercatMasterEditor.GetViewStart() + window_size = self.EthercatMasterEditor.GetClientSize() + maxx, maxy = self.EthercatMasterEditorSizer.GetMinSize() + posx = max(0, min(xstart, (maxx - window_size[0]) / SCROLLBAR_UNIT)) + posy = max(0, min(ystart, (maxy - window_size[1]) / SCROLLBAR_UNIT)) + self.EthercatMasterEditor.Scroll(posx, posy) + self.EthercatMasterEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, + maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy) + event.Skip() + + #def OnButtonClick(self, event): + # self.MasterState = self.Controler.getMasterState() + # if self.MasterState: + # self.Phase.SetValue(self.MasterState["phase"]) + # self.Active.SetValue(self.MasterState["active"]) + # self.SlaveCount.SetValue(self.MasterState["slave"]) + # self.MacAddress.SetValue(self.MasterState["MAC"]) + # self.LinkState.SetValue(self.MasterState["link"]) + # self.TxFrames.SetValue(self.MasterState["TXframe"]) + # self.RxFrames.SetValue(self.MasterState["RXframe"]) + # self.TxByte.SetValue(self.MasterState["TXbyte"]) + # self.TxError.SetValue(self.MasterState["TXerror"]) + # self.LostFrames.SetValue(self.MasterState["lost"]) + + # self.TxFrameRate1.SetValue(self.MasterState["TXframerate1"]) + # self.TxFrameRate2.SetValue(self.MasterState["TXframerate2"]) + # self.TxFrameRate3.SetValue(self.MasterState["TXframerate3"]) + # self.TxRate1.SetValue(self.MasterState["TXrate1"]) + # self.TxRate2.SetValue(self.MasterState["TXrate2"]) + # self.TxRate3.SetValue(self.MasterState["TXrate3"]) + # self.LossRate1.SetValue(self.MasterState["loss1"]) + # self.LossRate2.SetValue(self.MasterState["loss2"]) + # self.LossRate3.SetValue(self.MasterState["loss3"]) + # self.FrameLoss1.SetValue(self.MasterState["frameloss1"]) + # self.FrameLoss2.SetValue(self.MasterState["frameloss2"]) + # self.FrameLoss3.SetValue(self.MasterState["frameloss3"]) + +class LibraryEditorSizer(wx.FlexGridSizer): + + def __init__(self, parent, module_library, buttons): + wx.FlexGridSizer.__init__(self, cols=1, hgap=0, rows=4, vgap=5) + + self.ModuleLibrary = module_library + self.ParentWindow = parent + + self.AddGrowableCol(0) + self.AddGrowableRow(1) + self.AddGrowableRow(3) + + ESI_files_label = wx.StaticText(parent, + label=_("ESI Files:")) + self.AddWindow(ESI_files_label, border=10, + flag=wx.TOP|wx.LEFT|wx.RIGHT) + + folder_tree_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=1, vgap=0) + folder_tree_sizer.AddGrowableCol(0) + folder_tree_sizer.AddGrowableRow(0) + self.AddSizer(folder_tree_sizer, border=10, + flag=wx.GROW|wx.LEFT|wx.RIGHT) + + self.ESIFiles = FolderTree(parent, self.GetPath(), editable=False) + self.ESIFiles.SetFilter(".xml") + folder_tree_sizer.AddWindow(self.ESIFiles, flag=wx.GROW) + + buttons_sizer = wx.BoxSizer(wx.VERTICAL) + folder_tree_sizer.AddSizer(buttons_sizer, + flag=wx.ALIGN_CENTER_VERTICAL) + + for idx, (name, bitmap, help, callback) in enumerate(buttons): + button = wx.lib.buttons.GenBitmapButton(parent, + bitmap=GetBitmap(bitmap), + size=wx.Size(28, 28), style=wx.NO_BORDER) + button.SetToolTipString(help) + setattr(self, name, button) + if idx > 0: + flag = wx.TOP + else: + flag = 0 + if callback is None: + callback = getattr(self, "On" + name, None) + if callback is not None: + parent.Bind(wx.EVT_BUTTON, callback, button) + buttons_sizer.AddWindow(button, border=10, flag=flag) + + modules_label = wx.StaticText(parent, + label=_("Modules library:")) + self.AddSizer(modules_label, border=10, + flag=wx.LEFT|wx.RIGHT) + + self.ModulesGrid = wx.gizmos.TreeListCtrl(parent, + style=wx.TR_DEFAULT_STYLE | + wx.TR_ROW_LINES | + wx.TR_COLUMN_LINES | + wx.TR_HIDE_ROOT | + wx.TR_FULL_ROW_HIGHLIGHT) + self.ModulesGrid.GetMainWindow().Bind(wx.EVT_LEFT_DOWN, + self.OnModulesGridLeftDown) + self.ModulesGrid.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, + self.OnModulesGridBeginLabelEdit) + self.ModulesGrid.Bind(wx.EVT_TREE_END_LABEL_EDIT, + self.OnModulesGridEndLabelEdit) + self.ModulesGrid.GetHeaderWindow().Bind(wx.EVT_MOTION, + self.OnModulesGridHeaderMotion) + self.AddWindow(self.ModulesGrid, border=10, + flag=wx.GROW|wx.BOTTOM|wx.LEFT|wx.RIGHT) + + for colname, colsize, colalign in zip( + [_("Name")] + [param_infos["column_label"] + for param, param_infos in + self.ModuleLibrary.MODULES_EXTRA_PARAMS], + [400] + [param_infos["column_size"] + for param, param_infos in + self.ModuleLibrary.MODULES_EXTRA_PARAMS], + [wx.ALIGN_LEFT] + [wx.ALIGN_RIGHT] * len(self.ModuleLibrary.MODULES_EXTRA_PARAMS)): + self.ModulesGrid.AddColumn(_(colname), colsize, colalign, edit=True) + self.ModulesGrid.SetMainColumn(0) + + self.CurrentSelectedCol = None + self.LastToolTipCol = None + + def GetPath(self): + return self.ModuleLibrary.GetPath() + + def SetControlMinSize(self, size): + self.ESIFiles.SetMinSize(size) + self.ModulesGrid.SetMinSize(size) + + def GetSelectedFilePath(self): + return self.ESIFiles.GetPath() + + def RefreshView(self): + self.ESIFiles.RefreshTree() + self.RefreshModulesGrid() + + def RefreshModulesGrid(self): + root = self.ModulesGrid.GetRootItem() + if not root.IsOk(): + root = self.ModulesGrid.AddRoot("Modules") + self.GenerateModulesGridBranch(root, + self.ModuleLibrary.GetModulesLibrary(), + GetVariablesTableColnames()) + self.ModulesGrid.Expand(root) + + def GenerateModulesGridBranch(self, root, modules, colnames): + item, root_cookie = self.ModulesGrid.GetFirstChild(root) + + no_more_items = not item.IsOk() + for module in modules: + if no_more_items: + item = self.ModulesGrid.AppendItem(root, "") + self.ModulesGrid.SetItemText(item, module["name"], 0) + if module["infos"] is not None: + for param_idx, (param, param_infos) in enumerate(self.ModuleLibrary.MODULES_EXTRA_PARAMS): + self.ModulesGrid.SetItemText(item, + str(module["infos"][param]), + param_idx + 1) + else: + self.ModulesGrid.SetItemBackgroundColour(item, wx.LIGHT_GREY) + self.ModulesGrid.SetItemPyData(item, module["infos"]) + self.GenerateModulesGridBranch(item, module["children"], colnames) + if not no_more_items: + item, root_cookie = self.ModulesGrid.GetNextChild(root, root_cookie) + no_more_items = not item.IsOk() + + if not no_more_items: + to_delete = [] + while item.IsOk(): + to_delete.append(item) + item, root_cookie = self.ModulesGrid.GetNextChild(root, root_cookie) + for item in to_delete: + self.ModulesGrid.Delete(item) + + def OnImportButton(self, event): + dialog = wx.FileDialog(self.ParentWindow, + _("Choose an XML file"), + os.getcwd(), "", + _("XML files (*.xml)|*.xml|All files|*.*"), wx.OPEN) + + if dialog.ShowModal() == wx.ID_OK: + filepath = dialog.GetPath() + if self.ModuleLibrary.ImportModuleLibrary(filepath): + wx.CallAfter(self.RefreshView) + else: + message = wx.MessageDialog(self, + _("No such XML file: %s\n") % filepath, + _("Error"), wx.OK|wx.ICON_ERROR) + message.ShowModal() + message.Destroy() + dialog.Destroy() + + event.Skip() + + def OnDeleteButton(self, event): + filepath = self.GetSelectedFilePath() + if os.path.isfile(filepath): + folder, filename = os.path.split(filepath) + + dialog = wx.MessageDialog(self.ParentWindow, + _("Do you really want to delete the file '%s'?") % filename, + _("Delete File"), wx.YES_NO|wx.ICON_QUESTION) + remove = dialog.ShowModal() == wx.ID_YES + dialog.Destroy() + + if remove: + os.remove(filepath) + self.ModuleLibrary.LoadModules() + wx.CallAfter(self.RefreshView) + event.Skip() + + def OnModulesGridLeftDown(self, event): + item, flags, col = self.ModulesGrid.HitTest(event.GetPosition()) + if item.IsOk(): + entry_infos = self.ModulesGrid.GetItemPyData(item) + if entry_infos is not None and col > 0: + self.CurrentSelectedCol = col + else: + self.CurrentSelectedCol = None + else: + self.CurrentSelectedCol = None + event.Skip() + + def OnModulesGridBeginLabelEdit(self, event): + item = event.GetItem() + if item.IsOk(): + entry_infos = self.ModulesGrid.GetItemPyData(item) + if entry_infos is not None: + event.Skip() + else: + event.Veto() + else: + event.Veto() + + def OnModulesGridEndLabelEdit(self, event): + item = event.GetItem() + if item.IsOk() and self.CurrentSelectedCol is not None: + entry_infos = self.ModulesGrid.GetItemPyData(item) + if entry_infos is not None and self.CurrentSelectedCol > 0: + param, param_infos = self.ModuleLibrary.MODULES_EXTRA_PARAMS[self.CurrentSelectedCol - 1] + stripped_column_label = param_infos["column_label"].split('(')[0].strip() + try: + self.ModuleLibrary.SetModuleExtraParam( + entry_infos["vendor"], + entry_infos["product_code"], + entry_infos["revision_number"], + param, + int(event.GetLabel())) + wx.CallAfter(self.RefreshModulesGrid) + event.Skip() + except ValueError: + message = wx.MessageDialog(self, + _("Module %s must be an integer!") % stripped_column_label, + _("Error"), wx.OK|wx.ICON_ERROR) + message.ShowModal() + message.Destroy() + event.Veto() + else: + event.Veto() + else: + event.Veto() + + def OnModulesGridHeaderMotion(self, event): + item, flags, col = self.ModulesGrid.HitTest(event.GetPosition()) + if col != self.LastToolTipCol and self.LastToolTipCol is not None: + self.ModulesGrid.GetHeaderWindow().SetToolTip(None) + self.LastToolTipCol = None + if col > 0 and self.LastToolTipCol != col: + self.LastToolTipCol = col + param, param_infos = self.ModuleLibrary.MODULES_EXTRA_PARAMS[col - 1] + wx.CallAfter(self.ModulesGrid.GetHeaderWindow().SetToolTipString, + param_infos["description"]) + event.Skip() + +class DatabaseManagementDialog(wx.Dialog): + + def __init__(self, parent, database): + wx.Dialog.__init__(self, parent, + size=wx.Size(700, 500), title=_('ESI Files Database management'), + style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER) + + main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=10) + main_sizer.AddGrowableCol(0) + main_sizer.AddGrowableRow(0) + + self.DatabaseSizer = LibraryEditorSizer(self, database, + [("ImportButton", "ImportESI", _("Import file to ESI files database"), None), + ("DeleteButton", "remove_element", _("Remove file from database"), None)]) + self.DatabaseSizer.SetControlMinSize(wx.Size(0, 0)) + main_sizer.AddSizer(self.DatabaseSizer, border=10, + flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT) + + button_sizer = self.CreateButtonSizer(wx.OK|wx.CANCEL|wx.CENTRE) + button_sizer.GetAffirmativeButton().SetLabel(_("Add file to project")) + button_sizer.GetCancelButton().SetLabel(_("Close")) + main_sizer.AddSizer(button_sizer, border=10, + flag=wx.ALIGN_RIGHT|wx.BOTTOM|wx.LEFT|wx.RIGHT) + + self.SetSizer(main_sizer) + + self.DatabaseSizer.RefreshView() + + def GetValue(self): + return self.DatabaseSizer.GetSelectedFilePath() + +class LibraryEditor(ConfTreeNodeEditor): + + CONFNODEEDITOR_TABS = [ + (_("Modules Library"), "_create_ModuleLibraryEditor")] + + def _create_ModuleLibraryEditor(self, prnt): + self.ModuleLibraryEditor = wx.ScrolledWindow(prnt, + style=wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL) + self.ModuleLibraryEditor.Bind(wx.EVT_SIZE, self.OnResize) + + self.ModuleLibrarySizer = LibraryEditorSizer(self.ModuleLibraryEditor, + self.Controler.GetModulesLibraryInstance(), + [("ImportButton", "ImportESI", _("Import ESI file"), None), + ("AddButton", "ImportDatabase", _("Add file from ESI files database"), self.OnAddButton), + ("DeleteButton", "remove_element", _("Remove file from library"), None)]) + self.ModuleLibrarySizer.SetControlMinSize(wx.Size(0, 200)) + self.ModuleLibraryEditor.SetSizer(self.ModuleLibrarySizer) + + return self.ModuleLibraryEditor + + def __init__(self, parent, controler, window): + ConfTreeNodeEditor.__init__(self, parent, controler, window) + + self.RefreshView() + + def RefreshView(self): + ConfTreeNodeEditor.RefreshView(self) + self.ModuleLibrarySizer.RefreshView() + + def OnAddButton(self, event): + dialog = DatabaseManagementDialog(self, + self.Controler.GetModulesDatabaseInstance()) + + if dialog.ShowModal() == wx.ID_OK: + module_library = self.Controler.GetModulesLibraryInstance() + module_library.ImportModuleLibrary(dialog.GetValue()) + + dialog.Destroy() + + wx.CallAfter(self.ModuleLibrarySizer.RefreshView) + + event.Skip() + + def OnResize(self, event): + self.ModuleLibraryEditor.GetBestSize() + xstart, ystart = self.ModuleLibraryEditor.GetViewStart() + window_size = self.ModuleLibraryEditor.GetClientSize() + maxx, maxy = self.ModuleLibraryEditor.GetMinSize() + posx = max(0, min(xstart, (maxx - window_size[0]) / SCROLLBAR_UNIT)) + posy = max(0, min(ystart, (maxy - window_size[1]) / SCROLLBAR_UNIT)) + self.ModuleLibraryEditor.Scroll(posx, posy) + self.ModuleLibraryEditor.SetScrollbars(SCROLLBAR_UNIT, SCROLLBAR_UNIT, + maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy) + event.Skip() +