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 util.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]+)*)))?)$")

    93

    94

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

    95

#                            Variables Panel Table

    96

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

    97

    98

class VariableTable(CustomTable):

    99

   100

    """

   101

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

   102

    """

   103

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

   104

        # The base class must be initialized *first*

   105

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

   106

        self.old_value = None

   107

   108

    def GetValue(self, row, col):

   109

        if row < self.GetNumberRows():

   110

            if col == 0:

   111

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

   112

            colname = self.GetColLabelValue(col, False)

   113

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

   114

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

   115

                if value[0] == "array":

   116

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

   117

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

   118

                value = str(value)

   119

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

   120

                return _(value)

   121

            return value

   122

   123

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

   124

        if col < len(self.colnames):

   125

            colname = self.GetColLabelValue(col, False)

   126

            if colname == "Name":

   127

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

   128

            elif colname == "Class":

   129

                value = VARIABLE_CLASSES_DICT[value]

   130

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

   131

                if value == "External":

   132

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

   133

            elif colname == "Option":

   134

                value = OPTIONS_DICT[value]

   135

            self.data[row][colname] = value

   136

   137

    def GetOldValue(self):

   138

        return self.old_value

   139

   140

    def _updateColAttrs(self, grid):

   141

        """

   142

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

   143

        appropriate renderer given the column name.

   144

   145

        Otherwise default to the default renderer.

   146

        """

   147

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

   148

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

   149

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

   150

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

   151

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

   152

                editor = None

   153

                renderer = None

   154

                colname = self.GetColLabelValue(col, False)

   155

                if self.Parent.Debug:

   156

                    grid.SetReadOnly(row, col, True)

   157

                else:

   158

                    if colname == "Option":

   159

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

   160

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

   161

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

   162

                        if len(options) > 1:

   163

                            editor = wx.grid.GridCellChoiceEditor()

   164

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

   165

                        else:

   166

                            grid.SetReadOnly(row, col, True)

   167

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

   168

                        grid.SetReadOnly(row, col, False)

   169

                        if colname == "Name":

   170

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

   171

                                grid.SetReadOnly(row, col, True)

   172

                            else:

   173

                                editor = wx.grid.GridCellTextEditor()

   174

                                renderer = wx.grid.GridCellStringRenderer()

   175

                        elif colname == "Initial Value":

   176

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

   177

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

   178

                                    editor = wx.grid.GridCellChoiceEditor()

   179

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

   180

                                else:

   181

                                    editor = wx.grid.GridCellTextEditor()

   182

                                renderer = wx.grid.GridCellStringRenderer()

   183

                            else:

   184

                                grid.SetReadOnly(row, col, True)

   185

                        elif colname == "Location":

   186

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

   187

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

   188

                                renderer = wx.grid.GridCellStringRenderer()

   189

                            else:

   190

                                grid.SetReadOnly(row, col, True)

   191

                        elif colname == "Class":

   192

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

   193

                                grid.SetReadOnly(row, col, True)

   194

                            else:

   195

                                editor = wx.grid.GridCellChoiceEditor()

   196

                                excluded = []

   197

                                if self.Parent.PouIsUsed:

   198

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

   199

                                if self.Parent.IsFunctionBlockType(var_type):

   200

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

   201

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

   202

                    elif colname != "Documentation":

   203

                        grid.SetReadOnly(row, col, True)

   204

   205

                grid.SetCellEditor(row, col, editor)

   206

                grid.SetCellRenderer(row, col, renderer)

   207

   208

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

   209

                    highlight_colours = ERROR_HIGHLIGHT

   210

                else:

   211

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

   212

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

   213

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

   214

            self.ResizeRow(grid, row)

   215

   216

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

   217

#                         Variable Panel Drop Target

   218

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

   219

   220

