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] in ["location", "NamedConstant"]):

   311

                if values[1] in  ["location","NamedConstant"]:

   312

                    var_name = values[3]

   313

                else:

   314

                    var_name = values[0]

   315

                tagname = self.ParentWindow.GetTagName()

   316

                dlg = wx.TextEntryDialog(

   317

                    self.ParentWindow.ParentWindow.ParentWindow,

   318

                    _("Confirm or change variable name"),

   319

                    'Variable Drop', var_name)

   320

                dlg.SetValue(var_name)

   321

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   322

                dlg.Destroy()

   323

                if var_name is None:

   324

                    return

   325

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

   326

                        for name in self.ParentWindow.Controler.\

   327

                            GetProjectPouNames(self.ParentWindow.Debug)]:

   328

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

   329

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

   330

                        for name in self.ParentWindow.Controler.\

   331

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

   332

                    var_infos = self.ParentWindow.DefaultValue.copy()

   333

                    var_infos.Name = var_name

   334

                    var_infos.Type = values[2]

   335

                    var_infos.Documentation = values[4]

   336

                    if values[1] == "location":

   337

                        location = values[0]

   338

                        if not location.startswith("%"):

   339

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

   340

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

   341

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

   342

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

   343

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

   344

                                selected = dialog.GetSelection()

   345

                            else:

   346

                                selected = None

   347

                            dialog.Destroy()

   348

                            if selected is None:

   349

                                return

   350

                            if selected == 0:

   351

                                location = "%I" + location

   352

                            elif selected == 1:

   353

                                location = "%Q" + location

   354

                            else:

   355

                                location = "%M" + location

   356

                        if element_type == "functionBlock":

   357

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   358

                                                                self.ParentWindow.Debug)

   359

                            if len(configs) == 0:

   360

                                return

   361

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

   362

                                for name in self.ParentWindow.Controler.\

   363

                                    GetConfigurationVariableNames(configs[0])]:

   364

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   365

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

   366

                            var_infos.Class = "External"

   367

                        else:

   368

                            if element_type == "program":

   369

                                var_infos.Class = "Local"

   370

                            else:

   371

                                var_infos.Class = "Global"

   372

                            var_infos.Location = location

   373

                    elif values[1] == "NamedConstant":

   374

                        if element_type in ["functionBlock","program"]:

   375

                            var_infos.Class = "Local"

   376

                            var_infos.InitialValue = values[0]

   377

                        else :

   378

                            return

   379

                    else:

   380

                        var_infos.Class = "External"

   381

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

   382

                    self.ParentWindow.Values.append(var_infos)

   383

                    self.ParentWindow.SaveValues()

   384

                    self.ParentWindow.RefreshValues()

   385

                else:

   386

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

   387

   388

        if message is not None:

   389

            wx.CallAfter(self.ShowMessage, message)

   390

   391

    def ShowMessage(self, message):

   392

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

   393

        message.ShowModal()

   394

        message.Destroy()

   395

   396

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

   397

#                               Variable Panel

   398

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

   399

   400

class VariablePanel(wx.Panel):

   401

   402

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

   403

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

   404

   405

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

   406

        self.MainSizer.AddGrowableCol(0)

   407

        self.MainSizer.AddGrowableRow(1)

   408

   409

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

   410

        controls_sizer.AddGrowableCol(5)

   411

        controls_sizer.AddGrowableRow(0)

   412

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

   413

   414

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

   415

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

   416

   417

        self.ReturnType = wx.ComboBox(self,

   418

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

   419

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

   420

        controls_sizer.AddWindow(self.ReturnType)

   421

   422

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

   423

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

   424

   425

        self.Description = wx.TextCtrl(self,

   426

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

   427

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

   428

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

   429

        controls_sizer.AddWindow(self.Description)

   430

   431

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

   432

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

   433

   434

        self.ClassFilter = wx.ComboBox(self,

   435

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

   436

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

   437

        controls_sizer.AddWindow(self.ClassFilter)

   438

   439

        for name, bitmap, help in [

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

            button.SetToolTipString(help)

   447

            setattr(self, name, button)

   448

            controls_sizer.AddWindow(button)

   449

   450

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

   451

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   452

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

   453

              self.OnVariablesGridCellChange)

   454

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

   455

              self.OnVariablesGridCellLeftClick)

   456

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

   457

              self.OnVariablesGridEditorShown)

   458

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

   459

   460

        self.SetSizer(self.MainSizer)

   461

   462

        self.ParentWindow = window

   463

        self.Controler = controler

   464

        self.ElementType = element_type

   465

        self.Debug = debug

   466

   467

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

   468

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

   469

              self.RefreshHighlightsTimer)

   470

   471

        self.Filter = "All"

   472

        self.FilterChoices = []

   473

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   474

   475

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

   476

   477

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

   478

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

   479

        else:

   480

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

   481

   482

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

   483

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

   484

            # this is an element that can have located variables

   485

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

   486

   487

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

   488

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

   489

            else:

   490

                self.FilterChoices = ["All",

   491

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

   492

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

   493

   494

            # these condense the ColAlignements list

   495

            l = wx.ALIGN_LEFT

   496

            c = wx.ALIGN_CENTER

   497

   498

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   499

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

   500

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

   501

   502

        else:

   503

            # this is an element that cannot have located variables

   504

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

   505

   506

            if element_type == "function":

   507

                self.FilterChoices = ["All",

   508

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

   509

                                        "Variables", "   Local"]