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

   434

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

   435

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

   436

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

   437

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

   438

              id=ID_EDITINGPANELPARTLIST)

   439

   440

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

   441

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

   442

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

   443

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

   444

        self.SetMinimumPaneSize(1)

   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, self.SubindexGridPanel, 280)

   454

        self.SecondSplitter.SetMinimumPaneSize(1)

   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, wx.SWISS, wx.NORMAL, wx.NORMAL, False,

   460

              'Sans'))

   461

        self.SubindexGrid.SetLabelFont(wx.Font(10, wx.SWISS, 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)