1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of CanFestival, a library implementing CanOpen Stack. 

     5

#

     6

#Copyright (C): Edouard TISSERANT, Francis DUPIN and Laurent BESSARD

     7

#

     8

#See COPYING file for copyrights details.

     9

#

    10

#This library is free software; you can redistribute it and/or

    11

#modify it under the terms of the GNU Lesser General Public

    12

#License as published by the Free Software Foundation; either

    13

#version 2.1 of the License, or (at your option) any later version.

    14

#

    15

#This library is distributed in the hope that it will be useful,

    16

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

#Lesser General Public License for more details.

    19

#

    20

#You should have received a copy of the GNU Lesser General Public

    21

#License along with this library; if not, write to the Free Software

    22

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23

    24

import wx

    25

import wx.grid

    26

    27

from types import *

    28

from commondialogs import *

    29

    30

from node import OD_Subindex, OD_MultipleSubindexes, OD_IdenticalSubindexes, OD_IdenticalIndexes

    31

    32

ColSizes = [75, 250, 150, 125, 100, 60, 250]

    33

ColAlignements = [wx.ALIGN_CENTER, wx.ALIGN_LEFT, wx.ALIGN_CENTER, wx.ALIGN_RIGHT, wx.ALIGN_CENTER, wx.ALIGN_CENTER, wx.ALIGN_LEFT]

    34

    35

def GetAccessList(write=True):

    36

    _ = lambda x : x

    37

    if write:

    38

        return [_("Read Only"), _("Write Only"), _("Read/Write")]

    39

    return [_("Read Only"), _("Read/Write")]

    40

AccessList = ",".join(map(_, GetAccessList()))

    41

RAccessList = ",".join(map(_, GetAccessList(False)))

    42

ACCESS_LIST_DICT = dict([(_(access), access) for access in GetAccessList()])

    43

    44

def GetBoolList():

    45

    _ = lambda x : x

    46

    return [_("True"), _("False")]

    47

BoolList = ",".join(map(_, GetBoolList()))

    48

BOOL_LIST_DICT = dict([(_(bool), bool) for bool in GetBoolList()])

    49

    50

def GetOptionList():

    51

    _ = lambda x : x

    52

    return [_("Yes"), _("No")]

    53

OptionList = ",".join(map(_, GetOptionList()))

    54

OPTION_LIST_DICT = dict([(_(option), option) for option in GetOptionList()])

    55

    56

[USER_TYPE, SDO_SERVER, SDO_CLIENT, 

    57

 PDO_TRANSMIT, PDO_RECEIVE, MAP_VARIABLE] = range(6)

    58

    59

INDEXCHOICE_OPTIONS = {

    60

    USER_TYPE: (_("User Type"), 0, "AddUserType"), 

    61

    SDO_SERVER: (_("SDO Server"), 1, "AddSDOServerToCurrent"),

    62

    SDO_CLIENT: (_("SDO Client"), 1, "AddSDOClientToCurrent"),

    63

    PDO_RECEIVE: (_("PDO Receive"), 1, "AddPDOReceiveToCurrent"),

    64

    PDO_TRANSMIT: (_("PDO Transmit"), 1, "AddPDOTransmitToCurrent"),

    65

    MAP_VARIABLE: (_("Map Variable"), 0, "AddMapVariable")

    66

}

    67

    68

INDEXCHOICE_OPTIONS_DICT = dict([(translation, option) for option, (translation, object, function) in INDEXCHOICE_OPTIONS.iteritems()])

    69

    70

INDEXCHOICE_SECTIONS = {

    71

    0 : [USER_TYPE],

    72

    2 : [SDO_SERVER, SDO_CLIENT],

    73

    3 : [PDO_RECEIVE],

    74

    4 : [PDO_RECEIVE],

    75

    5 : [PDO_TRANSMIT],

    76

    6 : [PDO_TRANSMIT],

    77

    8 : [MAP_VARIABLE],

    78

}

    79

    80

def GetSubindexTableColnames():

    81

    _ = lambda x : x

    82

    return [_("subindex"), _("name"), _("type"), _("value"), _("access"), _("save"), _("comment")]

    83

    84

