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

            grid.SetRowMinimalHeight(row, 28)

   250

            grid.AutoSizeRow(row, False)

   251

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

   252

                editor = None

   253

                renderer = None

   254

   255

                colname = self.GetColLabelValue(col, False)

   256

                editortype = editors[colname]

   257

                if editortype and self.Editable:

   258

                    grid.SetReadOnly(row, col, False)

   259

                    if editortype == "string":

   260

                        editor = wx.grid.GridCellTextEditor()

   261

                        renderer = wx.grid.GridCellStringRenderer()

   262

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

   263

                            editor.SetParameters(editors["length"]) 

   264

                    elif editortype == "number":

   265

                        editor = wx.grid.GridCellNumberEditor()

   266

                        renderer = wx.grid.GridCellNumberRenderer()

   267

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

   268

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

   269

                    elif editortype == "float":

   270

                        editor = wx.grid.GridCellTextEditor()

   271

                        renderer = wx.grid.GridCellStringRenderer()

   272

                    elif editortype == "bool":

   273

                        editor = wx.grid.GridCellChoiceEditor()

   274

                        editor.SetParameters(BoolList)

   275

                    elif editortype == "access":

   276

                        editor = wx.grid.GridCellChoiceEditor()

   277

                        editor.SetParameters(AccessList)

   278

                    elif editortype == "raccess":

   279

                        editor = wx.grid.GridCellChoiceEditor()

   280

                        editor.SetParameters(RAccessList)

   281

                    elif editortype == "option":

   282

                        editor = wx.grid.GridCellChoiceEditor()

   283

                        editor.SetParameters(OptionList)

   284

                    elif editortype == "type":

   285

                        editor = wx.grid.GridCellChoiceEditor()

   286

                        if typelist == None:

   287

                            typelist = self.Parent.Manager.GetCurrentTypeList()

   288

                        editor.SetParameters(typelist)

   289

                    elif editortype == "map":

   290

                        editor = wx.grid.GridCellChoiceEditor()

   291

                        if maplist == None:

   292

                            maplist = self.Parent.Manager.GetCurrentMapList()

   293

                        editor.SetParameters(maplist)

   294

                    elif editortype == "time":

   295

                        editor = wx.grid.GridCellTextEditor()

   296

                        renderer = wx.grid.GridCellStringRenderer()

   297

                    elif editortype == "domain":

   298

                        editor = wx.grid.GridCellTextEditor()

   299

                        renderer = wx.grid.GridCellStringRenderer()

   300

                    elif editortype == "dcf":

   301

                        editor = wx.grid.GridCellTextEditor()

   302

                        renderer = wx.grid.GridCellStringRenderer()

   303

                else:

   304

                    grid.SetReadOnly(row, col, True)

   305

   306

                grid.SetCellEditor(row, col, editor)

   307

                grid.SetCellRenderer(row, col, renderer)

   308

   309

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

   310

   311

    def SetData(self, data):

   312

        self.data = data

   313

   314

    def SetEditors(self, editors):

   315

        self.editors = editors

   316

   317

    def GetCurrentIndex(self):

   318

        return self.CurrentIndex

   319

   320

    def SetCurrentIndex(self, index):

   321

        self.CurrentIndex = index

   322

   323

    def AppendRow(self, row_content):

   324

        self.data.append(row_content)

   325

   326

    def Empty(self):

   327

        self.data = []

   328

        self.editors = []

   329

   330

