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):

   236

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

   237

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

   238

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

   239

        message = None

   240

        element_type = self.ParentWindow.ElementType

   241

        try:

   242

            values = eval(data)    

   243

        except:

   244

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

   245

            values = None

   246

        if not isinstance(values, TupleType):

   247

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

   248

            values = None

   249

        if values is not None:

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

                    else:

   258

                        location = values[0]

   259

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

   260

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

   261

                        if location.startswith("%"):

   262

                            if base_type != values[2]:

   263

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

   264

                            else:

   265

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

   266

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

   267

                                self.ParentWindow.SaveValues()

   268

                        else:

   269

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

   270

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

   271

                            elif location[0] not in LOCATIONDATATYPES:

   272

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

   273

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

   274

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

   275

                            else:

   277

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

   278

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

   279

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

   280

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

   281

                                    selected = dialog.GetSelection()

   284

                                dialog.Destroy()

   296

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

   297

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

   298

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

   299

                    else:

   300

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

   301

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

   302

                        self.ParentWindow.SaveValues()

   303

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

   304

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

   305

                if values[1] == "location":

   306

                    var_name = values[3]

   307

                else:

   308

                    var_name = values[0]

   309

                tagname = self.ParentWindow.GetTagName()

   310

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

   311

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

   312

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

   313

                    var_infos = self.ParentWindow.DefaultValue.copy()

   314

                    var_infos["Name"] = var_name

   315

                    var_infos["Type"] = values[2]

   316

                    if values[1] == "location":

   317

                        var_infos["Class"] = "Global"

   318

                        var_infos["Location"] = values[0]

   319

                    else:

   320

                        var_infos["Class"] = "External"

   321

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

   322

                    self.ParentWindow.Values.append(var_infos)

   323

                    self.ParentWindow.SaveValues()

   324

                    self.ParentWindow.RefreshValues()

   325

   326

        if message is not None:

   327

            wx.CallAfter(self.ShowMessage, message)

   328

   329

    def ShowMessage(self, message):

   330

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

   331

        message.ShowModal()

   332

        message.Destroy()

   333

   334

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

   335

#                               Variable Panel

   336

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

   337

   338

class VariablePanel(wx.Panel):

   339

   340

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

   341

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

   342

   343

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

   344

        self.MainSizer.AddGrowableCol(0)

   345

        self.MainSizer.AddGrowableRow(1)

   346

   347

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

   348

        controls_sizer.AddGrowableCol(5)

   349

        controls_sizer.AddGrowableRow(0)

   350

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

   351

   352

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

   353

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

   354

   355

        self.ReturnType = wx.ComboBox(self,

   356

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

   357

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

   358

        controls_sizer.AddWindow(self.ReturnType)

   359

   360

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

   361

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

   362

   363

        self.Description = wx.TextCtrl(self,

   364

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

   365

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

   366

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

   367

        controls_sizer.AddWindow(self.Description) 

   368

   369

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

   370

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

   371

   372

        self.ClassFilter = wx.ComboBox(self, 

   373

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

   374

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

   375

        controls_sizer.AddWindow(self.ClassFilter)

   376

   377

        for name, bitmap, help in [

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

            button.SetToolTipString(help)

   385

            setattr(self, name, button)

   386

            controls_sizer.AddWindow(button)

   387

   388

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

   389

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   390

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

   391

              self.OnVariablesGridCellChange)

   392

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

   393

              self.OnVariablesGridCellLeftClick)

   394

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

   395

              self.OnVariablesGridEditorShown)

   396

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

   397

   398

        self.SetSizer(self.MainSizer)

   399

   400

        self.ParentWindow = window

   401

        self.Controler = controler

   402

        self.ElementType = element_type

   403

        self.Debug = debug

   404

   405

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

   406

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

   407

              self.RefreshHighlightsTimer)

   408

   409

        self.Filter = "All"

   410

        self.FilterChoices = []

   411

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   412

   413

        self.DefaultValue = {

   414

             "Name" : "", 

   415

             "Class" : "", 

   416

             "Type" : "INT", 

   417

             "Location" : "",

   418

              "Initial Value" : "", 

   419

              "Option" : "",

   420

              "Documentation" : "", 

   421

              "Edit" : True

   422

        }

   423

   424

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

   425

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

   426

        else:

   427

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

   428

   429

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

   430

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

   431

            # this is an element that can have located variables

   432

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

   433

   434

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

   435

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

   436

            else:

   437

                self.FilterChoices = ["All",

   438

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

   439

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

   440

   441

            # these condense the ColAlignements list

   442

            l = wx.ALIGN_LEFT

   443

            c = wx.ALIGN_CENTER 

   444

   445

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   446

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

   447

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

   448

   449

        else:

   450

            # this is an element that cannot have located variables

   451

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

   452

   453

            if element_type == "function":

   454

                self.FilterChoices = ["All",

   455

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

   456

                                        "Variables", "   Local"]

   457

            else:

   458

                self.FilterChoices = ["All",

   459

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

   460

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

   461

   462

            # these condense the ColAlignements list

   463

            l = wx.ALIGN_LEFT

   464

            c = wx.ALIGN_CENTER 

   465

   466

            #                      Num  Name    Class   Type    Init    Option   Doc

   467

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

   468

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

   469

   470

        for choice in self.FilterChoices:

   471

            self.ClassFilter.Append(_(choice))

   472

   473

        reverse_transfer = {}

   474

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

   475

            reverse_transfer[choice] = filter

   476

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

   477

        self.RefreshTypeList()

   478

   479

        self.VariablesGrid.SetTable(self.Table)

   480

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

   481

                                       "Delete": self.DeleteButton,

   482

                                       "Up": self.UpButton,

   483

                                       "Down": self.DownButton})

   484

        self.VariablesGrid.SetEditable(not self.Debug)

   485

   486

        def _AddVariable(new_row):

   487

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

   488

                row_content = self.DefaultValue.copy()

   489

                if self.Filter in self.DefaultTypes:

   490

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

   491

                else:

   492

                    row_content["Class"] = self.Filter

   493

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

   494

                    self.Values.insert(new_row, row_content)

   495

                else:

   496

                    self.Values.append(row_content)

   497

                    new_row = self.Table.GetNumberRows()

   498