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

    92

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([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

                            editor = wx.grid.GridCellTextEditor()

   171

                            renderer = wx.grid.GridCellStringRenderer()

   172

                        elif colname == "Initial Value":

   173

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

   174

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

   175

                                    editor = wx.grid.GridCellChoiceEditor()

   176

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

   177

                                else:

   178

                                    editor = wx.grid.GridCellTextEditor()

   179

                                renderer = wx.grid.GridCellStringRenderer()

   180

                            else:

   181

                                grid.SetReadOnly(row, col, True)

   182

                        elif colname == "Location":

   183

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

   184

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

   185

                                renderer = wx.grid.GridCellStringRenderer()

   186

                            else:

   187

                                grid.SetReadOnly(row, col, True)

   188

                        elif colname == "Class":

   189

                            if len(self.Parent.ClassList) == 1:

   190

                                grid.SetReadOnly(row, col, True)

   191

                            else:

   192

                                editor = wx.grid.GridCellChoiceEditor()

   193

                                excluded = []

   194

                                if self.Parent.IsFunctionBlockType(var_type):

   195

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

   196

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

   197

                    elif colname != "Documentation":

   198

                        grid.SetReadOnly(row, col, True)

   199

   200

                grid.SetCellEditor(row, col, editor)

   201

                grid.SetCellRenderer(row, col, renderer)

   202

   203

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

   204

                    highlight_colours = ERROR_HIGHLIGHT

   205

                else:

   206

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

   207

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

   208

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

   209

            self.ResizeRow(grid, row)

   210

   211

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

   212

#                         Variable Panel Drop Target

   213

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

   214

   215

class VariableDropTarget(wx.TextDropTarget):

   216

    '''

   217

    This allows dragging a variable location from somewhere to the Location

   218

    column of a variable row.

   219

   220

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

   221

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

   222

   223

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

   224

    variable to the Location column of the variable panel).

   225

    '''

   226

    def __init__(self, parent):

   227

        wx.TextDropTarget.__init__(self)

   228

        self.ParentWindow = parent

   229

   230

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

   231

        self.ParentWindow.ParentWindow.Select()

   232

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

   233

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

   234

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

   235

        message = None

   236

        element_type = self.ParentWindow.ElementType

   237

        try:

   238

            values = eval(data)    

   239

        except:

   240

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

   241

            values = None

   242

        if not isinstance(values, TupleType):

   243

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

   244

            values = None

   245

        if values is not None:

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

                    else:

   254

                        location = values[0]

   255

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

   256

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

   257

   258

                        if values[2] is not None:

   259

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

   260

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

   261

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

   262

   263

                        if message is None:

   264

                            if not location.startswith("%"):

   265

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

   266

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

   267

                                elif location[0] not in LOCATIONDATATYPES:

   268

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

   269

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

   270

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

   271

                                else:

   272

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

   273

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

   274

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

   275

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

   276

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

   277

                                        selected = dialog.GetSelection()

   278

                                    else:

   279

                                        selected = None

   280

                                    dialog.Destroy()

   281

                                    if selected is None:

   282

                                        return

   283

                                    if selected == 0:

   284

                                        location = "%I" + location

   285

                                    elif selected == 1:

   286

                                        location = "%Q" + location

   287

                                    else:

   288

                                        location = "%M" + location

   289

   290

                            if message is None:

   291

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

   292

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

   293

                                self.ParentWindow.SaveValues()

   294

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

   295

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

   296

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

   297

                    else:

   298

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

   299

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

   300

                        self.ParentWindow.SaveValues()

   301

            elif (element_type not in ["config", "resource", "function"] and values[1] == "Global" and 

   302

                  self.ParentWindow.Filter in ["All", "Interface", "External"] or

   303

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

   304

                if values[1] == "location":

   305

                    var_name = values[3]

   306

                else:

   307

                    var_name = values[0]

   308

                tagname = self.ParentWindow.GetTagName()

   309

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

   310

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

   311

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

   312

                    var_infos = self.ParentWindow.DefaultValue.copy()

   313

                    var_infos["Name"] = var_name

   314

                    var_infos["Type"] = values[2]

   315

                    if values[1] == "location":

   316

                        if element_type == "program":

   317

                            var_infos["Class"] = "Local"

   318

                        else:

   319

                            var_infos["Class"] = "Global"

   320

                        var_infos["Location"] = values[0]

   321

                    else:

   322

                        var_infos["Class"] = "External"

   323

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

   324

                    self.ParentWindow.Values.append(var_infos)

   325

                    self.ParentWindow.SaveValues()

   326

                    self.ParentWindow.RefreshValues()

   327

   328

        if message is not None:

   329

            wx.CallAfter(self.ShowMessage, message)

   330

   331

    def ShowMessage(self, message):

   332

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

   333

        message.ShowModal()

   334

        message.Destroy()

   335

   336

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

   337

#                               Variable Panel

   338

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

   339

   340

class VariablePanel(wx.Panel):

   341

   342

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

   343

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

   344

   345

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

   346

        self.MainSizer.AddGrowableCol(0)

   347

        self.MainSizer.AddGrowableRow(1)

   348

   349

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

   350

        controls_sizer.AddGrowableCol(5)

   351

        controls_sizer.AddGrowableRow(0)

   352

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

   353

   354

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

   355

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

   356

   357

        self.ReturnType = wx.ComboBox(self,

   358

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

   359

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

   360

        controls_sizer.AddWindow(self.ReturnType)

   361

   362

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

   363

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

   364

   365

        self.Description = wx.TextCtrl(self,

   366

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

   367

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

   368

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

   369

        controls_sizer.AddWindow(self.Description) 

   370

   371

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

   372

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

   373

   374

        self.ClassFilter = wx.ComboBox(self, 

   375

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

   376

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

   377

        controls_sizer.AddWindow(self.ClassFilter)

   378

   379

        for name, bitmap, help in [

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

            button.SetToolTipString(help)

   387

            setattr(self, name, button)

   388

            controls_sizer.AddWindow(button)

   389

   390

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

   391

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   392

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

   393

              self.OnVariablesGridCellChange)

   394

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

   395

              self.OnVariablesGridCellLeftClick)

   396

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

   397

              self.OnVariablesGridEditorShown)

   398

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

   399

   400

        self.SetSizer(self.MainSizer)

   401

   402

        self.ParentWindow = window

   403

        self.Controler = controler

   404

        self.ElementType = element_type

   405

        self.Debug = debug

   406

   407

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

   408

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

   409

              self.RefreshHighlightsTimer)

   410

   411

        self.Filter = "All"

   412

        self.FilterChoices = []

   413

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   414

   415

        self.DefaultValue = {

   416

             "Name" : "", 

   417

             "Class" : "", 

   418

             "Type" : "INT", 

   419

             "Location" : "",

   420

             "Initial Value" : "", 

   421

             "Option" : "",

   422

             "Documentation" : "", 

   423

             "Edit" : True

   424

        }

   425

   426

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

   427

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

   428

        else:

   429

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

   430

   431

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

   432

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

   433

            # this is an element that can have located variables

   434

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

   435

   436

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

   437

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

   438

            else:

   439

                self.FilterChoices = ["All",

   440

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

   441

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

   442

   443

            # these condense the ColAlignements list

   444

            l = wx.ALIGN_LEFT

   445

            c = wx.ALIGN_CENTER 

   446

   447

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   448

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

   449

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

   450

   451

        else:

   452

            # this is an element that cannot have located variables

   453

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

   454

   455

            if element_type == "function":

   456

                self.FilterChoices = ["All",

   457

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

   458

                                        "Variables", "   Local"]

   459

            else:

   460

                self.FilterChoices = ["All",

   461

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

   462

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

   463

   464

            # these condense the ColAlignements list

   465

            l = wx.ALIGN_LEFT

   466

            c = wx.ALIGN_CENTER 

   467

   468

            #                      Num  Name    Class   Type    Init    Option   Doc

   469

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

   470

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

   471

   472

        for choice in self.FilterChoices:

   473

            self.ClassFilter.Append(_(choice))

   474

   475

        reverse_transfer = {}

   476

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

   477

            reverse_transfer[choice] = filter

   478

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

   479

        self.RefreshTypeList()

   480

   481

        self.VariablesGrid.SetTable(self.Table)

   482

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

   483

                                       "Delete": self.DeleteButton,

   484

                                       "Up": self.UpButton,

   485

                                       "Down": self.DownButton})

   486

        self.VariablesGrid.SetEditable(not self.Debug)

   487

   488

        def _AddVariable(new_row):

   489

            if new_row > 0:

   490

                row_content = self.Values[new_row - 1].copy()

   491

                result = VARIABLE_NAME_SUFFIX_MODEL.search(row_content["Name"])

   492

                if result is not None:

   493

                    name = row_content["Name"][:result.start(1)]

   494

                    suffix = result.group(1)

   495

                    if suffix != "":

   496

                        start_idx = int(suffix)

   497

                    else:

   498

                        start_idx = 0

   499

                else:

   500

                    name = row_content["Name"]

   501

                    start_idx = 0

   502

                row_content["Name"] = self.Controler.GenerateNewName(

   503

                    self.TagName, None, name + "%d", start_idx)

   504

            else:

   505

                row_content = self.DefaultValue.copy()

   506

                if self.Filter in self.DefaultTypes:

   507

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

   508

                else:

   509

                    row_content["Class"] = self.Filter

   510

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

   511

                self.Values.insert(new_row, row_content)

   512

            else:

   513

                self.Values.append(row_content)

   514

                new_row = self.Table.GetNumberRows()

   515

            self.SaveValues()

   516

            self.RefreshValues()

   517

            return new_row

   518

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

   519

   520

        def _DeleteVariable(row):

   521

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

   522

                self.Values.remove(self.Table.GetRow(row))