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"] and values[1] == "Global" and self.ParentWindow.Filter in ["All", "Interface", "External"] or

   302

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

   303

                if values[1] == "location":

   304

                    var_name = values[3]

   305

                else:

   306

                    var_name = values[0]

   307

                tagname = self.ParentWindow.GetTagName()

   308

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

   309

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

   310

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

   311

                    var_infos = self.ParentWindow.DefaultValue.copy()

   312

                    var_infos["Name"] = var_name

   313

                    var_infos["Type"] = values[2]

   314

                    if values[1] == "location":

   315

                        if element_type == "program":

   316

                            var_infos["Class"] = "Local"

   317

                        else:

   318

                            var_infos["Class"] = "Global"

   319

                        var_infos["Location"] = values[0]

   320

                    else:

   321

                        var_infos["Class"] = "External"

   322

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

   323

                    self.ParentWindow.Values.append(var_infos)

   324

                    self.ParentWindow.SaveValues()

   325

                    self.ParentWindow.RefreshValues()

   326

   327

        if message is not None:

   328

            wx.CallAfter(self.ShowMessage, message)

   329

   330

    def ShowMessage(self, message):

   331

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

   332

        message.ShowModal()

   333

        message.Destroy()

   334

   335

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

   336

#                               Variable Panel

   337

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

   338

   339

class VariablePanel(wx.Panel):

   340

   341

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

   342

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

   343

   344

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

   345

        self.MainSizer.AddGrowableCol(0)

   346

        self.MainSizer.AddGrowableRow(1)

   347

   348

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

   349

        controls_sizer.AddGrowableCol(5)

   350

        controls_sizer.AddGrowableRow(0)

   351

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

   352

   353

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

   354

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

   355

   356

        self.ReturnType = wx.ComboBox(self,

   357

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

   358

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

   359

        controls_sizer.AddWindow(self.ReturnType)

   360

   361

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

   362

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

   363

   364

        self.Description = wx.TextCtrl(self,

   365

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

   366

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

   367

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

   368

        controls_sizer.AddWindow(self.Description) 

   369

   370

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

   371

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

   372

   373

        self.ClassFilter = wx.ComboBox(self, 

   374

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

   375

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

   376

        controls_sizer.AddWindow(self.ClassFilter)

   377

   378

        for name, bitmap, help in [

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

            button.SetToolTipString(help)

   386

            setattr(self, name, button)

   387

            controls_sizer.AddWindow(button)

   388

   389

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

   390

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   391

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

   392

              self.OnVariablesGridCellChange)

   393

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

   394

              self.OnVariablesGridCellLeftClick)

   395

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

   396

              self.OnVariablesGridEditorShown)

   397

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

   398

   399

        self.SetSizer(self.MainSizer)

   400

   401

        self.ParentWindow = window

   402

        self.Controler = controler

   403

        self.ElementType = element_type

   404

        self.Debug = debug

   405

   406

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

   407

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

   408

              self.RefreshHighlightsTimer)

   409

   410

        self.Filter = "All"

   411

        self.FilterChoices = []

   412

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   413

   414

        self.DefaultValue = {

   415

             "Name" : "", 

   416

             "Class" : "", 

   417

             "Type" : "INT", 

   418

             "Location" : "",

   419

             "Initial Value" : "", 

   420

             "Option" : "",

   421

             "Documentation" : "", 

   422

             "Edit" : True

   423

        }

   424

   425

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

   426

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

   427

        else:

   428

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

   429

   430

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

   431

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

   432

            # this is an element that can have located variables

   433

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

   434

   435

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

   436

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

   437

            else:

   438

                self.FilterChoices = ["All",

   439

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

   440

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

   441

   442

            # these condense the ColAlignements list

   443

            l = wx.ALIGN_LEFT

   444

            c = wx.ALIGN_CENTER 

   445

   446

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   447

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

   448

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

   449

   450

        else:

   451

            # this is an element that cannot have located variables

   452

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

   453

   454

            if element_type == "function":

   455

                self.FilterChoices = ["All",

   456

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

   457

                                        "Variables", "   Local"]

   458

            else:

   459

                self.FilterChoices = ["All",

   460

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

   461

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

   462

   463

            # these condense the ColAlignements list

   464

            l = wx.ALIGN_LEFT

   465

            c = wx.ALIGN_CENTER 

   466

   467

            #                      Num  Name    Class   Type    Init    Option   Doc

   468

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

   469

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

   470

   471

        for choice in self.FilterChoices:

   472

            self.ClassFilter.Append(_(choice))

   473

   474

        reverse_transfer = {}

   475

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

   476

            reverse_transfer[choice] = filter

   477

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

   478

        self.RefreshTypeList()

   479

   480

        self.VariablesGrid.SetTable(self.Table)

   481

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

   482

                                       "Delete": self.DeleteButton,

   483

                                       "Up": self.UpButton,

   484

                                       "Down": self.DownButton})

   485

        self.VariablesGrid.SetEditable(not self.Debug)

   486

   487

        def _AddVariable(new_row):

   488

            if new_row > 0:

   489

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

   490

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

   491

                if result is not None:

   492

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

   493

                    suffix = result.group(1)

   494

                    if suffix != "":

   495

                        start_idx = int(suffix)

   496

                    else:

   497

                        start_idx = 0

   498

                else:

   499

                    name = row_content["Name"]

   500

                    start_idx = 0

   501

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

   502

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

   503

            else:

   504

                row_content = self.DefaultValue.copy()

   505

                if self.Filter in self.DefaultTypes:

   506

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

   507

                else:

   508

                    row_content["Class"] = self.Filter

   509

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

   510

                self.Values.insert(new_row, row_content)

   511

            else:

   512

                self.Values.append(row_content)

   513

                new_row = self.Table.GetNumberRows()

   514

            self.SaveValues()

   515

            self.RefreshValues()

   516

            return new_row

   517

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

   518

   519

        def _DeleteVariable(row):

   520

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

   521

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

   522

                self.SaveValues()

   523