class VariableDropTarget(wx.TextDropTarget):

   221

    '''

   222

    This allows dragging a variable location from somewhere to the Location

   223

    column of a variable row.

   224

   225

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

   226

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

   227

   228

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

   229

    variable to the Location column of the variable panel).

   230

    '''

   231

    def __init__(self, parent):

   232

        wx.TextDropTarget.__init__(self)

   233

        self.ParentWindow = parent

   234

   235

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

   236

        self.ParentWindow.ParentWindow.Select()

   237

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

   238

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

   239

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

   240

        message = None

   241

        element_type = self.ParentWindow.ElementType

   242

        try:

   243

            values = eval(data)    

   244

        except:

   245

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

   246

            values = None

   247

        if not isinstance(values, TupleType):

   248

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

   249

            values = None

   250

        if values is not None:

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

                    else:

   259

                        location = values[0]

   260

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

   261

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

   262

   263

                        if values[2] is not None:

   264

                            base_location_type = self.ParentWindow.Controler.GetBaseType(values[2])

   265

                            if values[2] != variable_type and base_type != base_location_type:

   266

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

   267

   268

                        if message is None:

   269

                            if not location.startswith("%"):

   270

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

   271

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

   272

                                elif location[0] not in LOCATIONDATATYPES:

   273

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

   274

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

   275

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

   276

                                else:

   277

                                    dialog = wx.SingleChoiceDialog(self.ParentWindow.ParentWindow.ParentWindow, 

   278

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

   279

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

   280

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

   281

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

   282

                                        selected = dialog.GetSelection()

   283

                                    else:

   284

                                        selected = None

   285

                                    dialog.Destroy()

   286

                                    if selected is None:

   287

                                        return

   288

                                    if selected == 0:

   289

                                        location = "%I" + location

   290

                                    elif selected == 1:

   291

                                        location = "%Q" + location

   292

                                    else:

   293

                                        location = "%M" + location

   294

   295

                            if message is None:

   296

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

   297

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

   298

                                self.ParentWindow.SaveValues()

   299

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

   300

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

   301

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

   302

                    else:

   303

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

   304

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

   305

                        self.ParentWindow.SaveValues()

   306

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

   307

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

   308

                if values[1] == "location":

   309

                    var_name = values[3]

   310

                else:

   311

                    var_name = values[0]

   312

                tagname = self.ParentWindow.GetTagName()

   313

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

   314

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

   315

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

   316

                    var_infos = self.ParentWindow.DefaultValue.copy()

   317

                    var_infos["Name"] = var_name

   318

                    var_infos["Type"] = values[2]

   319

                    if values[1] == "location":

   320

                        if element_type == "program":

   321

                            var_infos["Class"] = "Local"

   322

                        else:

   323

                            var_infos["Class"] = "Global"

   324

                        var_infos["Location"] = values[0]

   325

                    else:

   326

                        var_infos["Class"] = "External"

   327

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

   328

                    self.ParentWindow.Values.append(var_infos)

   329

                    self.ParentWindow.SaveValues()

   330

                    self.ParentWindow.RefreshValues()

   331

   332

        if message is not None:

   333

            wx.CallAfter(self.ShowMessage, message)

   334

   335

    def ShowMessage(self, message):

   336

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

   337

        message.ShowModal()

   338

        message.Destroy()

   339

   340

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

   341

#                               Variable Panel

   342

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

   343

   344

class VariablePanel(wx.Panel):

   345

   346

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

   347

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

   348

   349

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

   350

        self.MainSizer.AddGrowableCol(0)

   351

        self.MainSizer.AddGrowableRow(1)

   352

   353

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

   354

        controls_sizer.AddGrowableCol(5)

   355

        controls_sizer.AddGrowableRow(0)

   356

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

   357

   358

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

   359

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

   360

   361

        self.ReturnType = wx.ComboBox(self,

   362

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

   363

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

   364

        controls_sizer.AddWindow(self.ReturnType)

   365

   366

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

   367

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

   368

   369

        self.Description = wx.TextCtrl(self,

   370

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

   371

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

   372

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

   373

        controls_sizer.AddWindow(self.Description) 

   374

   375

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

   376

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

   377

   378

        self.ClassFilter = wx.ComboBox(self, 

   379

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

   380

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

   381

        controls_sizer.AddWindow(self.ClassFilter)

   382

   383

        for name, bitmap, help in [

   384

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

   385

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

   386

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

   387

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

   388

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

   389

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

   390

            button.SetToolTipString(help)

   391

            setattr(self, name, button)

   392

            controls_sizer.AddWindow(button)

   393

   394

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

   395

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   396

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

   397

              self.OnVariablesGridCellChange)

   398

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

   399

              self.OnVariablesGridCellLeftClick)

   400

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

   401

              self.OnVariablesGridEditorShown)

   402

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

   403

   404

        self.SetSizer(self.MainSizer)

   405

   406

        self.ParentWindow = window

   407

        self.Controler = controler

   408

        self.ElementType = element_type

   409

        self.Debug = debug

   410

   411

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

   412

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

   413

              self.RefreshHighlightsTimer)

   414

   415

        self.Filter = "All"

   416

        self.FilterChoices = []

   417

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   418

   419

        self.DefaultValue = {

   420

             "Name" : "", 

   421

             "Class" : "", 

   422

             "Type" : "INT", 

   423

             "Location" : "",

   424

             "Initial Value" : "", 

   425

             "Option" : "",

   426

             "Documentation" : "", 

   427

             "Edit" : True

   428

        }

   429

   430

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

   431

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

   432

        else:

   433

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

   434

   435

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

   436

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

   437

            # this is an element that can have located variables

   438

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

   439

   440

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

   441

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

   442

            else:

   443

                self.FilterChoices = ["All",

   444

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

   445

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

   446

   447

            # these condense the ColAlignements list

   448

            l = wx.ALIGN_LEFT

   449

            c = wx.ALIGN_CENTER 

   450

   451

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   452

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

   453

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

   454

   455

        else:

   456

            # this is an element that cannot have located variables

   457

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

   458

   459

            if element_type == "function":

   460

                self.FilterChoices = ["All",

   461

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

   462

                                        "Variables", "   Local"]

   463

            else:

   464

                self.FilterChoices = ["All",

   465

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

   466

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

   467

   468

            # these condense the ColAlignements list

   469

            l = wx.ALIGN_LEFT

   470

            c = wx.ALIGN_CENTER 

   471

   472

            #                      Num  Name    Class   Type    Init    Option   Doc

   473

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

   474

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

   475

   476

        for choice in self.FilterChoices:

   477

            self.ClassFilter.Append(_(choice))

   478

   479

        reverse_transfer = {}

   480

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

   481

            reverse_transfer[choice] = filter

   482

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

   483

        self.RefreshTypeList()

   484

   485

        self.VariablesGrid.SetTable(self.Table)

   486

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

   487

                                       "Delete": self.DeleteButton,

   488

                                       "Up": self.UpButton,

   489

                                       "Down": self.DownButton})

   490

        self.VariablesGrid.SetEditable(not self.Debug)

   491

   492

        def _AddVariable(new_row):

   493

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

   509

                else:

   515

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

   516

                    self.Values.insert(new_row, row_content)

   517

                else:

   518

                    self.Values.append(row_content)

   519

                    new_row = self.Table.GetNumberRows()

   520

                self.SaveValues()

   521

                self.RefreshValues()

   522

                return new_row

   523

            return self.VariablesGrid.GetGridCursorRow()

   524

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