1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import os

    26

import wx, wx.grid

    27

    28

from types import TupleType, StringType, UnicodeType

    29

    30

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS

    31

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    32

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    33

from CustomGrid import CustomGrid

    34

from CustomTable import CustomTable

    35

from LocationCellEditor import LocationCellEditor

    36

    37

# Compatibility function for wx versions < 2.6

    38

def AppendMenu(parent, help, id, kind, text):

    39

    if wx.VERSION >= (2, 6, 0):

    40

        parent.Append(help=help, id=id, kind=kind, text=text)

    41

    else:

    42

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    43

    44

[TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, TYPESTREE, 

    45

 INSTANCESTREE, LIBRARYTREE, SCALING

    46

] = range(9)

    47

    48

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

    49

#                            Variables Editor Panel

    50

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

    51

    52

def GetVariableTableColnames(location):

    53

    _ = lambda x : x

    54

    if location:

    55

    	return ["#", _("Name"), _("Class"), _("Type"), _("Location"), _("Initial Value"), _("Option"), _("Documentation")]

    56

    return ["#", _("Name"), _("Class"), _("Type"), _("Initial Value"), _("Option"), _("Documentation")]

    57

    58

def GetOptions(constant=True, retain=True, non_retain=True):

    59

    _ = lambda x : x

    60

    options = [""]

    61

    if constant:

    62

        options.append(_("Constant"))

    63

    if retain:

    64

        options.append(_("Retain"))

    65

    if non_retain:

    66

        options.append(_("Non-Retain"))

    67

    return options

    68

OPTIONS_DICT = dict([(_(option), option) for option in GetOptions()])

    69

    70

def GetFilterChoiceTransfer():

    71

    _ = lambda x : x

    72

    return {_("All"): _("All"), _("Interface"): _("Interface"), 

    73

            _("   Input"): _("Input"), _("   Output"): _("Output"), _("   InOut"): _("InOut"), 

    74

            _("   External"): _("External"), _("Variables"): _("Variables"), _("   Local"): _("Local"),

    75

            _("   Temp"): _("Temp"), _("Global"): _("Global")}#, _("Access") : _("Access")}

    76

VARIABLE_CHOICES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().iterkeys()])

    77

VARIABLE_CLASSES_DICT = dict([(_(_class), _class) for _class in GetFilterChoiceTransfer().itervalues()])

    78

    79

CheckOptionForClass = {"Local": lambda x: x,

    80

                       "Temp": lambda x: "",

    81

                       "Input": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    82

                       "InOut": lambda x: "",

    83

                       "Output": lambda x: {"Retain": "Retain", "Non-Retain": "Non-Retain"}.get(x, ""),

    84

                       "Global": lambda x: {"Constant": "Constant", "Retain": "Retain"}.get(x, ""),

    85

                       "External": lambda x: {"Constant": "Constant"}.get(x, "")

    86

                      }

    87

    88

