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, DefaultType

    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

from PLCControler import _VariableInfos

    41

    42

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

    43

#                                 Helpers

    44

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

    45

    46

[TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE,

    47

 POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    48

] = range(10)

    49

    50

def GetVariableTableColnames(location):

    51

    _ = lambda x : x

    52

    if location:

    53

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

    54

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

    55

    56

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

    57

    _ = lambda x : x

    58

    options = [""]

    59

    if constant:

    60

        options.append(_("Constant"))

    61

    if retain:

    62

        options.append(_("Retain"))

    63

    if non_retain:

    64

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

    65

    return options

    66

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

    67

    68

def GetFilterChoiceTransfer():

    69

    _ = lambda x : x

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

    77

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

    78

                       "Temp": lambda x: "",

    79

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

    80

                       "InOut": lambda x: "",

    81

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

    82

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

    83

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

    84

                      }

    85

    86

LOCATION_MODEL = re.compile("((?:%[IQM](?:\*|(?:[XBWLD]?[0-9]+(?:\.[0-9]+)*)))?)$")

    87

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([0-9]*)$")

    88

    89

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

    90

#                            Variables Panel Table

    91

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

    92

    93

class VariableTable(CustomTable):

    94

    95

    """

    96

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

    97

    """

    98

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

    99

        # The base class must be initialized *first*

   100

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

   101

        self.old_value = None

   102

   103

    def GetValueByName(self, row, colname):

   104

        if row < self.GetNumberRows():

   105

            return getattr(self.data[row], colname)

   106

   107

    def SetValueByName(self, row, colname, value):

   108

        if row < self.GetNumberRows():

   109

            setattr(self.data[row], colname, value)

   110

   111

    def GetValue(self, row, col):

   112

        if row < self.GetNumberRows():

   113

            if col == 0:

   114

                return self.data[row].Number

   115

            colname = self.GetColLabelValue(col, False)

   116

            if colname == "Initial Value":

   117

                colname = "InitialValue"

   118

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

   119

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

   120

                if value[0] == "array":

   121

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

   122

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

   123

                value = str(value)

   124

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

   125

                return _(value)

   126

            return value

   127

   128

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

   129

        if col < len(self.colnames):

   130

            colname = self.GetColLabelValue(col, False)

   131

            if colname == "Name":

   132

                self.old_value = getattr(self.data[row], colname)

   133

            elif colname == "Class":

   134

                value = VARIABLE_CLASSES_DICT[value]

   135

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

   136

                if value == "External":

   137

                    self.SetValueByName(row, "InitialValue", "")

   138

            elif colname == "Option":

   139

                value = OPTIONS_DICT[value]

   140

            elif colname == "Initial Value":

   141

                colname = "InitialValue"

   142

            setattr(self.data[row], colname, value)

   143

   144

    def GetOldValue(self):

   145

        return self.old_value

   146

   147

    def _updateColAttrs(self, grid):

   148

        """

   149

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

   150

        appropriate renderer given the column name.

   151

   152

        Otherwise default to the default renderer.

   153

        """

   154

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

   155

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

   156

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

   157

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

   158

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

   159

                editor = None

   160

                renderer = None

   161

                colname = self.GetColLabelValue(col, False)

   162

                if self.Parent.Debug:

   163

                    grid.SetReadOnly(row, col, True)

   164

                else:

   165

                    if colname == "Option":

   166

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

   167

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

   168

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

   169

                        if len(options) > 1:

   170

                            editor = wx.grid.GridCellChoiceEditor()

   171

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

   172

                        else:

   173

                            grid.SetReadOnly(row, col, True)

   174

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

   175

                        grid.SetReadOnly(row, col, False)

   176

                        if colname == "Name":

   177

                            editor = wx.grid.GridCellTextEditor()

   178

                            renderer = wx.grid.GridCellStringRenderer()

   179

                        elif colname == "Initial Value":

   180

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

   181

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

   182

                                    editor = wx.grid.GridCellChoiceEditor()

   183

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

   184

                                else:

   185

                                    editor = wx.grid.GridCellTextEditor()

   186

                                renderer = wx.grid.GridCellStringRenderer()

   187

                            else:

   188

                                grid.SetReadOnly(row, col, True)

   189

                        elif colname == "Location":

   190

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

   191

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

   192

                                renderer = wx.grid.GridCellStringRenderer()

   193

                            else:

   194

                                grid.SetReadOnly(row, col, True)

   195

                        elif colname == "Class":

   196

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

   197

                                grid.SetReadOnly(row, col, True)

   198

                            else:

   199

                                editor = wx.grid.GridCellChoiceEditor()

   200

                                excluded = []

   201

                                if self.Parent.IsFunctionBlockType(var_type):

   202

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

   203

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

   204

                    elif colname != "Documentation":

   205

                        grid.SetReadOnly(row, col, True)

   206

   207

                grid.SetCellEditor(row, col, editor)

   208

                grid.SetCellRenderer(row, col, renderer)

   209

   210

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

   211

                    highlight_colours = ERROR_HIGHLIGHT

   212

                else:

   213

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

   214

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

   215

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

   216

            self.ResizeRow(grid, row)

   217

   218

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

   219