DictionaryOrganisation = [

    85

    {"minIndex" : 0x0001, "maxIndex" : 0x0FFF, "name" : "Data Type Definitions"},

    86

    {"minIndex" : 0x1000, "maxIndex" : 0x1029, "name" : "Communication Parameters"},

    87

    {"minIndex" : 0x1200, "maxIndex" : 0x12FF, "name" : "SDO Parameters"},

    88

    {"minIndex" : 0x1400, "maxIndex" : 0x15FF, "name" : "Receive PDO Parameters"},

    89

    {"minIndex" : 0x1600, "maxIndex" : 0x17FF, "name" : "Receive PDO Mapping"},

    90

    {"minIndex" : 0x1800, "maxIndex" : 0x19FF, "name" : "Transmit PDO Parameters"},

    91

    {"minIndex" : 0x1A00, "maxIndex" : 0x1BFF, "name" : "Transmit PDO Mapping"},

    92

    {"minIndex" : 0x1C00, "maxIndex" : 0x1FFF, "name" : "Other Communication Parameters"},

    93

    {"minIndex" : 0x2000, "maxIndex" : 0x5FFF, "name" : "Manufacturer Specific"},

    94

    {"minIndex" : 0x6000, "maxIndex" : 0x9FFF, "name" : "Standardized Device Profile"},

    95

    {"minIndex" : 0xA000, "maxIndex" : 0xBFFF, "name" : "Standardized Interface Profile"}]

    96

    97

IECTypeConversion = {

    98

    "BOOLEAN": "BOOL",

    99

    "INTEGER8": "SINT",

   100

    "INTEGER16": "INT",

   101

    "INTEGER32": "DINT",

   102

    "UNSIGNED8": "USINT",

   103

    "UNSIGNED16": "UINT",

   104

    "UNSIGNED32": "UDINT",

   105

    "REAL32": "REAL",

   106

    "VISIBLE_STRING": "STRING",

   107

    "OCTET_STRING": "STRING",

   108

    "UNICODE_STRING": "WSTRING",

   109

    "DOMAIN": "STRING",

   110

    "INTEGER24": "DINT",

   111

    "REAL64": "LREAL",

   112

    "INTEGER40": "LINT",

   113

    "INTEGER48": "LINT",

   114

    "INTEGER56": "LINT",

   115

    "INTEGER64": "LINT",

   116

    "UNSIGNED24": "UDINT",

   117

    "UNSIGNED40": "ULINT",

   118

    "UNSIGNED48": "ULINT",

   119

    "UNSIGNED56": "ULINT",

   120

    "UNSIGNED64": "ULINT",

   121

}

   122

SizeConversion = {1 : "X", 8 : "B", 16 : "W", 24 : "D", 32 : "D", 40 : "L", 48 : "L", 56 : "L", 64 : "L"}

   123

   124