class VariableTable(CustomTable):

    89

    90

    """

    91

    A custom wx.grid.Grid Table using user supplied data

    92

    """

    93

    def __init__(self, parent, data, colnames):

    94

        # The base class must be initialized *first*

    95

        CustomTable.__init__(self, parent, data, colnames)

    96

        self.old_value = None

    97

    98

    def GetValue(self, row, col):

    99

        if row < self.GetNumberRows():

   100

            if col == 0:

   101

                return self.data[row]["Number"]

   102

            colname = self.GetColLabelValue(col, False)

   103

            value = self.data[row].get(colname, "")

   104

            if colname == "Type" and isinstance(value, TupleType):

   105

                if value[0] == "array":

   106

                    return "ARRAY [%s] OF %s" % (",".join(map(lambda x : "..".join(x), value[2])), value[1])

   107

            if not isinstance(value, (StringType, UnicodeType)):

   108

                value = str(value)

   109

            if colname in ["Class", "Option"]:

   110

                return _(value)

   111

            return value

   112

   113

    def SetValue(self, row, col, value):

   114

        if col < len(self.colnames):

   115

            colname = self.GetColLabelValue(col, False)

   116

            if colname == "Name":

   117

                self.old_value = self.data[row][colname]

   118

            elif colname == "Class":

   119

                value = VARIABLE_CLASSES_DICT[value]

   120

                self.SetValueByName(row, "Option", CheckOptionForClass[value](self.GetValueByName(row, "Option")))

   121

                if value == "External":

   122

                    self.SetValueByName(row, "Initial Value", "")

   123

            elif colname == "Option":

   124

                value = OPTIONS_DICT[value]

   125

            self.data[row][colname] = value

   126

   127

    def GetOldValue(self):

   128

        return self.old_value

   129

   130

    def _updateColAttrs(self, grid):

   131

        """

   132

        wx.grid.Grid -> update the column attributes to add the

   133

        appropriate renderer given the column name.

   134

   135

        Otherwise default to the default renderer.

   136

        """

   137

        for row in range(self.GetNumberRows()):

   138

            var_class = self.GetValueByName(row, "Class")

   139

            var_type = self.GetValueByName(row, "Type")

   140

            row_highlights = self.Highlights.get(row, {})

   141

            for col in range(self.GetNumberCols()):

   142

                editor = None

   143

                renderer = None

   144

                colname = self.GetColLabelValue(col, False)

   145

                if self.Parent.Debug:

   146

                    grid.SetReadOnly(row, col, True)

   147

                else:

   148

                    if colname == "Option":

   149

                        options = GetOptions(constant = var_class in ["Local", "External", "Global"],

   150

                                             retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output", "Global"],

   151

                                             non_retain = self.Parent.ElementType != "function" and var_class in ["Local", "Input", "Output"])

   152

                        if len(options) > 1:

   153

                            editor = wx.grid.GridCellChoiceEditor()

   154

                            editor.SetParameters(",".join(map(_, options)))

   155

                        else:

   156

                            grid.SetReadOnly(row, col, True)

   157

                    elif col != 0 and self.GetValueByName(row, "Edit"):

   158

                        grid.SetReadOnly(row, col, False)

   159

                        if colname == "Name":

   160

                            if self.Parent.PouIsUsed and var_class in ["Input", "Output", "InOut"]:

   161

                                grid.SetReadOnly(row, col, True)

   162

                            else:

   163

                                editor = wx.grid.GridCellTextEditor()

   164

                                renderer = wx.grid.GridCellStringRenderer()

   165

                        elif colname == "Initial Value":

   166

                            if var_class != "External":

   167

                                if self.Parent.Controler.IsEnumeratedType(var_type):

   168

                                    editor = wx.grid.GridCellChoiceEditor()

   169

                                    editor.SetParameters(",".join(self.Parent.Controler.GetEnumeratedDataValues(var_type)))

   170

                                else:

   171

                                    editor = wx.grid.GridCellTextEditor()

   172

                                renderer = wx.grid.GridCellStringRenderer()

   173

                            else:

   174

                                grid.SetReadOnly(row, col, True)

   175

                        elif colname == "Location":

   176

                            if var_class in ["Local", "Global"] and self.Parent.Controler.IsLocatableType(var_type):

   177

                                editor = LocationCellEditor(self, self.Parent.Controler)

   178

                                renderer = wx.grid.GridCellStringRenderer()

   179

                            else:

   180

                                grid.SetReadOnly(row, col, True)

   181

                        elif colname == "Class":

   182

                            if len(self.Parent.ClassList) == 1 or self.Parent.PouIsUsed and var_class in ["Input", "Output", "InOut"]:

   183

                                grid.SetReadOnly(row, col, True)

   184

                            else:

   185

                                editor = wx.grid.GridCellChoiceEditor()

   186

                                excluded = []

   187

                                if self.Parent.PouIsUsed:

   188

                                    excluded.extend(["Input","Output","InOut"])

   189

                                if self.Parent.IsFunctionBlockType(var_type):

   190

                                    excluded.extend(["Local","Temp"])

   191

                                editor.SetParameters(",".join([_(choice) for choice in self.Parent.ClassList if choice not in excluded]))

   192

                    elif colname != "Documentation":

   193

                        grid.SetReadOnly(row, col, True)

   194

   195

                grid.SetCellEditor(row, col, editor)

   196

                grid.SetCellRenderer(row, col, renderer)

   197

   198

                highlight_colours = row_highlights.get(colname.lower(), [(wx.WHITE, wx.BLACK)])[-1]

   199

                grid.SetCellBackgroundColour(row, col, highlight_colours[0])

   200

                grid.SetCellTextColour(row, col, highlight_colours[1])

   201

            self.ResizeRow(grid, row)

   202

   203

   204