#                         Variable Panel Drop Target

   220

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

   221

   222

class VariableDropTarget(wx.TextDropTarget):

   223

    '''

   224

    This allows dragging a variable location from somewhere to the Location

   225

    column of a variable row.

   226

   227

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

   228

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

   229

   230

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

   231

    variable to the Location column of the variable panel).

   232

    '''

   233

    def __init__(self, parent):

   234

        wx.TextDropTarget.__init__(self)

   235

        self.ParentWindow = parent

   236

   237

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

   238

        self.ParentWindow.ParentWindow.Select()

   239

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

   240

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

   241

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

   242

        message = None

   243

        element_type = self.ParentWindow.ElementType

   244

        try:

   245

            values = eval(data)

   246

        except:

   247

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

   248

            values = None

   249

        if not isinstance(values, TupleType):

   250

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

   251

            values = None

   252

        if values is not None:

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

                    else:

   261

                        location = values[0]

   262

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

   263

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

   264

   265

                        if values[2] is not None:

   266

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

   267

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

   268

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

   269

   270

                        if message is None:

   271

                            if not location.startswith("%"):

   272

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

   273

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

   274

                                elif location[0] not in LOCATIONDATATYPES:

   275

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

   276

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

   277

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

   278

                                else:

   279

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

   280

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

   281

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

   282

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

   283

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

   284

                                        selected = dialog.GetSelection()

   285

                                    else:

   286

                                        selected = None

   287

                                    dialog.Destroy()

   288

                                    if selected is None:

   289

                                        return

   290

                                    if selected == 0:

   291

                                        location = "%I" + location

   292

                                    elif selected == 1:

   293

                                        location = "%Q" + location

   294

                                    else:

   295

                                        location = "%M" + location

   296

   297

                            if message is None:

   298

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

   299

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

   300

                                self.ParentWindow.SaveValues()

   301

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

   302

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

   303

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

   304

                    else:

   305

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

   306

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

   307

                        self.ParentWindow.SaveValues()

   308

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

   309

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

   310

                  element_type != "function" and values[1] == "location"):

   311

                if values[1] == "location":

   312

                    var_name = values[3]

   313

                else:

   314

                    var_name = values[0]

   315

                tagname = self.ParentWindow.GetTagName()

   316

                if var_name.upper() in [name.upper()

   317

                        for name in self.ParentWindow.Controler.\

   318

                            GetProjectPouNames(self.ParentWindow.Debug)]:

   319

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

   320

                elif not var_name.upper() in [name.upper()

   321

                        for name in self.ParentWindow.Controler.\

   322

                            GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   323

                    var_infos = self.ParentWindow.DefaultValue.copy()

   324

                    var_infos.Name = var_name

   325

                    var_infos.Type = values[2]

   326

                    if values[1] == "location":

   327

                        location = values[0]

   328

                        if not location.startswith("%"):

   329

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

   330

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

   331

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

   332

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

   333

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

   334

                                selected = dialog.GetSelection()

   335

                            else:

   336

                                selected = None

   337

                            dialog.Destroy()

   338

                            if selected is None:

   339

                                return

   340

                            if selected == 0:

   341

                                location = "%I" + location

   342

                            elif selected == 1:

   343

                                location = "%Q" + location

   344

                            else:

   345

                                location = "%M" + location

   346

                        if element_type == "functionBlock":

   347

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   348

                                                                self.ParentWindow.Debug)

   349

                            if len(configs) == 0:

   350

                                return

   351

                            if not var_name.upper() in [name.upper()

   352

                                for name in self.ParentWindow.Controler.\

   353

                                    GetConfigurationVariableNames(configs[0])]:

   354

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   355

                                    configs[0], values[2], var_name, location, "")

   356

                            var_infos.Class = "External"

   357

                        else:

   358

                            if element_type == "program":

   359

                                var_infos.Class = "Local"

   360

                            else:

   361

                                var_infos.Class = "Global"

   362

                            var_infos.Location = location

   363

                    else:

   364

                        var_infos.Class = "External"

   365

                    var_infos.Number = len(self.ParentWindow.Values)

   366

                    self.ParentWindow.Values.append(var_infos)

   367

                    self.ParentWindow.SaveValues()

   368

                    self.ParentWindow.RefreshValues()

   369

   370

        if message is not None:

   371

            wx.CallAfter(self.ShowMessage, message)

   372

   373

    def ShowMessage(self, message):

   374

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

   375

        message.ShowModal()

   376

        message.Destroy()

   377

   378

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

   379