[ID_EDITINGPANEL, ID_EDITINGPANELADDBUTTON, ID_EDITINGPANELINDEXCHOICE, 

   331

 ID_EDITINGPANELINDEXLIST, ID_EDITINGPANELINDEXLISTPANEL, ID_EDITINGPANELPARTLIST, 

   332

 ID_EDITINGPANELSECONDSPLITTER, ID_EDITINGPANELSUBINDEXGRID,

   333

 ID_EDITINGPANELSUBINDEXGRIDPANEL, ID_EDITINGPANELCALLBACKCHECK,

   334

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

   335

   336

[ID_EDITINGPANELINDEXLISTMENUITEMS0, ID_EDITINGPANELINDEXLISTMENUITEMS1, 

   337

 ID_EDITINGPANELINDEXLISTMENUITEMS2, 

   338

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

   339

   340

[ID_EDITINGPANELMENU1ITEMS0, ID_EDITINGPANELMENU1ITEMS1, 

   341

 ID_EDITINGPANELMENU1ITEMS3, ID_EDITINGPANELMENU1ITEMS4, 

   342

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

   343

   344

class EditingPanel(wx.SplitterWindow):

   345

    def _init_coll_AddToListSizer_Items(self, parent):

   346

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

   347

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

   348

   349

    def _init_coll_SubindexGridSizer_Items(self, parent):

   350

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

   351

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

   352

   353

    def _init_coll_IndexListSizer_Items(self, parent):

   354

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

   355

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

   356

   357

    def _init_coll_AddToListSizer_Growables(self, parent):

   358

        parent.AddGrowableCol(1)

   359

   360

    def _init_coll_SubindexGridSizer_Growables(self, parent):

   361

        parent.AddGrowableCol(0)

   362

        parent.AddGrowableRow(1)

   363

   364

    def _init_coll_IndexListSizer_Growables(self, parent):

   365

        parent.AddGrowableCol(0)

   366

        parent.AddGrowableRow(0)

   367

   368

    def _init_coll_SubindexGridMenu_Items(self, parent):

   369

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

   370

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

   371

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

   372

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

   373

        parent.AppendSeparator()

   374

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

   375

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

   376

        if not self.Editable:

   377

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

   378

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

   379

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

   380

              id=ID_EDITINGPANELMENU1ITEMS0)

   381

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

   382

              id=ID_EDITINGPANELMENU1ITEMS1)

   383

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

   384

              id=ID_EDITINGPANELMENU1ITEMS3)

   385

        if not self.Editable:

   386

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

   387

                  id=ID_EDITINGPANELMENU1ITEMS4)

   388

   389

    def _init_coll_IndexListMenu_Items(self, parent):

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

              id=ID_EDITINGPANELINDEXLISTMENUITEMS0)

   398

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

   399

              id=ID_EDITINGPANELINDEXLISTMENUITEMS1)

   400

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

   401

              id=ID_EDITINGPANELINDEXLISTMENUITEMS2)

   402

   403

    def _init_utils(self):

   404

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

   405

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

   406

   407

        self._init_coll_IndexListMenu_Items(self.IndexListMenu)

   408

        self._init_coll_SubindexGridMenu_Items(self.SubindexGridMenu)

   409

   410

    def _init_sizers(self):

   411

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

   412

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

   413

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

   414

   415

        self._init_coll_IndexListSizer_Growables(self.IndexListSizer)

   416

        self._init_coll_IndexListSizer_Items(self.IndexListSizer)

   417

        self._init_coll_SubindexGridSizer_Growables(self.SubindexGridSizer)

   418

        self._init_coll_SubindexGridSizer_Items(self.SubindexGridSizer)

   419

        self._init_coll_AddToListSizer_Growables(self.AddToListSizer)

   420

        self._init_coll_AddToListSizer_Items(self.AddToListSizer)

   421

   422

        self.SubindexGridPanel.SetSizer(self.SubindexGridSizer)

   423

        self.IndexListPanel.SetSizer(self.IndexListSizer)

   424

   425

    def _init_ctrls(self, prnt):

   426

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

   427

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

   428

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

   429

        self._init_utils()

   430

        self.SetNeedUpdating(True)

   431

        self.SetMinimumPaneSize(1)

   432

   433

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

   434

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

   435

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

   436

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

   437

              id=ID_EDITINGPANELPARTLIST)

   438

   439

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

   440

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

   441

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

   442

        self.SecondSplitter.SetMinimumPaneSize(1)

   443

        self.SplitHorizontally(self.PartList, self.SecondSplitter,

   444

              110)

   445

   446

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

   447

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

   448

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

   449

   450

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

   451

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

   452

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

   453

        self.SecondSplitter.SplitVertically(self.IndexListPanel,

   454

              self.SubindexGridPanel, 280)

   455

   456

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

   457

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

   458

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

   459

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

   460

              'Sans'))

   461

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

   462

              False, 'Sans'))

   463

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

   464

              self.OnSubindexGridCellChange)

   465

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

   466

              self.OnSubindexGridRightClick)

   467

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

   468

              self.OnSubindexGridSelectCell)

   469

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

   470

              self.OnSubindexGridCellLeftClick)

   471

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

   472

              self.OnSubindexGridEditorShown)

   473

   474

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

   475

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

   476

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

   477

              24), style=0)

   478

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

   479

              id=ID_EDITINGPANELCALLBACKCHECK)

   480

   481

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

   482

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

   483

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

   484

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

   485

              id=ID_EDITINGPANELINDEXLIST)

   486

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

   487

   488

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

   489

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

   490

              size=wx.DefaultSize, style=0)

   491

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

   492

              id=ID_EDITINGPANELADDBUTTON)

   493

   494

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

   495

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

   496

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

   497

   498

        self._init_sizers()

   499

   500

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

   501

        self.Editable = editable

   502

        self._init_ctrls(parent)

   503

        self.ParentWindow = window

   504

        self.Manager = manager

   505