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 re

    27

from types import TupleType, StringType, UnicodeType

    28

    29

import wx

    30

import wx.grid

    31

import wx.lib.buttons

    32

    33

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS

    34

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

    35

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    36

from CustomGrid import CustomGrid

    37

from CustomTable import CustomTable

    38

from LocationCellEditor import LocationCellEditor

    39

from utils.BitmapLibrary import GetBitmap

    40

    41

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

    42

#                                 Helpers

    43

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

    44

    45

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

    46

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

    47

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

    48

    else:

    49

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

    50

    51

[TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE, 

    52

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    53

] = range(10)

    54

    55

def GetVariableTableColnames(location):

    56

    _ = lambda x : x

    57

    if location:

    58

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

    59

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

    60

    61

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

    62

    _ = lambda x : x

    63

    options = [""]

    64

    if constant:

    65

        options.append(_("Constant"))

    66

    if retain:

    67

        options.append(_("Retain"))

    68

    if non_retain:

    69

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

    70

    return options

    71

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

    72

    73

def GetFilterChoiceTransfer():

    74

    _ = lambda x : x

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

    82

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

    83

                       "Temp": lambda x: "",

    84

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

    85

                       "InOut": lambda x: "",

    86

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

    87

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

    88

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

    89

                      }

    90

    91

LOCATION_MODEL = re.compile("((?:%[IQM](?:\*|(?:[XBWLD]?[0-9]+(?:\.[0-9]+)*)))?)$")

    92

    93

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

    94

#                            Variables Panel Table

    95

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

    96

    97

class VariableTable(CustomTable):

    98

    99

    """

   100

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

   101

    """

   102

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

   103

        # The base class must be initialized *first*

   104

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

   105

        self.old_value = None

   106

   107

    def GetValue(self, row, col):

   108

        if row < self.GetNumberRows():

   109

            if col == 0:

   110

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

   111

            colname = self.GetColLabelValue(col, False)

   112

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

   113

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

   114

                if value[0] == "array":

   115

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

   116

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

   117

                value = str(value)

   118

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

   119

                return _(value)

   120

            return value

   121

   122

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

   123

        if col < len(self.colnames):

   124

            colname = self.GetColLabelValue(col, False)

   125

            if colname == "Name":

   126

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

   127

            elif colname == "Class":

   128

                value = VARIABLE_CLASSES_DICT[value]

   129

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

   130

                if value == "External":

   131

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

   132

            elif colname == "Option":

   133

                value = OPTIONS_DICT[value]

   134

            self.data[row][colname] = value

   135

   136

    def GetOldValue(self):

   137

        return self.old_value

   138

   139

    def _updateColAttrs(self, grid):

   140

        """

   141

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

   142

        appropriate renderer given the column name.

   143

   144

        Otherwise default to the default renderer.

   145

        """

   146

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

   147

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

   148

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

   149

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

   150

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

   151

                editor = None

   152

                renderer = None

   153

                colname = self.GetColLabelValue(col, False)

   154

                if self.Parent.Debug:

   155

                    grid.SetReadOnly(row, col, True)

   156

                else:

   157

                    if colname == "Option":

   158

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

   159

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

   160

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

   161

                        if len(options) > 1:

   162

                            editor = wx.grid.GridCellChoiceEditor()

   163

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

   164

                        else:

   165

                            grid.SetReadOnly(row, col, True)

   166

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

   167

                        grid.SetReadOnly(row, col, False)

   168

                        if colname == "Name":

   169

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

   170

                                grid.SetReadOnly(row, col, True)

   171

                            else:

   172

                                editor = wx.grid.GridCellTextEditor()

   173

                                renderer = wx.grid.GridCellStringRenderer()

   174

                        elif colname == "Initial Value":

   175

                            if var_class not in ["External", "InOut"]:

   176

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

   177

                                    editor = wx.grid.GridCellChoiceEditor()

   178

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

   179

                                else:

   180

                                    editor = wx.grid.GridCellTextEditor()

   181

                                renderer = wx.grid.GridCellStringRenderer()

   182

                            else:

   183

                                grid.SetReadOnly(row, col, True)

   184

                        elif colname == "Location":

   185

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

   186

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

   187

                                renderer = wx.grid.GridCellStringRenderer()

   188

                            else:

   189

                                grid.SetReadOnly(row, col, True)

   190

                        elif colname == "Class":

   191

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

   192

                                grid.SetReadOnly(row, col, True)

   193

                            else:

   194

                                editor = wx.grid.GridCellChoiceEditor()

   195

                                excluded = []

   196

                                if self.Parent.PouIsUsed:

   197

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

   198

                                if self.Parent.IsFunctionBlockType(var_type):

   199

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

   200

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

   201

                    elif colname != "Documentation":

   202

                        grid.SetReadOnly(row, col, True)

   203

   204

                grid.SetCellEditor(row, col, editor)

   205

                grid.SetCellRenderer(row, col, renderer)

   206

   207

                if colname == "Location" and LOCATION_MODEL.match(self.GetValueByName(row, "Location")) is None:

   208

                    highlight_colours = ERROR_HIGHLIGHT

   209

                else:

   210

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

   211

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

   212

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

   213

            self.ResizeRow(grid, row)

   214

   215

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

   216