#                               Variable Panel

   380

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

   381

   382

class VariablePanel(wx.Panel):

   383

   384

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

   385

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

   386

   387

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

   388

        self.MainSizer.AddGrowableCol(0)

   389

        self.MainSizer.AddGrowableRow(1)

   390

   391

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

   392

        controls_sizer.AddGrowableCol(5)

   393

        controls_sizer.AddGrowableRow(0)

   394

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

   395

   396

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

   397

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

   398

   399

        self.ReturnType = wx.ComboBox(self,

   400

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

   401

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

   402

        controls_sizer.AddWindow(self.ReturnType)

   403

   404

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

   405

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

   406

   407

        self.Description = wx.TextCtrl(self,

   408

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

   409

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

   410

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

   411

        controls_sizer.AddWindow(self.Description)

   412

   413

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

   414

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

   415

   416

        self.ClassFilter = wx.ComboBox(self,

   417

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

   418

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

   419

        controls_sizer.AddWindow(self.ClassFilter)

   420

   421

        for name, bitmap, help in [

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

            button.SetToolTipString(help)

   429

            setattr(self, name, button)

   430

            controls_sizer.AddWindow(button)

   431

   432

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

   433

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   434

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

   435

              self.OnVariablesGridCellChange)

   436

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

   437

              self.OnVariablesGridCellLeftClick)

   438

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

   439

              self.OnVariablesGridEditorShown)

   440

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

   441

   442

        self.SetSizer(self.MainSizer)

   443

   444

        self.ParentWindow = window

   445

        self.Controler = controler

   446

        self.ElementType = element_type

   447

        self.Debug = debug

   448

   449

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

   450

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

   451

              self.RefreshHighlightsTimer)

   452

   453

        self.Filter = "All"

   454

        self.FilterChoices = []

   455

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   456

   457

        self.DefaultValue = _VariableInfos("", "", "", "", "", True, "", DefaultType, ([], []), 0)

   458

   459

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

   460

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

   461

        else:

   462

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

   463

   464

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

   465

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

   466

            # this is an element that can have located variables

   467

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

   468

   469

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

   470

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

   471

            else:

   472

                self.FilterChoices = ["All",

   473

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

   474

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

   475

   476

            # these condense the ColAlignements list

   477

            l = wx.ALIGN_LEFT

   478

            c = wx.ALIGN_CENTER

   479

   480

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   481

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

   482

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

   483

   484

        else:

   485

            # this is an element that cannot have located variables

   486

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

   487

   488

            if element_type == "function":

   489

                self.FilterChoices = ["All",

   490

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

   491

                                        "Variables", "   Local"]

   492

            else:

   493

                self.FilterChoices = ["All",

   494

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

   495

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

   496

   497

            # these condense the ColAlignements list

   498

            l = wx.ALIGN_LEFT

   499

            c = wx.ALIGN_CENTER

   500

   501

            #                      Num  Name    Class   Type    Init    Option   Doc

   502

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

   503

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

   504

   505

        self.ElementType = element_type

   506

        self.BodyType = None

   507

   508

        for choice in self.FilterChoices:

   509

            self.ClassFilter.Append(_(choice))