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 _GetRowEdit(self, row):

   148

        row_edit = self.GetValueByName(row, "Edit")

   149

        var_type = self.Parent.GetTagName()

   150

        bodytype = self.Parent.Controler.GetEditedElementBodyType(var_type)

   151

        if bodytype in ["ST", "IL"]:

   152

            row_edit = True;

   153

        return row_edit

   154

   155

    def _updateColAttrs(self, grid):

   156

        """

   157

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

   158

        appropriate renderer given the column name.

   159

   160

        Otherwise default to the default renderer.

   161

        """

   162

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

   163

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

   164

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

   165

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

   166

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

   167

                editor = None

   168

                renderer = None

   169

                colname = self.GetColLabelValue(col, False)

   170

                if self.Parent.Debug:

   171

                    grid.SetReadOnly(row, col, True)

   172

                else:

   173

                    if colname == "Option":

   174

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

   175

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

   176

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

   177

                        if len(options) > 1:

   178

                            editor = wx.grid.GridCellChoiceEditor()

   179

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

   180

                        else:

   181

                            grid.SetReadOnly(row, col, True)

   182

                    elif col != 0 and self._GetRowEdit(row):

   183

                        grid.SetReadOnly(row, col, False)

   184

                        if colname == "Name":

   185

                            editor = wx.grid.GridCellTextEditor()

   186

                            renderer = wx.grid.GridCellStringRenderer()

   187

                        elif colname == "Initial Value":

   188

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

   189

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

   190

                                    editor = wx.grid.GridCellChoiceEditor()

   191

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

   192

                                else:

   193

                                    editor = wx.grid.GridCellTextEditor()

   194

                                renderer = wx.grid.GridCellStringRenderer()

   195

                            else:

   196

                                grid.SetReadOnly(row, col, True)

   197

                        elif colname == "Location":

   198

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

   199

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

   200

                                renderer = wx.grid.GridCellStringRenderer()

   201

                            else:

   202

                                grid.SetReadOnly(row, col, True)

   203

                        elif colname == "Class":

   204

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

   205

                                grid.SetReadOnly(row, col, True)

   206

                            else:

   207

                                editor = wx.grid.GridCellChoiceEditor()

   208

                                excluded = []

   209

                                if self.Parent.IsFunctionBlockType(var_type):

   210

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

   211

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

   212

                    elif colname != "Documentation":

   213

                        grid.SetReadOnly(row, col, True)

   214

   215

                grid.SetCellEditor(row, col, editor)

   216

                grid.SetCellRenderer(row, col, renderer)

   217

   218

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

   219

                    highlight_colours = ERROR_HIGHLIGHT

   220

                else:

   221

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

   222

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

   223

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

   224

            self.ResizeRow(grid, row)

   225

   226

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

   227

#                         Variable Panel Drop Target

   228

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

   229

   230

