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 wx, wx.grid

    27

    28

from types import TupleType, StringType, UnicodeType

    29

    30

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS

    31

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD

    32

from dialogs.ArrayTypeDialog import ArrayTypeDialog

    33

from CustomGrid import CustomGrid

    35

from LocationCellEditor import LocationCellEditor

    36

    37

# Compatibility function for wx versions < 2.6

    38

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

    39

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

    40

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

    41

    else:

    42

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

    43

    44

[TITLE, TOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, TYPESTREE, 

    45

 INSTANCESTREE, LIBRARYTREE, SCALING

    46

] = range(9)

    47

    48

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

    49

#                            Variables Editor Panel

    50

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

    51

    52

def GetVariableTableColnames(location):

    53

    _ = lambda x : x

    54

    if location:

    55

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

    56

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

    57

    58

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

    59

    _ = lambda x : x

    60

    options = [""]

    61

    if constant:

    62

        options.append(_("Constant"))

    63

    if retain:

    64

        options.append(_("Retain"))

    65

    if non_retain:

    66

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

    67

    return options

    68

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

    69

    70

def GetFilterChoiceTransfer():

    71

    _ = lambda x : x

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

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

    80

                       "Temp": lambda x: "",

    81

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

    82

                       "InOut": lambda x: "",

    83

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

    84

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

    85

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

    86

                      }

    87

    89

    90

    """

    91

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

    92

    """

    93

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

    94

        # The base class must be initialized *first*

    96

        self.old_value = None

    98

    def GetValue(self, row, col):

    99

        if row < self.GetNumberRows():

   100

            if col == 0:

   101

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

   102

            colname = self.GetColLabelValue(col, False)

   103

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

   104

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

   105

                if value[0] == "array":

   106

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

   107

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

   108

                value = str(value)

   109

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

   110

                return _(value)

   111

            return value

   112

   113

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

   114

        if col < len(self.colnames):

   115

            colname = self.GetColLabelValue(col, False)

   116

            if colname == "Name":

   117

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

   118

            elif colname == "Class":

   119

                value = VARIABLE_CLASSES_DICT[value]

   120

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

   121

                if value == "External":

   122

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

   123

            elif colname == "Option":

   124

                value = OPTIONS_DICT[value]

   125

            self.data[row][colname] = value

   126

   127

    def GetOldValue(self):

   128

        return self.old_value

   129

   130

    def _updateColAttrs(self, grid):

   131

        """

   132

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

   133

        appropriate renderer given the column name.

   134

   135

        Otherwise default to the default renderer.

   136

        """

   137

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

   138

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

   139

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

   140

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

   141

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

   142

                editor = None

   143

                renderer = None

   144

                colname = self.GetColLabelValue(col, False)

   145

                if self.Parent.Debug:

   146

                    grid.SetReadOnly(row, col, True)

   147

                else:

   148

                    if colname == "Option":

   149

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

   150

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

   151

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

   152

                        if len(options) > 1:

   153

                            editor = wx.grid.GridCellChoiceEditor()

   154

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

   155

                        else:

   156

                            grid.SetReadOnly(row, col, True)

   157

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

   158

                        grid.SetReadOnly(row, col, False)

   159

                        if colname == "Name":

   160

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

   161

                                grid.SetReadOnly(row, col, True)

   162

                            else:

   163

                                editor = wx.grid.GridCellTextEditor()

   164

                                renderer = wx.grid.GridCellStringRenderer()

   165

                        elif colname == "Initial Value":

   166

                            if var_class != "External":

   167

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

   168

                                    editor = wx.grid.GridCellChoiceEditor()

   169

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

   170

                                else:

   171

                                    editor = wx.grid.GridCellTextEditor()

   172

                                renderer = wx.grid.GridCellStringRenderer()

   173

                            else:

   174

                                grid.SetReadOnly(row, col, True)

   175

                        elif colname == "Location":

   176

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

   177

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

   178

                                renderer = wx.grid.GridCellStringRenderer()

   179

                            else:

   180

                                grid.SetReadOnly(row, col, True)

   181

                        elif colname == "Class":

   182

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

   183

                                grid.SetReadOnly(row, col, True)

   184

                            else:

   185

                                editor = wx.grid.GridCellChoiceEditor()

   186

                                excluded = []

   187

                                if self.Parent.PouIsUsed:

   188

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

   189

                                if self.Parent.IsFunctionBlockType(var_type):

   190

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

   191

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

   192

                    elif colname != "Documentation":

   193

                        grid.SetReadOnly(row, col, True)

   194

   195

                grid.SetCellEditor(row, col, editor)

   196

                grid.SetCellRenderer(row, col, renderer)

   197

   198

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

   199

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

   200

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

   202

   203

   204