class VariableDropTarget(wx.TextDropTarget):

   205

    '''

   206

    This allows dragging a variable location from somewhere to the Location

   207

    column of a variable row.

   208

   209

    The drag source should be a TextDataObject containing a Python tuple like:

   210

        ('%ID0.0.0', 'location', 'REAL')

   211

   212

    c_ext/CFileEditor.py has an example of this (you can drag a C extension

   213

    variable to the Location column of the variable panel).

   214

    '''

   215

    def __init__(self, parent):

   216

        wx.TextDropTarget.__init__(self)

   217

        self.ParentWindow = parent

   218

   219

    def OnDropText(self, x, y, data):

   220

        x, y = self.ParentWindow.VariablesGrid.CalcUnscrolledPosition(x, y)

   221

        col = self.ParentWindow.VariablesGrid.XToCol(x)

   222

        row = self.ParentWindow.VariablesGrid.YToRow(y - self.ParentWindow.VariablesGrid.GetColLabelSize())

   242

                    location = values[0]

   243

                    variable_type = self.ParentWindow.Table.GetValueByName(row, "Type")

   244

                    base_type = self.ParentWindow.Controler.GetBaseType(variable_type)

   245

                    if location.startswith("%"):

   246

                        if base_type != values[2]:

   247

                            message = _("Incompatible data types between \"%s\" and \"%s\"")%(values[2], variable_type)

   248

                        else:

   249

                            self.ParentWindow.Table.SetValue(row, col, location)

   250

                            self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   251

                            self.ParentWindow.SaveValues()

   252

                    else:

   253

                        if location[0].isdigit() and base_type != "BOOL":

   254

                            message = _("Incompatible size of data between \"%s\" and \"BOOL\"")%location

   255

                        elif location[0] not in LOCATIONDATATYPES:

   256

                            message = _("Unrecognized data size \"%s\"")%location[0]

   257

                        elif base_type not in LOCATIONDATATYPES[location[0]]:

   258

                            message = _("Incompatible size of data between \"%s\" and \"%s\"")%(location, variable_type)

   259

                        else:

   260

                            dialog = wx.SingleChoiceDialog(self.ParentWindow, _("Select a variable class:"), _("Variable class"), ["Input", "Output", "Memory"], wx.OK|wx.CANCEL)

   261

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

   262

                                selected = dialog.GetSelection()

   263

                                if selected == 0:

   264

                                    location = "%I" + location

   265

                                elif selected == 1:

   266

                                    location = "%Q" + location

   267

                                else:

   268

                                    location = "%M" + location

   269

                                self.ParentWindow.Table.SetValue(row, col, location)

   270

                                self.ParentWindow.Table.ResetView(self.ParentWindow.VariablesGrid)

   271

                                self.ParentWindow.SaveValues()

   272

                            dialog.Destroy()

   298

   300

    def ShowMessage(self, message):

   301

        message = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   302

        message.ShowModal()

   303

        message.Destroy()

   304

   305

[ID_VARIABLEEDITORPANEL, ID_VARIABLEEDITORPANELVARIABLESGRID, 

   306

 ID_VARIABLEEDITORCONTROLPANEL, ID_VARIABLEEDITORPANELRETURNTYPE, 

   307

 ID_VARIABLEEDITORPANELCLASSFILTER, ID_VARIABLEEDITORPANELADDBUTTON, 

   308

 ID_VARIABLEEDITORPANELDELETEBUTTON, ID_VARIABLEEDITORPANELUPBUTTON, 

   309

 ID_VARIABLEEDITORPANELDOWNBUTTON, ID_VARIABLEEDITORPANELSTATICTEXT1, 

   310

 ID_VARIABLEEDITORPANELSTATICTEXT2, ID_VARIABLEEDITORPANELSTATICTEXT3,

   311

] = [wx.NewId() for _init_ctrls in range(12)]

   312

   313