class VariableDropTarget(wx.TextDropTarget):

   231

    '''

   232

    This allows dragging a variable location from somewhere to the Location

   233

    column of a variable row.

   234

   235

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

   236

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

   237

   238

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

   239

    variable to the Location column of the variable panel).

   240

    '''

   241

    def __init__(self, parent):

   242

        wx.TextDropTarget.__init__(self)

   243

        self.ParentWindow = parent

   244

   245

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

   246

        self.ParentWindow.ParentWindow.Select()

   247

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

   248

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

   249

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

   250

        message = None

   251

        element_type = self.ParentWindow.ElementType

   252

        try:

   253

            values = eval(data)

   254

        except:

   255

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

   256

            values = None

   257

        if not isinstance(values, TupleType):

   258

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

   259

            values = None

   260

        if values is not None:

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

                    else:

   269

                        location = values[0]

   270

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

   271

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

   272

   273

                        if values[2] is not None:

   274

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

   275

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

   276

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

   277

   278

                        if message is None:

   279

                            if not location.startswith("%"):

   280

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

   281

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

   282

                                elif location[0] not in LOCATIONDATATYPES:

   283

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

   284

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

   285

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

   286

                                else:

   287

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

   288

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

   289

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

   290

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

   291

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

   292

                                        selected = dialog.GetSelection()

   293

                                    else:

   294

                                        selected = None

   295

                                    dialog.Destroy()

   296

                                    if selected is None:

   297

                                        return

   298

                                    if selected == 0:

   299

                                        location = "%I" + location

   300

                                    elif selected == 1:

   301

                                        location = "%Q" + location

   302

                                    else:

   303

                                        location = "%M" + location

   304

   305

                            if message is None:

   306

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

   307

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

   308

                                self.ParentWindow.SaveValues()

   309

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

   310

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

   311

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

   312

                    else:

   313

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

   314

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

   315

                        self.ParentWindow.SaveValues()

   316

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

   317

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

   318

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

   319

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

   320

                    var_name = values[3]

   321

                else:

   322

                    var_name = values[0]

   323

                tagname = self.ParentWindow.GetTagName()

   324

                dlg = wx.TextEntryDialog(

   325

                    self.ParentWindow.ParentWindow.ParentWindow,

   326

                    _("Confirm or change variable name"),

   327

                    'Variable Drop', var_name)

   328

                dlg.SetValue(var_name)

   329

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

   330

                dlg.Destroy()

   331

                if var_name is None:

   332

                    return

   333

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

   334

                        for name in self.ParentWindow.Controler.\

   335

                            GetProjectPouNames(self.ParentWindow.Debug)]:

   336

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

   337

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

   338

                        for name in self.ParentWindow.Controler.\

   339

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

   340

                    var_infos = self.ParentWindow.DefaultValue.copy()

   341

                    var_infos.Name = var_name

   342

                    var_infos.Type = values[2]

   343

                    var_infos.Documentation = values[4]

   344

                    if values[1] == "location":

   345

                        location = values[0]

   346

                        if not location.startswith("%"):

   347

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

   348

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

   349

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

   350

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

   351

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

   352

                                selected = dialog.GetSelection()

   353

                            else:

   354

                                selected = None

   355

                            dialog.Destroy()

   356

                            if selected is None:

   357

                                return

   358

                            if selected == 0:

   359

                                location = "%I" + location

   360

                            elif selected == 1:

   361

                                location = "%Q" + location

   362

                            else:

   363

                                location = "%M" + location

   364

                        if element_type == "functionBlock":

   365

                            configs = self.ParentWindow.Controler.GetProjectConfigNames(

   366

                                                                self.ParentWindow.Debug)

   367

                            if len(configs) == 0:

   368

                                return

   369

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

   370

                                for name in self.ParentWindow.Controler.\

   371

                                    GetConfigurationVariableNames(configs[0])]:

   372

                                self.ParentWindow.Controler.AddConfigurationGlobalVar(

   373

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

   374

                            var_infos.Class = "External"

   375

                        else:

   376

                            if element_type == "program":

   377

                                var_infos.Class = "Local"

   378

                            else:

   379

                                var_infos.Class = "Global"

   380

                            var_infos.Location = location

   381

                    elif values[1] == "NamedConstant":

   382

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

   383

                            var_infos.Class = "Local"

   384

                            var_infos.InitialValue = values[0]

   385

                        else :

   386

                            return

   387

                    else:

   388

                        var_infos.Class = "External"

   389

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

   390

                    self.ParentWindow.Values.append(var_infos)

   391

                    self.ParentWindow.SaveValues()

   392

                    self.ParentWindow.RefreshValues()

   393

                else:

   394

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

   395

   396

        if message is not None:

   397

            wx.CallAfter(self.ShowMessage, message)

   398

   399

    def ShowMessage(self, message):

   400

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

   401

        message.ShowModal()

   402

        message.Destroy()

   403

   404

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

   405

#                               Variable Panel

   406

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

   407

   408

class VariablePanel(wx.Panel):

   409

   410

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

   411

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

   412

   413

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

   414

        self.MainSizer.AddGrowableCol(0)

   415

        self.MainSizer.AddGrowableRow(1)

   416

   417

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

   418

        controls_sizer.AddGrowableCol(5)

   419

        controls_sizer.AddGrowableRow(0)

   420

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

   421

   422

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

   423

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

   424

   425

        self.ReturnType = wx.ComboBox(self,

   426

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

   427

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

   428

        controls_sizer.AddWindow(self.ReturnType)

   429

   430

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

   431

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

   432

   433

        self.Description = wx.TextCtrl(self,

   434

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

   435

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

   436

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

   437

        controls_sizer.AddWindow(self.Description)

   438

   439

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

   440

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

   441

   442

        self.ClassFilter = wx.ComboBox(self,

   443

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

   444

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

   445

        controls_sizer.AddWindow(self.ClassFilter)

   446

   447

        for name, bitmap, help in [

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

            button.SetToolTipString(help)

   455

            setattr(self, name, button)

   456

            controls_sizer.AddWindow(button)

   457

   458

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

   459

        self.VariablesGrid.SetDropTarget(VariableDropTarget(self))

   460

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

   461

              self.OnVariablesGridCellChange)

   462

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

   463

              self.OnVariablesGridCellLeftClick)

   464

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

   465

              self.OnVariablesGridEditorShown)

   466

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

   467

   468

        self.SetSizer(self.MainSizer)

   469

   470

        self.ParentWindow = window

   471

        self.Controler = controler

   472

        self.ElementType = element_type

   473

        self.Debug = debug

   474

   475

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

   476

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

   477

              self.RefreshHighlightsTimer)

   478

   479

        self.Filter = "All"

   480

        self.FilterChoices = []

   481

        self.FilterChoiceTransfer = GetFilterChoiceTransfer()

   482

   483

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

   484

   485

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

   486

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

   487

        else:

   488

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

   489

   490

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

   491

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

   492

            # this is an element that can have located variables

   493

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

   494

   495

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

   496

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

   497

            else:

   498

                self.FilterChoices = ["All",

   499

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

   500

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

   501

   502

            # these condense the ColAlignements list

   503

            l = wx.ALIGN_LEFT

   504

            c = wx.ALIGN_CENTER

   505

   506

            #                      Num  Name    Class   Type    Loc     Init    Option   Doc

   507

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

   508

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