class VariableDropTarget(wx.TextDropTarget):

   205

    '''

   206

    This allows dragging a variable location from somewhere to the Location

   207

    column of a variable row.

   208

   209

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

   210

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

   211

   212

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

   213

    variable to the Location column of the variable panel).

   214

    '''

   215

    def __init__(self, parent):

   216

        wx.TextDropTarget.__init__(self)

   217

        self.ParentWindow = parent

   218

   219

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

   220

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

   221

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

   222

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

   223

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

   224

            if self.ParentWindow.Table.GetColLabelValue(col, False) != "Location":

   225

                return

   226

            message = None

   227

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

   228

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

   229

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

   230

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

   231

            else:

   232

                try:

   233

                    values = eval(data)    

   234

                except:

   235

                    message = _("Invalid value \"%s\" for location")%data

   236

                    values = None

   237

                if not isinstance(values, TupleType):

   238

                    message = _("Invalid value \"%s\" for location")%data

   239

                    values = None

   240

                if values is not None and values[1] == "location":

   241

                    location = values[0]

   242

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

   243

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

   244

                    message = None

   245

                    if location.startswith("%"):

   246

                        if base_type != values[2]:

   247

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

   248

                        else:

   249

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

   250

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

   251

                            self.ParentWindow.SaveValues()

   252

                    else:

   253

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

   254

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

   255

                        elif location[0] not in LOCATIONDATATYPES:

   256

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

   257

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

   258

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

   259

                        else:

   260

                            dialog = wx.SingleChoiceDialog(self.ParentWindow, _("Select a variable class:"), _("Variable class"), ["Input", "Output", "Memory"], wx.OK|wx.CANCEL)

   261

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

   262

                                selected = dialog.GetSelection()

   263

                                if selected == 0:

   264

                                    location = "%I" + location

   265

                                elif selected == 1:

   266

                                    location = "%Q" + location

   267

                                else:

   268

                                    location = "%M" + location

   269

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

   270

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

   271

                                self.ParentWindow.SaveValues()

   272

                            dialog.Destroy()

   273

            if message is not None:

   274

                wx.CallAfter(self.ShowMessage, message)

   275

   276

    def ShowMessage(self, message):

   277

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

   278

        message.ShowModal()

   279

        message.Destroy()

   280

   281

[ID_VARIABLEEDITORPANEL, ID_VARIABLEEDITORPANELVARIABLESGRID, 

   282

 ID_VARIABLEEDITORCONTROLPANEL, ID_VARIABLEEDITORPANELRETURNTYPE, 

   283

 ID_VARIABLEEDITORPANELCLASSFILTER, ID_VARIABLEEDITORPANELADDBUTTON, 

   284

 ID_VARIABLEEDITORPANELDELETEBUTTON, ID_VARIABLEEDITORPANELUPBUTTON, 

   285

 ID_VARIABLEEDITORPANELDOWNBUTTON, ID_VARIABLEEDITORPANELSTATICTEXT1, 

   286

 ID_VARIABLEEDITORPANELSTATICTEXT2, ID_VARIABLEEDITORPANELSTATICTEXT3,

   287

] = [wx.NewId() for _init_ctrls in range(12)]

   288

   289