class VariablePanel(wx.Panel):

   314

   315

    if wx.VERSION < (2, 6, 0):

   316

        def Bind(self, event, function, id = None):

   317

            if id is not None:

   318

                event(self, id, function)

   319

            else:

   320

                event(self, function)

   321

   322

    def _init_coll_MainSizer_Items(self, parent):

   323

        parent.AddWindow(self.ControlPanel, 0, border=5, flag=wx.GROW|wx.ALL)

   324

        parent.AddWindow(self.VariablesGrid, 0, border=0, flag=wx.GROW)

   325

   326

    def _init_coll_MainSizer_Growables(self, parent):

   327

        parent.AddGrowableCol(0)

   328

        parent.AddGrowableRow(1)

   329

   330

    def _init_coll_ControlPanelSizer_Items(self, parent):

   331

        parent.AddWindow(self.staticText1, 0, border=0, flag=wx.ALIGN_CENTER_VERTICAL)

   332

        parent.AddWindow(self.ReturnType, 0, border=0, flag=0)

   333

        parent.AddWindow(self.staticText2, 0, border=0, flag=wx.ALIGN_CENTER_VERTICAL)

   334

        parent.AddWindow(self.ClassFilter, 0, border=0, flag=0)

   335

        parent.AddWindow(self.AddButton, 0, border=0, flag=0)

   336

        parent.AddWindow(self.DeleteButton, 0, border=0, flag=0)

   337

        parent.AddWindow(self.UpButton, 0, border=0, flag=0)

   338

        parent.AddWindow(self.DownButton, 0, border=0, flag=0)

   339

   340

    def _init_coll_ControlPanelSizer_Growables(self, parent):

   341

        parent.AddGrowableCol(3)

   342

        parent.AddGrowableRow(0)

   343

   344

    def _init_sizers(self):

   345

        self.MainSizer = wx.FlexGridSizer(cols=1, hgap=10, rows=2, vgap=0)

   346

        self.ControlPanelSizer = wx.FlexGridSizer(cols=8, hgap=5, rows=1, vgap=5)

   347

   348

        self._init_coll_MainSizer_Items(self.MainSizer)

   349

        self._init_coll_MainSizer_Growables(self.MainSizer)

   350

        self._init_coll_ControlPanelSizer_Items(self.ControlPanelSizer)

   351

        self._init_coll_ControlPanelSizer_Growables(self.ControlPanelSizer)

   352

   353

        self.ControlPanel.SetSizer(self.ControlPanelSizer)

   354

        self.SetSizer(self.MainSizer)

   355

   356

    def _init_ctrls(self, prnt):

   357

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

   358

              name='VariableEditorPanel', parent=prnt, pos=wx.Point(0, 0),

   359

              size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

   360

   361

        self.VariablesGrid = CustomGrid(id=ID_VARIABLEEDITORPANELVARIABLESGRID,

   362

              name='VariablesGrid', parent=self, pos=wx.Point(0, 0), 

   363

              size=wx.Size(0, 0), style=wx.VSCROLL)

   364

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   365

        if wx.VERSION >= (2, 6, 0):

   366

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

   367

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

   368

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

   369

        else:

   370

            wx.grid.EVT_GRID_CELL_CHANGE(self.VariablesGrid, self.OnVariablesGridCellChange)

   371

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

   372

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

   373

   374

        self.ControlPanel = wx.ScrolledWindow(id=ID_VARIABLEEDITORCONTROLPANEL,

   375

              name='ControlPanel', parent=self, pos=wx.Point(0, 0),

   376

              size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

   377

        self.ControlPanel.SetScrollRate(10, 0)

   378

   379

        self.staticText1 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT1,

   380

              label=_('Return Type:'), name='staticText1', parent=self.ControlPanel,

   381

              pos=wx.Point(0, 0), size=wx.DefaultSize, style=0)

   382

   383

        self.ReturnType = wx.ComboBox(id=ID_VARIABLEEDITORPANELRETURNTYPE,

   384

              name='ReturnType', parent=self.ControlPanel, pos=wx.Point(0, 0),

   385

              size=wx.Size(145, 28), style=wx.CB_READONLY)

   386

        self.Bind(wx.EVT_COMBOBOX, self.OnReturnTypeChanged, id=ID_VARIABLEEDITORPANELRETURNTYPE)

   387

   388

        self.staticText2 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT2,

   389

              label=_('Class Filter:'), name='staticText2', parent=self.ControlPanel,

   390

              pos=wx.Point(0, 0), size=wx.DefaultSize, style=0)

   391

   392

        self.ClassFilter = wx.ComboBox(id=ID_VARIABLEEDITORPANELCLASSFILTER,

   393

              name='ClassFilter', parent=self.ControlPanel, pos=wx.Point(0, 0),

   394

              size=wx.Size(145, 28), style=wx.CB_READONLY)

   395

        self.Bind(wx.EVT_COMBOBOX, self.OnClassFilter, id=ID_VARIABLEEDITORPANELCLASSFILTER)

   396

   397

        self.AddButton = wx.Button(id=ID_VARIABLEEDITORPANELADDBUTTON, label=_('Add'),

   398

              name='AddButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   399

              size=wx.DefaultSize, style=0)

   400

   401

        self.DeleteButton = wx.Button(id=ID_VARIABLEEDITORPANELDELETEBUTTON, label=_('Delete'),

   402

              name='DeleteButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   403

              size=wx.DefaultSize, style=0)

   404

   405

        self.UpButton = wx.Button(id=ID_VARIABLEEDITORPANELUPBUTTON, label='^',

   406

              name='UpButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   407

              size=wx.Size(28, 28), style=0)

   408

   409

        self.DownButton = wx.Button(id=ID_VARIABLEEDITORPANELDOWNBUTTON, label='v',

   410

              name='DownButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   411

              size=wx.Size(28, 28), style=0)

   412

   413

        self._init_sizers()

   414

   415

    def __init__(self, parent, window, controler, element_type, debug=False):

   416

        self._init_ctrls(parent)

   417

        self.ParentWindow = window

   418

        self.Controler = controler

   419

        self.ElementType = element_type

   420

        self.Debug = debug

   421

   422

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

   423

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

   424

   425

        self.Filter = "All"

   426

        self.FilterChoices = []

   427

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   428

   429

        self.DefaultValue = {   "Name" : "", "Class" : "", "Type" : "INT", "Location" : "",

   430

                                "Initial Value" : "", "Option" : "",

   431

                                "Documentation" : "", "Edit" : True

   432

                            }

   433

   434

        if element_type in ["config", "resource"]:

   435

            self.DefaultTypes = {"All" : "Global"}

   436

        else:

   437

            self.DefaultTypes = {"All" : "Local", "Interface" : "Input", "Variables" : "Local"}

   438

   439

        if element_type in ["config", "resource"] \

   440

        or element_type in ["program", "transition", "action"]:

   441

            # this is an element that can have located variables

   442

            self.Table = VariableTable(self, [], GetVariableTableColnames(True))

   443

   444

            if element_type in ["config", "resource"]:

   445

                self.FilterChoices = ["All", "Global"]#,"Access"]

   446

            else:

   447

                self.FilterChoices = ["All",

   448

                                        "Interface", "   Input", "   Output", "   InOut", "   External",

   449

                                        "Variables", "   Local", "   Temp"]#,"Access"]

   450

   451

            # these condense the ColAlignements list

   452

            l = wx.ALIGN_LEFT

   453

            c = wx.ALIGN_CENTER 

   454

   455

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   456

            self.ColSizes       = [40,  80,     70,     80,     80,     80,     100,     80]

   457

            self.ColAlignements = [c,   l,      l,      l,      l,      l,      l,       l]

   458

   459

        else:

   460

            # this is an element that cannot have located variables

   461

            self.Table = VariableTable(self, [], GetVariableTableColnames(False))

   462

   463

            if element_type == "function":

   464

                self.FilterChoices = ["All",

   465

                                        "Interface", "   Input", "   Output", "   InOut",

   466

                                        "Variables", "   Local"]

   467

            else:

   468

                self.FilterChoices = ["All",

   469

                                        "Interface", "   Input", "   Output", "   InOut", "   External",

   470

                                        "Variables", "   Local", "   Temp"]

   471

   472

            # these condense the ColAlignements list

   473

            l = wx.ALIGN_LEFT

   474

            c = wx.ALIGN_CENTER 

   475

   476

            #                      Num  Name    Class   Type    Init    Option   Doc

   477

            self.ColSizes       = [40,  80,     70,     80,     80,     100,     160]

   478

            self.ColAlignements = [c,   l,      l,      l,      l,      l,       l]

   479

   480

        for choice in self.FilterChoices:

   481

            self.ClassFilter.Append(_(choice))

   482

   483

        reverse_transfer = {}

   484

        for filter, choice in self.FilterChoiceTransfer.items():

   485

            reverse_transfer[choice] = filter

   486

        self.ClassFilter.SetStringSelection(_(reverse_transfer[self.Filter]))

   487

        self.RefreshTypeList()

   488

   489

        self.VariablesGrid.SetTable(self.Table)

   490

        self.VariablesGrid.SetButtons({"Add": self.AddButton,

   491

                                       "Delete": self.DeleteButton,

   492

                                       "Up": self.UpButton,

   493

                                       "Down": self.DownButton})

   494

        self.VariablesGrid.SetEditable(not self.Debug)

   495

   496

        def _AddVariable(new_row):

   497

            if not self.PouIsUsed or self.Filter not in ["Interface", "Input", "Output", "InOut"]:

   498

                row_content = self.DefaultValue.copy()

   499

                if self.Filter in self.DefaultTypes:

   500

                    row_content["Class"] = self.DefaultTypes[self.Filter]

   501

                else:

   502

                    row_content["Class"] = self.Filter

   503

                if self.Filter == "All" and len(self.Values) > 0:

   504

                    self.Values.insert(new_row, row_content)