#                         Variable Panel Drop Target

   217

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

   218

   219

class VariableDropTarget(wx.TextDropTarget):

   220

    '''

   221

    This allows dragging a variable location from somewhere to the Location

   222

    column of a variable row.

   223

   224

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

   225

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

   226

   227

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

   228

    variable to the Location column of the variable panel).

   229

    '''

   230

    def __init__(self, parent):

   231

        wx.TextDropTarget.__init__(self)

   232

        self.ParentWindow = parent

   233

   234

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

   235

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

   236

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

   237

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

   238

        message = None

   239

        element_type = self.ParentWindow.ElementType

   240

        try:

   241

            values = eval(data)    

   242

        except:

   243

            message = _("Invalid value \"%s\" for variable grid element")%data

   244

            values = None

   245

        if not isinstance(values, TupleType):

   246

            message = _("Invalid value \"%s\" for variable grid element")%data

   247

            values = None

   248

        if values is not None:

   249

            if col != wx.NOT_FOUND and row != wx.NOT_FOUND:

   250

                colname = self.ParentWindow.Table.GetColLabelValue(col, False)

   251

                if colname == "Location" and values[1] == "location":

   252

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   253

                        message = _("Can't give a location to a function block instance")

   254

                    elif self.ParentWindow.Table.GetValueByName(row, "Class") not in ["Local", "Global"]:

   255

                        message = _("Can only give a location to local or global variables")

   256

                    else:

   257

                        location = values[0]

   258

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

   259

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

   260

                        if location.startswith("%"):

   261

                            if base_type != values[2]:

   262

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

   263

                            else:

   264

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

   265

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

   266

                                self.ParentWindow.SaveValues()

   267

                        else:

   268

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

   269

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

   270

                            elif location[0] not in LOCATIONDATATYPES:

   271

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

   272

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

   273

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

   274

                            else:

   275

                                dialog = wx.SingleChoiceDialog(self.ParentWindow, 

   276

                                      _("Select a variable class:"), _("Variable class"), 

   277

                                      ["Input", "Output", "Memory"], 

   278

                                      wx.DEFAULT_DIALOG_STYLE|wx.OK|wx.CANCEL)

   279

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

   280

                                    selected = dialog.GetSelection()

   281

                                    if selected == 0:

   282

                                        location = "%I" + location

   283

                                    elif selected == 1:

   284

                                        location = "%Q" + location

   285

                                    else:

   286

                                        location = "%M" + location

   287

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

   288

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

   289

                                    self.ParentWindow.SaveValues()

   290

                                dialog.Destroy()

   291

                elif colname == "Initial Value" and values[1] == "Constant":

   292

                    if not self.ParentWindow.Table.GetValueByName(row, "Edit"):

   293

                        message = _("Can't set an initial value to a function block instance")

   294

                    else:

   295

                        self.ParentWindow.Table.SetValue(row, col, values[0])

   296

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

   297

                        self.ParentWindow.SaveValues()

   298

            elif (element_type not in ["config", "resource"] and values[1] == "Global" and self.ParentWindow.Filter in ["All", "Interface", "External"] or

   299

                  element_type in ["config", "resource"] and values[1] == "location"):

   300

                if values[1] == "location":

   301

                    var_name = values[3]

   302

                else:

   303

                    var_name = values[0]

   304

                tagname = self.ParentWindow.GetTagName()

   305

                if var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   306

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

   307

                elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   308

                    var_infos = self.ParentWindow.DefaultValue.copy()

   309

                    var_infos["Name"] = var_name

   310

                    var_infos["Type"] = values[2]

   311

                    if values[1] == "location":

   312

                        var_infos["Class"] = "Global"

   313

                        var_infos["Location"] = values[0]

   314

                    else:

   315

                        var_infos["Class"] = "External"

   316

                    var_infos["Number"] = len(self.ParentWindow.Values)

   317

                    self.ParentWindow.Values.append(var_infos)

   318

                    self.ParentWindow.SaveValues()

   319

                    self.ParentWindow.RefreshValues()

   320

   321

        if message is not None:

   322

            wx.CallAfter(self.ShowMessage, message)

   323

   324

    def ShowMessage(self, message):

   325

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

   326

        message.ShowModal()

   327

        message.Destroy()

   328

   329

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

   330

#                               Variable Panel

   331

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

   332

   333