class VariablePanel(wx.Panel):

   290

   291

    if wx.VERSION < (2, 6, 0):

   292

        def Bind(self, event, function, id = None):

   293

            if id is not None:

   294

                event(self, id, function)

   295

            else:

   296

                event(self, function)

   297

   298

    def _init_coll_MainSizer_Items(self, parent):

   299

        parent.AddWindow(self.ControlPanel, 0, border=5, flag=wx.GROW|wx.ALL)

   300

        parent.AddWindow(self.VariablesGrid, 0, border=0, flag=wx.GROW)

   301

   302

    def _init_coll_MainSizer_Growables(self, parent):

   303

        parent.AddGrowableCol(0)

   304

        parent.AddGrowableRow(1)

   305

   306

    def _init_coll_ControlPanelSizer_Items(self, parent):

   307

        parent.AddWindow(self.staticText1, 0, border=0, flag=wx.ALIGN_CENTER_VERTICAL)

   308

        parent.AddWindow(self.ReturnType, 0, border=0, flag=0)

   309

        parent.AddWindow(self.staticText2, 0, border=0, flag=wx.ALIGN_CENTER_VERTICAL)

   310

        parent.AddWindow(self.ClassFilter, 0, border=0, flag=0)

   311

        parent.AddWindow(self.AddButton, 0, border=0, flag=0)

   312

        parent.AddWindow(self.DeleteButton, 0, border=0, flag=0)

   313

        parent.AddWindow(self.UpButton, 0, border=0, flag=0)

   314

        parent.AddWindow(self.DownButton, 0, border=0, flag=0)

   315

   316

    def _init_coll_ControlPanelSizer_Growables(self, parent):

   317

        parent.AddGrowableCol(3)

   318

        parent.AddGrowableRow(0)

   319

   320

    def _init_sizers(self):

   321

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

   322

        self.ControlPanelSizer = wx.FlexGridSizer(cols=8, hgap=5, rows=1, vgap=5)

   323

   324

        self._init_coll_MainSizer_Items(self.MainSizer)

   325

        self._init_coll_MainSizer_Growables(self.MainSizer)

   326

        self._init_coll_ControlPanelSizer_Items(self.ControlPanelSizer)

   327

        self._init_coll_ControlPanelSizer_Growables(self.ControlPanelSizer)

   328

   329

        self.ControlPanel.SetSizer(self.ControlPanelSizer)

   330

        self.SetSizer(self.MainSizer)

   331

   332

    def _init_ctrls(self, prnt):

   333

        wx.Panel.__init__(self, id=ID_VARIABLEEDITORPANEL,

   334

              name='VariableEditorPanel', parent=prnt, pos=wx.Point(0, 0),

   335

              size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

   336

   337

        self.VariablesGrid = CustomGrid(id=ID_VARIABLEEDITORPANELVARIABLESGRID,

   338

              name='VariablesGrid', parent=self, pos=wx.Point(0, 0), 

   339

              size=wx.Size(0, 0), style=wx.VSCROLL)

   340

        self.VariablesGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,

   341

              'Sans'))

   342

        self.VariablesGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,

   343

              False, 'Sans'))

   344

        self.VariablesGrid.SetSelectionBackground(wx.WHITE)

   345

        self.VariablesGrid.SetSelectionForeground(wx.BLACK)

   346

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   347

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

   348

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

   349

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

   350

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

   351

        else:

   352

            wx.grid.EVT_GRID_CELL_CHANGE(self.VariablesGrid, self.OnVariablesGridCellChange)

   353

            wx.grid.EVT_GRID_CELL_LEFT_CLICK(self.VariablesGrid, self.OnVariablesGridCellLeftClick)

   354

            wx.grid.EVT_GRID_EDITOR_SHOWN(self.VariablesGrid, self.OnVariablesGridEditorShown)

   355

   356

        self.ControlPanel = wx.ScrolledWindow(id=ID_VARIABLEEDITORCONTROLPANEL,

   357

              name='ControlPanel', parent=self, pos=wx.Point(0, 0),

   358

              size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

   359

        self.ControlPanel.SetScrollRate(10, 0)

   360

   361

        self.staticText1 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT1,

   362

              label=_('Return Type:'), name='staticText1', parent=self.ControlPanel,

   363

              pos=wx.Point(0, 0), size=wx.DefaultSize, style=0)

   364

   365

        self.ReturnType = wx.ComboBox(id=ID_VARIABLEEDITORPANELRETURNTYPE,

   366

              name='ReturnType', parent=self.ControlPanel, pos=wx.Point(0, 0),

   367

              size=wx.Size(145, 28), style=wx.CB_READONLY)

   368

        self.Bind(wx.EVT_COMBOBOX, self.OnReturnTypeChanged, id=ID_VARIABLEEDITORPANELRETURNTYPE)

   369

   370

        self.staticText2 = wx.StaticText(id=ID_VARIABLEEDITORPANELSTATICTEXT2,

   371

              label=_('Class Filter:'), name='staticText2', parent=self.ControlPanel,

   372

              pos=wx.Point(0, 0), size=wx.DefaultSize, style=0)

   373

   374

        self.ClassFilter = wx.ComboBox(id=ID_VARIABLEEDITORPANELCLASSFILTER,

   375

              name='ClassFilter', parent=self.ControlPanel, pos=wx.Point(0, 0),

   376

              size=wx.Size(145, 28), style=wx.CB_READONLY)

   377

        self.Bind(wx.EVT_COMBOBOX, self.OnClassFilter, id=ID_VARIABLEEDITORPANELCLASSFILTER)

   378

   379

        self.AddButton = wx.Button(id=ID_VARIABLEEDITORPANELADDBUTTON, label=_('Add'),

   380

              name='AddButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   381

              size=wx.DefaultSize, style=0)

   382

   383

        self.DeleteButton = wx.Button(id=ID_VARIABLEEDITORPANELDELETEBUTTON, label=_('Delete'),

   384

              name='DeleteButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   385

              size=wx.DefaultSize, style=0)

   386

   387

        self.UpButton = wx.Button(id=ID_VARIABLEEDITORPANELUPBUTTON, label='^',

   388

              name='UpButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   389

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

   390

   391

        self.DownButton = wx.Button(id=ID_VARIABLEEDITORPANELDOWNBUTTON, label='v',

   392

              name='DownButton', parent=self.ControlPanel, pos=wx.Point(0, 0),

   393

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

   394

   395

        self._init_sizers()

   396

   397

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

   398

        self._init_ctrls(parent)

   399

        self.ParentWindow = window

   400

        self.Controler = controler

   401

        self.ElementType = element_type

   402

        self.Debug = debug

   403

   404

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

   405

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

   406

   407

        self.Filter = "All"

   408

        self.FilterChoices = []

   409

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   410

   411

        self.DefaultValue = {   "Name" : "", "Class" : "", "Type" : "INT", "Location" : "",

   412

                                "Initial Value" : "", "Option" : "",

   413

                                "Documentation" : "", "Edit" : True

   414

                            }

   415

   416

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

   417

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

   418

        else:

   419

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

   420

   421

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

   422

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

   423

            # this is an element that can have located variables

   424

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

   425

   426

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

   427

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

   428

            else:

   429

                self.FilterChoices = ["All",

   430

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

   431

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

   432

   433

            # these condense the ColAlignements list

   434

            l = wx.ALIGN_LEFT

   435

            c = wx.ALIGN_CENTER 

   436

   437

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   438

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

   439

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

   440

   441

        else:

   442

            # this is an element that cannot have located variables

   443

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

   444

   445

            if element_type == "function":

   446

                self.FilterChoices = ["All",

   447

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

   448

                                        "Variables", "   Local"]

   449

            else:

   450

                self.FilterChoices = ["All",

   451

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

   452

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

   453

   454

            # these condense the ColAlignements list

   455

            l = wx.ALIGN_LEFT

   456

            c = wx.ALIGN_CENTER 

   457

   458

            #                      Num  Name    Class   Type    Init    Option   Doc

   459

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

   460

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

   461

   462

        for choice in self.FilterChoices:

   463

            self.ClassFilter.Append(_(choice))

   464

   465

        reverse_transfer = {}

   466

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

   467

            reverse_transfer[choice] = filter

   468

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

   469

        self.RefreshTypeList()

   470

   471

        self.VariablesGrid.SetTable(self.Table)

   472

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

   473

                                       "Delete": self.DeleteButton,

   474

                                       "Up": self.UpButton,

   475

                                       "Down": self.DownButton})

   476

        self.VariablesGrid.SetEditable(not self.Debug)

   477

   478

        def _AddVariable(new_row):

   479

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

   480

                row_content = self.DefaultValue.copy()

   481

                if self.Filter in self.DefaultTypes:

   482

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

   483

                else:

   484

                    row_content["Class"] = self.Filter

   485

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

   486

                    self.Values.insert(new_row, row_content)

   487

                else:

   488

                    self.Values.append(row_content)

   489

                    new_row = self.Table.GetNumberRows()

   490

                self.SaveValues()

   491

                self.RefreshValues()

   492

                return new_row

   493

            return self.VariablesGrid.GetGridCursorRow()

   494

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

   495

   496

        def _DeleteVariable(row):

   497

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

   498

                (not self.PouIsUsed or self.Table.GetValueByName(row, "Class") not in ["Input", "Output", "InOut"])):

   499

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

   500

                self.SaveValues()

   501

                self.RefreshValues()

   502

        setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

   503

   504

        def _MoveVariable(row, move):

   505

            if (self.Filter == "All" and 

   506