class SubindexTable(wx.grid.PyGridTableBase):

   125

   126

    """

   127

    A custom wxGrid Table using user supplied data

   128

    """

   129

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

   130

        # The base class must be initialized *first*

   131

        wx.grid.PyGridTableBase.__init__(self)

   132

        self.data = data

   133

        self.editors = editors

   134

        self.CurrentIndex = 0

   135

        self.colnames = colnames

   136

        self.Parent = parent

   137

        self.Editable = True

   138

        # XXX

   139

        # we need to store the row length and collength to

   140

        # see if the table has changed size

   141

        self._rows = self.GetNumberRows()

   142

        self._cols = self.GetNumberCols()

   143

   144

    def Disable(self):

   145

        self.Editable = False

   146

   147

    def Enable(self):

   148

        self.Editable = True

   149

   150

    def GetNumberCols(self):

   151

        return len(self.colnames)

   152

   153

    def GetNumberRows(self):

   154

        return len(self.data)

   155

   156

    def GetColLabelValue(self, col, translate=True):

   157

        if col < len(self.colnames):

   158

            if translate:

   159

                return _(self.colnames[col])

   160

            return self.colnames[col]

   161

   162

    def GetRowLabelValues(self, row, translate=True):

   163

        return row

   164

   165

    def GetValue(self, row, col, translate=True):

   166

        if row < self.GetNumberRows():

   167

            colname = self.GetColLabelValue(col, False)

   168

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

   169

            if translate and (colname == "access" or 

   170

                              self.editors[row][colname] in ["bool", "option"] or

   171

                              self.editors[row][colname] == "map" and value == "None"):

   172

                value = _(value)

   173

            return value

   174

   175

    def GetEditor(self, row, col):

   176

        if row < self.GetNumberRows():

   177

            return self.editors[row].get(self.GetColLabelValue(col, False), "")

   178

   179

    def GetValueByName(self, row, colname):

   180

        return self.data[row].get(colname)

   181

   182

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

   183

        if col < len(self.colnames):

   184

            colname = self.GetColLabelValue(col, False)

   185

            if colname == "access":

   186

                value = ACCESS_LIST_DICT[value]

   187

            elif self.editors[row][colname] == "bool":

   188

                value = BOOL_LIST_DICT[value]

   189

            elif self.editors[row][colname] == "option":

   190

                value = OPTION_LIST_DICT[value]

   191

            elif self.editors[row][colname] == "map" and value == _("None"):

   192

                value = "None"

   193

            self.data[row][colname] = value

   194

   195

    def ResetView(self, grid):

   196

        """

   197

        (wx.grid.Grid) -> Reset the grid view.   Call this to

   198

        update the grid if rows and columns have been added or deleted

   199

        """

   200

        grid.BeginBatch()

   201

        for current, new, delmsg, addmsg in [

   202

            (self._rows, self.GetNumberRows(), wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED),

   203

            (self._cols, self.GetNumberCols(), wx.grid.GRIDTABLE_NOTIFY_COLS_DELETED, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED),

   204

        ]:

   205

            if new < current:

   206

                msg = wx.grid.GridTableMessage(self,delmsg,new,current-new)

   207

                grid.ProcessTableMessage(msg)

   208

            elif new > current:

   209

                msg = wx.grid.GridTableMessage(self,addmsg,new-current)

   210

                grid.ProcessTableMessage(msg)

   211

                self.UpdateValues(grid)

   212

        grid.EndBatch()

   213

   214

        self._rows = self.GetNumberRows()

   215

        self._cols = self.GetNumberCols()

   216

        # update the column rendering scheme

   217

        self._updateColAttrs(grid)

   218

   219

        # update the scrollbars and the displayed part of the grid

   220

        grid.AdjustScrollbars()

   221

        grid.ForceRefresh()

   222

   223

   224

    def UpdateValues(self, grid):

   225

        """Update all displayed values"""

   226

        # This sends an event to the grid table to update all of the values

   227

        msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)

   228

        grid.ProcessTableMessage(msg)

   229

   230

    def _updateColAttrs(self, grid):

   231

        """

   232

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

   233

        appropriate renderer given the column name.

   234

   235

        Otherwise default to the default renderer.

   236

        """

   237

   238

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

   239

            attr = wx.grid.GridCellAttr()

   240

            attr.SetAlignment(ColAlignements[col], wx.ALIGN_CENTRE)

   241

            grid.SetColAttr(col, attr)

   242

            grid.SetColMinimalWidth(col, ColSizes[col])

   243

            grid.AutoSizeColumn(col, False)

   244

   245

        typelist = None

   246

        maplist = None

   247

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

   248

            editors = self.editors[row]

   249

            if wx.Platform == '__WXMSW__':

   250

                grid.SetRowMinimalHeight(row, 20)

   251

            else:

   252

                grid.SetRowMinimalHeight(row, 28)

   253

            grid.AutoSizeRow(row, False)

   254

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

   255

                editor = None

   256

                renderer = None

   257

   258

                colname = self.GetColLabelValue(col, False)

   259

                editortype = editors[colname]

   260

                if editortype == "dcf":

   261

                    editor = wx.grid.GridCellTextEditor()

   262

                    renderer = wx.grid.GridCellStringRenderer()

   263

                elif editortype and self.Editable:

   264

                    grid.SetReadOnly(row, col, False)

   265

                    if editortype == "string":

   266

                        editor = wx.grid.GridCellTextEditor()

   267

                        renderer = wx.grid.GridCellStringRenderer()

   268

                        if colname == "value" and "length" in editors:

   269

                            editor.SetParameters(editors["length"]) 

   270

                    elif editortype == "number":

   271

                        editor = wx.grid.GridCellNumberEditor()

   272

                        renderer = wx.grid.GridCellNumberRenderer()

   273

                        if colname == "value" and "min" in editors and "max" in editors:

   274

                            editor.SetParameters("%s,%s"%(editors["min"],editors["max"]))

   275

                    elif editortype == "float":

   276

                        editor = wx.grid.GridCellTextEditor()

   277

                        renderer = wx.grid.GridCellStringRenderer()

   278

                    elif editortype == "bool":

   279

                        editor = wx.grid.GridCellChoiceEditor()

   280

                        editor.SetParameters(BoolList)

   281

                    elif editortype == "access":

   282

                        editor = wx.grid.GridCellChoiceEditor()

   283

                        editor.SetParameters(AccessList)

   284

                    elif editortype == "raccess":

   285

                        editor = wx.grid.GridCellChoiceEditor()

   286

                        editor.SetParameters(RAccessList)

   287

                    elif editortype == "option":

   288

                        editor = wx.grid.GridCellChoiceEditor()

   289

                        editor.SetParameters(OptionList)

   290

                    elif editortype == "type":

   291

                        editor = wx.grid.GridCellChoiceEditor()

   292

                        if typelist == None:

   293

                            typelist = self.Parent.Manager.GetCurrentTypeList()

   294

                        editor.SetParameters(typelist)

   295

                    elif editortype == "map":

   296

                        editor = wx.grid.GridCellChoiceEditor()

   297

                        if maplist == None:

   298

                            maplist = self.Parent.Manager.GetCurrentMapList()

   299

                        editor.SetParameters(maplist)

   300

                    elif editortype == "time":

   301

                        editor = wx.grid.GridCellTextEditor()

   302

                        renderer = wx.grid.GridCellStringRenderer()

   303

                    elif editortype == "domain":

   304

                        editor = wx.grid.GridCellTextEditor()

   305

                        renderer = wx.grid.GridCellStringRenderer()

   306

                else:

   307

                    grid.SetReadOnly(row, col, True)

   308

   309

                grid.SetCellEditor(row, col, editor)

   310

                grid.SetCellRenderer(row, col, renderer)

   311

   312

                grid.SetCellBackgroundColour(row, col, wx.WHITE)

   313

   314

    def SetData(self, data):

   315

        self.data = data

   316

   317

    def SetEditors(self, editors):

   318

        self.editors = editors

   319

   320

    def GetCurrentIndex(self):

   321

        return self.CurrentIndex

   322

   323

    def SetCurrentIndex(self, index):

   324

        self.CurrentIndex = index

   325

   326

    def AppendRow(self, row_content):

   327

        self.data.append(row_content)

   328

   329

    def Empty(self):

   330

        self.data = []

   331

        self.editors = []

   332

   333