class VariablePanel(wx.Panel):

   334

   335

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

   336

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

   337

   338

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

   339

        self.MainSizer.AddGrowableCol(0)

   340

        self.MainSizer.AddGrowableRow(1)

   341

   342

        controls_sizer = wx.FlexGridSizer(cols=10, hgap=5, rows=1, vgap=5)

   343

        controls_sizer.AddGrowableCol(5)

   344

        controls_sizer.AddGrowableRow(0)

   345

        self.MainSizer.AddSizer(controls_sizer, border=5, flag=wx.GROW|wx.ALL)

   346

   347

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

   348

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

   349

   350

        self.ReturnType = wx.ComboBox(self,

   351

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   352

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

   353

        controls_sizer.AddWindow(self.ReturnType)

   354

   355

        self.DescriptionLabel = wx.StaticText(self, label=_('Description:'))

   356

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

   357

   358

        self.Description = wx.TextCtrl(self,

   359

              size=wx.Size(250, -1), style=wx.TE_PROCESS_ENTER)

   360

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

   361

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

   362

        controls_sizer.AddWindow(self.Description) 

   363

   364

        class_filter_label = wx.StaticText(self, label=_('Class Filter:'))

   365

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

   366

   367

        self.ClassFilter = wx.ComboBox(self, 

   368

              size=wx.Size(145, -1), style=wx.CB_READONLY)

   369

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

   370

        controls_sizer.AddWindow(self.ClassFilter)

   371

   372

        for name, bitmap, help in [

   373

                ("AddButton", "add_element", _("Add variable")),

   374

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

   375

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

   376

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

   377

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

   378

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

   379

            button.SetToolTipString(help)

   380

            setattr(self, name, button)

   381

            controls_sizer.AddWindow(button)

   382

   383

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

   384

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   385

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

   386

              self.OnVariablesGridCellChange)

   387

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

   388

              self.OnVariablesGridCellLeftClick)

   389

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

   390

              self.OnVariablesGridEditorShown)

   391

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

   392

   393

        self.SetSizer(self.MainSizer)

   394

   395

        self.ParentWindow = window

   396

        self.Controler = controler

   397

        self.ElementType = element_type

   398

        self.Debug = debug

   399

   400

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

   401

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

   402

              self.RefreshHighlightsTimer)

   403

   404

        self.Filter = "All"

   405

        self.FilterChoices = []

   406

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   407

   408

        self.DefaultValue = {

   409

             "Name" : "", 

   410

             "Class" : "", 

   411

             "Type" : "INT", 

   412

             "Location" : "",

   413

              "Initial Value" : "", 

   414

              "Option" : "",

   415

              "Documentation" : "", 

   416

              "Edit" : True

   417

        }

   418

   419

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

   420

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

   421

        else:

   422

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

   423

   424

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

   425

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

   426

            # this is an element that can have located variables

   427

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

   428

   429

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

   430

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

   431

            else:

   432

                self.FilterChoices = ["All",

   433

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

   434

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

   435

   436

            # these condense the ColAlignements list

   437

            l = wx.ALIGN_LEFT

   438

            c = wx.ALIGN_CENTER 

   439

   440

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   441

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

   442

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

   443

   444

        else:

   445

            # this is an element that cannot have located variables

   446

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

   447

   448

            if element_type == "function":

   449

                self.FilterChoices = ["All",

   450

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

   451

                                        "Variables", "   Local"]

   452

            else:

   453

                self.FilterChoices = ["All",

   454

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

   455

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

   456

   457

            # these condense the ColAlignements list

   458

            l = wx.ALIGN_LEFT

   459

            c = wx.ALIGN_CENTER 

   460

   461

            #                      Num  Name    Class   Type    Init    Option   Doc

   462

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

   463

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

   464

   465

        for choice in self.FilterChoices:

   466

            self.ClassFilter.Append(_(choice))

   467

   468

        reverse_transfer = {}

   469

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

   470

            reverse_transfer[choice] = filter

   471

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

   472

        self.RefreshTypeList()

   473

   474

        self.VariablesGrid.SetTable(self.Table)

   475

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

   476

                                       "Delete": self.DeleteButton,

   477

                                       "Up": self.UpButton,

   478

                                       "Down": self.DownButton})

   479

        self.VariablesGrid.SetEditable(not self.Debug)

   480

   481

        def _AddVariable(new_row):

   482

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

   483

                row_content = self.DefaultValue.copy()

   484

                if self.Filter in self.DefaultTypes:

   485

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

   486

                else:

   487

                    row_content["Class"] = self.Filter

   488

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

   489

                    self.Values.insert(new_row, row_content)

   490

                else:

   491

                    self.Values.append(row_content)

   492

                    new_row = self.Table.GetNumberRows()

   493

                self.SaveValues()

   494

                self.RefreshValues()

   495

                return new_row

   496

            return self.VariablesGrid.GetGridCursorRow()

   497

        setattr(self.VariablesGrid, "_AddRow", _AddVariable)

   498