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

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

    98

    99

class SubindexTable(wx.grid.PyGridTableBase):

   100

   101

    """

   102

    A custom wxGrid Table using user supplied data

   103

    """

   104

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

   105

        # The base class must be initialized *first*

   106

        wx.grid.PyGridTableBase.__init__(self)

   107

        self.data = data

   108

        self.editors = editors

   109

        self.CurrentIndex = 0

   110

        self.colnames = colnames

   111

        self.Parent = parent

   112

        self.Editable = True

   113

        # XXX

   114

        # we need to store the row length and collength to

   115

        # see if the table has changed size

   116

        self._rows = self.GetNumberRows()

   117

        self._cols = self.GetNumberCols()

   118

   119

    def Disable(self):

   120

        self.Editable = False

   121

   122

    def Enable(self):

   123

        self.Editable = True

   124

   125

    def GetNumberCols(self):

   126

        return len(self.colnames)

   127

   128

    def GetNumberRows(self):

   129

        return len(self.data)

   130

   131

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

   132

        if col < len(self.colnames):

   133

            if translate:

   134

                return _(self.colnames[col])

   135

            return self.colnames[col]

   136

   137

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

   138

        return row

   139

   140

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

   141

        if row < self.GetNumberRows():

   142

            colname = self.GetColLabelValue(col, False)

   143

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

   144

            if translate and (colname == "access" or 

   145

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

   146

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

   147

                value = _(value)

   148

            return value

   149

   150

    def GetEditor(self, row, col):

   151

        if row < self.GetNumberRows():

   152

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

   153

   154

    def GetValueByName(self, row, colname):

   155

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

   156

   157

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

   158

        if col < len(self.colnames):

   159

            colname = self.GetColLabelValue(col, False)

   160

            if colname == "access":

   161

                value = ACCESS_LIST_DICT[value]

   162

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

   163

                value = BOOL_LIST_DICT[value]

   164

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

   165

                value = OPTION_LIST_DICT[value]

   166

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

   167

                value = "None"

   168

            self.data[row][colname] = value

   169

   170

    def ResetView(self, grid):

   171

        """

   172

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

   173

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

   174

        """

   175

        grid.BeginBatch()

   176

        for current, new, delmsg, addmsg in [

   177

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

   178

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

   179

        ]:

   180

            if new < current:

   181

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

   182

                grid.ProcessTableMessage(msg)

   183

            elif new > current:

   184

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

   185

                grid.ProcessTableMessage(msg)

   186

                self.UpdateValues(grid)

   187

        grid.EndBatch()

   188

   189

        self._rows = self.GetNumberRows()

   190

        self._cols = self.GetNumberCols()

   191

        # update the column rendering scheme

   192

        self._updateColAttrs(grid)

   193

   194

        # update the scrollbars and the displayed part of the grid

   195

        grid.AdjustScrollbars()

   196

        grid.ForceRefresh()

   197

   198

   199

    def UpdateValues(self, grid):

   200

        """Update all displayed values"""

   201

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

   202

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

   203

        grid.ProcessTableMessage(msg)

   204

   205

    def _updateColAttrs(self, grid):

   206

        """

   207

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

   208

        appropriate renderer given the column name.

   209

   210

        Otherwise default to the default renderer.

   211

        """

   212

   213

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

   214

            attr = wx.grid.GridCellAttr()

   215

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

   216

            grid.SetColAttr(col, attr)

   217

            grid.SetColMinimalWidth(col, ColSizes[col])

   218

            grid.AutoSizeColumn(col, False)

   219

   220

        typelist = None

   221

        maplist = None

   222

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

   223

            editors = self.editors[row]

   224

            grid.SetRowMinimalHeight(row, 28)

   225

            grid.AutoSizeRow(row, False)

   226

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

   227

                editor = None

   228

                renderer = None

   229

   230

                colname = self.GetColLabelValue(col, False)

   231

                editortype = editors[colname]

   232

                if editortype and self.Editable:

   233

                    grid.SetReadOnly(row, col, False)

   234

                    if editortype == "string":

   235

                        editor = wx.grid.GridCellTextEditor()

   236

                        renderer = wx.grid.GridCellStringRenderer()

   237

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

   238

                            editor.SetParameters(editors["length"]) 

   239

                    elif editortype == "number":

   240

                        editor = wx.grid.GridCellNumberEditor()

   241

                        renderer = wx.grid.GridCellNumberRenderer()

   242

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

   243

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

   244

                    elif editortype == "float":

   245

                        editor = wx.grid.GridCellTextEditor()

   246

                        renderer = wx.grid.GridCellStringRenderer()

   247

                    elif editortype == "bool":

   248

                        editor = wx.grid.GridCellChoiceEditor()

   249

                        editor.SetParameters(BoolList)

   250

                    elif editortype == "access":

   251

                        editor = wx.grid.GridCellChoiceEditor()

   252

                        editor.SetParameters(AccessList)

   253

                    elif editortype == "raccess":

   254

                        editor = wx.grid.GridCellChoiceEditor()

   255

                        editor.SetParameters(RAccessList)

   256

                    elif editortype == "option":

   257

                        editor = wx.grid.GridCellChoiceEditor()

   258

                        editor.SetParameters(OptionList)

   259

                    elif editortype == "type":

   260

                        editor = wx.grid.GridCellChoiceEditor()

   261

                        if typelist == None:

   262

                            typelist = self.Parent.Manager.GetCurrentTypeList()

   263

                        editor.SetParameters(typelist)

   264

                    elif editortype == "map":

   265

                        editor = wx.grid.GridCellChoiceEditor()

   266

                        if maplist == None:

   267

                            maplist = self.Parent.Manager.GetCurrentMapList()

   268

                        editor.SetParameters(maplist)

   269

                    elif editortype == "time":

   270

                        editor = wx.grid.GridCellTextEditor()

   271

                        renderer = wx.grid.GridCellStringRenderer()

   272

                    elif editortype == "domain":

   273

                        editor = wx.grid.GridCellTextEditor()

   274

                        renderer = wx.grid.GridCellStringRenderer()

   275

                    elif editortype == "dcf":

   276

                        editor = wx.grid.GridCellTextEditor()

   277

                        renderer = wx.grid.GridCellStringRenderer()

   278

                else:

   279

                    grid.SetReadOnly(row, col, True)

   280

   281

                grid.SetCellEditor(row, col, editor)

   282

                grid.SetCellRenderer(row, col, renderer)

   283

   284

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

   285

   286

    def SetData(self, data):

   287

        self.data = data

   288

   289

    def SetEditors(self, editors):

   290

        self.editors = editors

   291

   292

    def GetCurrentIndex(self):

   293

        return self.CurrentIndex

   294

   295

    def SetCurrentIndex(self, index):

   296

        self.CurrentIndex = index

   297

   298

    def AppendRow(self, row_content):

   299

        self.data.append(row_content)

   300

   301

    def Empty(self):

   302

        self.data = []

   303

        self.editors = []

   304

   305

[ID_EDITINGPANEL, ID_EDITINGPANELADDBUTTON, ID_EDITINGPANELINDEXCHOICE, 

   306

 ID_EDITINGPANELINDEXLIST, ID_EDITINGPANELINDEXLISTPANEL, ID_EDITINGPANELPARTLIST, 

   307

 ID_EDITINGPANELSECONDSPLITTER, ID_EDITINGPANELSUBINDEXGRID,

   308

 ID_EDITINGPANELSUBINDEXGRIDPANEL, ID_EDITINGPANELCALLBACKCHECK,

   309

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

   310

   311

[ID_EDITINGPANELINDEXLISTMENUITEMS0, ID_EDITINGPANELINDEXLISTMENUITEMS1, 

   312

 ID_EDITINGPANELINDEXLISTMENUITEMS2, 

   313

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

   314

   315

[ID_EDITINGPANELMENU1ITEMS0, ID_EDITINGPANELMENU1ITEMS1, 

   316

 ID_EDITINGPANELMENU1ITEMS3, ID_EDITINGPANELMENU1ITEMS4, 

   317

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

   318

   319

class EditingPanel(wx.SplitterWindow):

   320

    def _init_coll_AddToListSizer_Items(self, parent):

   321

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

   322

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

   323

   324

    def _init_coll_SubindexGridSizer_Items(self, parent):

   325

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

   326

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

   327

   328

    def _init_coll_IndexListSizer_Items(self, parent):

   329

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

   330

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

   331

   332

    def _init_coll_AddToListSizer_Growables(self, parent):

   333

        parent.AddGrowableCol(1)

   334

   335

    def _init_coll_SubindexGridSizer_Growables(self, parent):

   336

        parent.AddGrowableCol(0)

   337

        parent.AddGrowableRow(1)

   338

   339

    def _init_coll_IndexListSizer_Growables(self, parent):

   340

        parent.AddGrowableCol(0)

   341

        parent.AddGrowableRow(0)

   342

   343

    def _init_coll_SubindexGridMenu_Items(self, parent):

   344

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

   345

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

   346

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

   347

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

   348

        parent.AppendSeparator()

   349

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

   350

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

   351

        if not self.Editable:

   352

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

   353

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

   354

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

   355

              id=ID_EDITINGPANELMENU1ITEMS0)

   356

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

   357

              id=ID_EDITINGPANELMENU1ITEMS1)

   358

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

   359

              id=ID_EDITINGPANELMENU1ITEMS3)

   360

        if not self.Editable:

   361

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

   362

                  id=ID_EDITINGPANELMENU1ITEMS4)

   363

   364

    def _init_coll_IndexListMenu_Items(self, parent):

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

              id=ID_EDITINGPANELINDEXLISTMENUITEMS0)

   373

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

   374

              id=ID_EDITINGPANELINDEXLISTMENUITEMS1)

   375

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

   376

              id=ID_EDITINGPANELINDEXLISTMENUITEMS2)

   377

   378

    def _init_utils(self):

   379

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

   380

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

   381

   382

        self._init_coll_IndexListMenu_Items(self.IndexListMenu)

   383

        self._init_coll_SubindexGridMenu_Items(self.SubindexGridMenu)

   384

   385

    def _init_sizers(self):

   386

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

   387

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

   388

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

   389

   390

        self._init_coll_IndexListSizer_Growables(self.IndexListSizer)

   391

        self._init_coll_IndexListSizer_Items(self.IndexListSizer)

   392

        self._init_coll_SubindexGridSizer_Growables(self.SubindexGridSizer)

   393

        self._init_coll_SubindexGridSizer_Items(self.SubindexGridSizer)

   394

        self._init_coll_AddToListSizer_Growables(self.AddToListSizer)

   395

        self._init_coll_AddToListSizer_Items(self.AddToListSizer)

   396

   397

        self.SubindexGridPanel.SetSizer(self.SubindexGridSizer)

   398

        self.IndexListPanel.SetSizer(self.IndexListSizer)

   399

   400

    def _init_ctrls(self, prnt):

   401

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

   402

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

   403

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

   404

        self._init_utils()

   405

        self.SetNeedUpdating(True)

   406

        self.SetMinimumPaneSize(1)

   407

   408

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

   409

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

   410

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

   411

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

   412

              id=ID_EDITINGPANELPARTLIST)

   413

   414

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

   415

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

   416

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

   417

        self.SecondSplitter.SetMinimumPaneSize(1)

   418

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

   419

              110)

   420

   421

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

   422

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

   423

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

   424

   425

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

   426

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

   427

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

   428

        self.SecondSplitter.SplitVertically(self.IndexListPanel,

   429

              self.SubindexGridPanel, 280)

   430

   431

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

   432

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

   433

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

   434

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

   435

              'Sans'))

   436

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

   437

              False, 'Sans'))

   438

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

   439

              self.OnSubindexGridCellChange)

   440

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

   441

              self.OnSubindexGridRightClick)

   442

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

   443

              self.OnSubindexGridSelectCell)

   444

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

   445

              self.OnSubindexGridCellLeftClick)

   446

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

   447

              self.OnSubindexGridEditorShown)

   448

   449

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

   450

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

   451

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

   452

              24), style=0)

   453

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

   454

              id=ID_EDITINGPANELCALLBACKCHECK)

   455

   456

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

   457

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

   458

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

   459

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

   460

              id=ID_EDITINGPANELINDEXLIST)

   461

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

   462

   463

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

   464

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

   465

              size=wx.DefaultSize, style=0)

   466

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

   467

              id=ID_EDITINGPANELADDBUTTON)

   468

   469

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

   470

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

   471

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

   472

   473

        self._init_sizers()

   474

   475

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

   476

        self.Editable = editable

   477

        self._init_ctrls(parent)

   478

        self.ParentWindow = window

   479

        self.Manager = manager

   480

        self.ListIndex = []

   481

        self.ChoiceIndex = []

   482

        self.FirstCall = False

   483

        self.Index = None

   484

   485

        for values in DictionaryOrganisation:

   486

            text = "   0x%04X-0x%04X      %s"%(values["minIndex"], values["maxIndex"], values["name"])

   487

            self.PartList.Append(text)

   488

        self.Table = SubindexTable(self, [], [], GetSubindexTableColnames())

   489

        self.SubindexGrid.SetTable(self.Table)

   490

        self.SubindexGrid.SetRowLabelSize(0)

   491

        self.CallbackCheck.Disable()

   492

        self.Table.ResetView(self.SubindexGrid)

   493

   494

        if not self.Editable:

   495

            self.AddButton.Disable()

   496

            self.IndexChoice.Disable()

   497

            self.CallbackCheck.Disable()

   498

            self.Table.Disable()

   499

   500

    def GetIndex(self):

   501

        return self.Index

   502

   503

    def SetIndex(self, index):

   504

        self.Index = index

   505

   506

    def GetSelection(self):