[ID_EDITINGPANEL, ID_EDITINGPANELADDBUTTON, ID_EDITINGPANELINDEXCHOICE, 

   334

 ID_EDITINGPANELINDEXLIST, ID_EDITINGPANELINDEXLISTPANEL, ID_EDITINGPANELPARTLIST, 

   335

 ID_EDITINGPANELSECONDSPLITTER, ID_EDITINGPANELSUBINDEXGRID,

   336

 ID_EDITINGPANELSUBINDEXGRIDPANEL, ID_EDITINGPANELCALLBACKCHECK,

   337

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

   338

   339

[ID_EDITINGPANELINDEXLISTMENUITEMS0, ID_EDITINGPANELINDEXLISTMENUITEMS1, 

   340

 ID_EDITINGPANELINDEXLISTMENUITEMS2, 

   341

] = [wx.NewId() for _init_coll_IndexListMenu_Items in range(3)]

   342

   343

[ID_EDITINGPANELMENU1ITEMS0, ID_EDITINGPANELMENU1ITEMS1, 

   344

 ID_EDITINGPANELMENU1ITEMS3, ID_EDITINGPANELMENU1ITEMS4, 

   345

] = [wx.NewId() for _init_coll_SubindexGridMenu_Items in range(4)]

   346

   347

class EditingPanel(wx.SplitterWindow):

   348

    def _init_coll_AddToListSizer_Items(self, parent):

   349

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

   350

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

   351

   352

    def _init_coll_SubindexGridSizer_Items(self, parent):

   353

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

   354

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

   355

   356

    def _init_coll_IndexListSizer_Items(self, parent):

   357

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

   358

        parent.AddSizer(self.AddToListSizer, 0, border=0, flag=wx.GROW)

   359

   360

    def _init_coll_AddToListSizer_Growables(self, parent):

   361

        parent.AddGrowableCol(1)

   362

   363

    def _init_coll_SubindexGridSizer_Growables(self, parent):

   364

        parent.AddGrowableCol(0)

   365

        parent.AddGrowableRow(1)

   366

   367

    def _init_coll_IndexListSizer_Growables(self, parent):

   368

        parent.AddGrowableCol(0)

   369

        parent.AddGrowableRow(0)

   370

   371

    def _init_coll_SubindexGridMenu_Items(self, parent):

   372

        parent.Append(help='', id=ID_EDITINGPANELMENU1ITEMS0,

   373

              kind=wx.ITEM_NORMAL, text=_('Add subindexes'))

   374

        parent.Append(help='', id=ID_EDITINGPANELMENU1ITEMS1,

   375

              kind=wx.ITEM_NORMAL, text=_('Delete subindexes'))

   376

        parent.AppendSeparator()

   377

        parent.Append(help='', id=ID_EDITINGPANELMENU1ITEMS3,

   378

              kind=wx.ITEM_NORMAL, text=_('Default value'))

   379

        if not self.Editable:

   380

            parent.Append(help='', id=ID_EDITINGPANELMENU1ITEMS4,

   381

                  kind=wx.ITEM_NORMAL, text=_('Add to DCF'))

   382

        self.Bind(wx.EVT_MENU, self.OnAddSubindexMenu,

   383

              id=ID_EDITINGPANELMENU1ITEMS0)

   384

        self.Bind(wx.EVT_MENU, self.OnDeleteSubindexMenu,

   385

              id=ID_EDITINGPANELMENU1ITEMS1)

   386

        self.Bind(wx.EVT_MENU, self.OnDefaultValueSubindexMenu,

   387

              id=ID_EDITINGPANELMENU1ITEMS3)

   388

        if not self.Editable:

   389

            self.Bind(wx.EVT_MENU, self.OnAddToDCFSubindexMenu,

   390

                  id=ID_EDITINGPANELMENU1ITEMS4)

   391

   392

    def _init_coll_IndexListMenu_Items(self, parent):

   393

        parent.Append(help='', id=ID_EDITINGPANELINDEXLISTMENUITEMS0,

   394

              kind=wx.ITEM_NORMAL, text=_('Rename'))

   395

        parent.Append(help='', id=ID_EDITINGPANELINDEXLISTMENUITEMS2,

   396

              kind=wx.ITEM_NORMAL, text=_('Modify'))

   397

        parent.Append(help='', id=ID_EDITINGPANELINDEXLISTMENUITEMS1,

   398

              kind=wx.ITEM_NORMAL, text=_('Delete'))

   399

        self.Bind(wx.EVT_MENU, self.OnRenameIndexMenu,

   400

              id=ID_EDITINGPANELINDEXLISTMENUITEMS0)

   401

        self.Bind(wx.EVT_MENU, self.OnDeleteIndexMenu,

   402

              id=ID_EDITINGPANELINDEXLISTMENUITEMS1)

   403

        self.Bind(wx.EVT_MENU, self.OnModifyIndexMenu,

   404

              id=ID_EDITINGPANELINDEXLISTMENUITEMS2)

   405

   406

    def _init_utils(self):

   407

        self.IndexListMenu = wx.Menu(title='')

   408

        self.SubindexGridMenu = wx.Menu(title='')

   409

   410

        self._init_coll_IndexListMenu_Items(self.IndexListMenu)

   411

        self._init_coll_SubindexGridMenu_Items(self.SubindexGridMenu)

   412

   413

    def _init_sizers(self):

   414

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

   415

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

   416

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

   417

   418

        self._init_coll_IndexListSizer_Growables(self.IndexListSizer)

   419

        self._init_coll_IndexListSizer_Items(self.IndexListSizer)

   420

        self._init_coll_SubindexGridSizer_Growables(self.SubindexGridSizer)

   421

        self._init_coll_SubindexGridSizer_Items(self.SubindexGridSizer)

   422

        self._init_coll_AddToListSizer_Growables(self.AddToListSizer)

   423

        self._init_coll_AddToListSizer_Items(self.AddToListSizer)

   424

   425

        self.SubindexGridPanel.SetSizer(self.SubindexGridSizer)

   426

        self.IndexListPanel.SetSizer(self.IndexListSizer)

   427

   428

    def _init_ctrls(self, prnt):

   429

        wx.SplitterWindow.__init__(self, id=ID_EDITINGPANEL,

   430

              name='MainSplitter', parent=prnt, point=wx.Point(0, 0),

   431

              size=wx.Size(-1, -1), style=wx.SP_3D)

   432

        self._init_utils()

   433

        self.SetNeedUpdating(True)

   434

   435

        self.PartList = wx.ListBox(choices=[], id=ID_EDITINGPANELPARTLIST,

   436

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

   437

              size=wx.Size(-1, -1), style=0)

   438

        self.PartList.Bind(wx.EVT_LISTBOX, self.OnPartListBoxClick,

   439

              id=ID_EDITINGPANELPARTLIST)

   440

   441

        self.SecondSplitter = wx.SplitterWindow(id=ID_EDITINGPANELSECONDSPLITTER,

   442

              name='SecondSplitter', parent=self, point=wx.Point(0, 0), 

   443

              size=wx.Size(-1, -1), style=wx.SP_3D)

   444

        self.SplitHorizontally(self.PartList, self.SecondSplitter, 110)

   445

        self.SetMinimumPaneSize(1)

   446

   447

        self.SubindexGridPanel = wx.Panel(id=ID_EDITINGPANELSUBINDEXGRIDPANEL,

   448

              name='SubindexGridPanel', parent=self.SecondSplitter, 

   449

              pos=wx.Point(0, 0), size=wx.Size(-1, -1), style=wx.TAB_TRAVERSAL)

   450

   451

        self.IndexListPanel = wx.Panel(id=ID_EDITINGPANELINDEXLISTPANEL,

   452

              name='IndexListPanel', parent=self.SecondSplitter, 

   453

              pos=wx.Point(0, 0), size=wx.Size(-1, -1), style=wx.TAB_TRAVERSAL)

   454

        self.SecondSplitter.SplitVertically(self.IndexListPanel, self.SubindexGridPanel, 280)

   455

        self.SecondSplitter.SetMinimumPaneSize(1)

   456

   457

        self.SubindexGrid = wx.grid.Grid(id=ID_EDITINGPANELSUBINDEXGRID,

   458

              name='SubindexGrid', parent=self.SubindexGridPanel, pos=wx.Point(0,

   459

              0), size=wx.Size(-1, -1), style=0)

   460

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

   461

              'Sans'))

   462

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

   463

              False, 'Sans'))

   464

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

   465

              self.OnSubindexGridCellChange)

   466

        self.SubindexGrid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK,

   467

              self.OnSubindexGridRightClick)

   468

        self.SubindexGrid.Bind(wx.grid.EVT_GRID_SELECT_CELL,

   469

              self.OnSubindexGridSelectCell)

   470

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

   471

              self.OnSubindexGridCellLeftClick)

   472

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

   473

              self.OnSubindexGridEditorShown)

   474

   475

        self.CallbackCheck = wx.CheckBox(id=ID_EDITINGPANELCALLBACKCHECK,

   476

              label=_('Have Callbacks'), name='CallbackCheck',

   477

              parent=self.SubindexGridPanel, pos=wx.Point(0, 0), size=wx.Size(152,

   478

              24), style=0)

   479

        self.CallbackCheck.Bind(wx.EVT_CHECKBOX, self.OnCallbackCheck,

   480

              id=ID_EDITINGPANELCALLBACKCHECK)

   481

   482

        self.IndexList = wx.ListBox(choices=[], id=ID_EDITINGPANELINDEXLIST,

   483

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

   484

              size=wx.Size(-1, -1), style=0)

   485

        self.IndexList.Bind(wx.EVT_LISTBOX, self.OnIndexListClick,

   486

              id=ID_EDITINGPANELINDEXLIST)

   487

        self.IndexList.Bind(wx.EVT_RIGHT_UP, self.OnIndexListRightUp)

   488

   489

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

   490

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

   491

              size=wx.DefaultSize, style=0)

   492

        self.AddButton.Bind(wx.EVT_BUTTON, self.OnAddButtonClick,

   493

              id=ID_EDITINGPANELADDBUTTON)

   494

   495

        self.IndexChoice = wx.ComboBox(choices=[], id=ID_EDITINGPANELINDEXCHOICE,

   496

              name='IndexChoice', parent=self.IndexListPanel, pos=wx.Point(50,

   497

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

   498

   499

        self._init_sizers()

   500

   501

    def __init__(self, parent, window, manager, editable = True):

   502

        self.Editable = editable

   503

        self._init_ctrls(parent)

   504

        self.ParentWindow = window