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

AccessList = "Read Only,Write Only,Read/Write"

    35

RAccessList = "Read Only,Read/Write"

    36

BoolList = "True,False"

    37

OptionList = "Yes,No"

    38

    39

DictionaryOrganisation = [

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

    52

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

    53

    54

class SubindexTable(wx.grid.PyGridTableBase):

    55

    56

    """

    57

    A custom wxGrid Table using user supplied data

    58

    """

    59

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

    60

        # The base class must be initialized *first*

    61

        wx.grid.PyGridTableBase.__init__(self)

    62

        self.data = data

    63

        self.editors = editors

    64

        self.CurrentIndex = 0

    65

        self.colnames = colnames

    66

        self.Parent = parent

    67

        self.Editable = True

    68

        # XXX

    69

        # we need to store the row length and collength to

    70

        # see if the table has changed size

    71

        self._rows = self.GetNumberRows()

    72

        self._cols = self.GetNumberCols()

    73

    74

    def Disable(self):

    75

        self.Editable = False

    76

    77

    def Enable(self):

    78

        self.Editable = True

    79

    80

    def GetNumberCols(self):

    81

        return len(self.colnames)

    82

    83

    def GetNumberRows(self):

    84

        return len(self.data)

    85

    86

    def GetColLabelValue(self, col):

    87

        if col < len(self.colnames):

    88

            return self.colnames[col]

    89

    90

    def GetRowLabelValues(self, row):

    91

        return row

    92

    93

    def GetValue(self, row, col):

    94

        if row < self.GetNumberRows():

    95

            return str(self.data[row].get(self.GetColLabelValue(col), ""))

    96

    97

    def GetEditor(self, row, col):

    98

        if row < self.GetNumberRows():

    99

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

   100

   101

    def GetValueByName(self, row, colname):

   102

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

   103

   104

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

   105

        if col < len(self.colnames):

   106

            self.data[row][self.GetColLabelValue(col)] = value

   107

   108

    def ResetView(self, grid):

   109

        """

   110

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

   111

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

   112

        """

   113

        grid.BeginBatch()

   114

        for current, new, delmsg, addmsg in [

   115

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

   116

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

   117

        ]:

   118

            if new < current:

   119

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

   120

                grid.ProcessTableMessage(msg)

   121

            elif new > current:

   122

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

   123

                grid.ProcessTableMessage(msg)

   124

                self.UpdateValues(grid)

   125

        grid.EndBatch()

   126

   127

        self._rows = self.GetNumberRows()

   128

        self._cols = self.GetNumberCols()

   129

        # update the column rendering scheme

   130

        self._updateColAttrs(grid)

   131

   132

        # update the scrollbars and the displayed part of the grid

   133

        grid.AdjustScrollbars()

   134

        grid.ForceRefresh()

   135

   136

   137

    def UpdateValues(self, grid):

   138

        """Update all displayed values"""

   139

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

   140

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

   141

        grid.ProcessTableMessage(msg)

   142

   143

    def _updateColAttrs(self, grid):

   144

        """

   145

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

   146

        appropriate renderer given the column name.

   147

   148

        Otherwise default to the default renderer.

   149

        """

   150

   151

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

   152

            attr = wx.grid.GridCellAttr()

   153

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

   154

            grid.SetColAttr(col, attr)

   155

            grid.SetColSize(col, ColSizes[col])

   156

   157

        typelist = None

   158

        maplist = None

   159

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

   160

            editors = self.editors[row]

   161

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

   162

                editor = None

   163

                renderer = None

   164

   165

                colname = self.GetColLabelValue(col)

   166

                editortype = editors[colname]

   167

                if editortype and self.Editable:

   168

                    grid.SetReadOnly(row, col, False)

   169

                    if editortype == "string":

   170

                        editor = wx.grid.GridCellTextEditor()

   171

                        renderer = wx.grid.GridCellStringRenderer()

   172

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

   173

                            editor.SetParameters(editors["length"]) 

   174

                    elif editortype == "number":

   175

                        editor = wx.grid.GridCellNumberEditor()

   176

                        renderer = wx.grid.GridCellNumberRenderer()

   177

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

   178

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

   179

                    elif editortype == "real":

   180

                        editor = wx.grid.GridCellFloatEditor()

   181

                        renderer = wx.grid.GridCellFloatRenderer()

   182

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

   183

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

   184

                    elif editortype == "bool":

   185

                        editor = wx.grid.GridCellChoiceEditor()

   186

                        editor.SetParameters(BoolList)

   187

                    elif editortype == "access":

   188

                        editor = wx.grid.GridCellChoiceEditor()

   189

                        editor.SetParameters(AccessList)

   190

                    elif editortype == "raccess":

   191

                        editor = wx.grid.GridCellChoiceEditor()

   192

                        editor.SetParameters(RAccessList)

   193

                    elif editortype == "option":

   194

                        editor = wx.grid.GridCellChoiceEditor()

   195

                        editor.SetParameters(OptionList)

   196

                    elif editortype == "type":

   197

                        editor = wx.grid.GridCellChoiceEditor()

   198

                        if typelist == None:

   199

                            typelist = self.Parent.Manager.GetCurrentTypeList()

   200

                        editor.SetParameters(typelist)

   201

                    elif editortype == "map":

   202

                        editor = wx.grid.GridCellChoiceEditor()

   203

                        if maplist == None:

   204

                            maplist = self.Parent.Manager.GetCurrentMapList()

   205

                        editor.SetParameters(maplist)

   206

                    elif editortype == "time":

   207

                        editor = wx.grid.GridCellTextEditor()

   208

                        renderer = wx.grid.GridCellStringRenderer()

   209

                    elif editortype == "domain":

   210

                        editor = wx.grid.GridCellTextEditor()

   211

                        renderer = wx.grid.GridCellStringRenderer()

   212

                else:

   213

                    grid.SetReadOnly(row, col, True)

   214

   215

                grid.SetCellEditor(row, col, editor)

   216

                grid.SetCellRenderer(row, col, renderer)

   217

   218

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

   219

   220

    def SetData(self, data):

   221

        self.data = data

   222

   223

    def SetEditors(self, editors):

   224

        self.editors = editors

   225

   226

    def GetCurrentIndex(self):

   227

        return self.CurrentIndex

   228

   229

    def SetCurrentIndex(self, index):

   230

        self.CurrentIndex = index

   231

   232

    def AppendRow(self, row_content):

   233

        self.data.append(row_content)

   234

   235

    def Empty(self):

   236

        self.data = []

   237

        self.editors = []

   238

   239

[ID_EDITINGPANEL, ID_EDITINGPANELADDBUTTON, ID_EDITINGPANELINDEXCHOICE, 

   240

 ID_EDITINGPANELINDEXLIST, ID_EDITINGPANELINDEXLISTPANEL, ID_EDITINGPANELPARTLIST, 

   241

 ID_EDITINGPANELSECONDSPLITTER, ID_EDITINGPANELSUBINDEXGRID,

   242

 ID_EDITINGPANELSUBINDEXGRIDPANEL, ID_EDITINGPANELCALLBACKCHECK,

   243

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

   244

   245

[ID_EDITINGPANELINDEXLISTMENUITEMS0, ID_EDITINGPANELINDEXLISTMENUITEMS1, 

   246

 ID_EDITINGPANELINDEXLISTMENUITEMS2, 

   247

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

   248

   249

[ID_EDITINGPANELMENU1ITEMS0, ID_EDITINGPANELMENU1ITEMS1, 

   250

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

   251

   252

class EditingPanel(wx.SplitterWindow):

   253

    def _init_coll_AddToListSizer_Items(self, parent):

   254

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

   255

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

   256

   257

    def _init_coll_SubindexGridSizer_Items(self, parent):

   258

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

   259

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

   260

   261

    def _init_coll_IndexListSizer_Items(self, parent):

   262

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

   263

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

   264

   265

    def _init_coll_AddToListSizer_Growables(self, parent):

   266

        parent.AddGrowableCol(1)

   267

   268

    def _init_coll_SubindexGridSizer_Growables(self, parent):

   269

        parent.AddGrowableCol(0)

   270

        parent.AddGrowableRow(1)

   271

   272

    def _init_coll_IndexListSizer_Growables(self, parent):

   273

        parent.AddGrowableCol(0)

   274

        parent.AddGrowableRow(0)

   275

   276

    def _init_coll_SubindexGridMenu_Items(self, parent):

   277

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

   278

              kind=wx.ITEM_NORMAL, text='Add')

   279

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

   280

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

   281

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

   282

              id=ID_EDITINGPANELMENU1ITEMS0)

   283

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

   284

              id=ID_EDITINGPANELMENU1ITEMS1)

   285

   286

    def _init_coll_IndexListMenu_Items(self, parent):

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

              id=ID_EDITINGPANELINDEXLISTMENUITEMS0)

   295

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

   296

              id=ID_EDITINGPANELINDEXLISTMENUITEMS1)

   297

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

   298

              id=ID_EDITINGPANELINDEXLISTMENUITEMS2)

   299

   300

    def _init_utils(self):

   301

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

   302

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

   303

   304

        self._init_coll_IndexListMenu_Items(self.IndexListMenu)

   305

        self._init_coll_SubindexGridMenu_Items(self.SubindexGridMenu)

   306

   307

    def _init_sizers(self):

   308

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

   309

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

   310

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

   311

   312

        self._init_coll_IndexListSizer_Growables(self.IndexListSizer)

   313

        self._init_coll_IndexListSizer_Items(self.IndexListSizer)

   314

        self._init_coll_SubindexGridSizer_Growables(self.SubindexGridSizer)

   315

        self._init_coll_SubindexGridSizer_Items(self.SubindexGridSizer)

   316

        self._init_coll_AddToListSizer_Growables(self.AddToListSizer)

   317

        self._init_coll_AddToListSizer_Items(self.AddToListSizer)

   318

   319

        self.SubindexGridPanel.SetSizer(self.SubindexGridSizer)

   320

        self.IndexListPanel.SetSizer(self.IndexListSizer)

   321

   322

    def _init_ctrls(self, prnt):

   323

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

   324

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

   325

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

   326

        self._init_utils()

   327

        self.SetNeedUpdating(True)

   328

        self.SetMinimumPaneSize(1)

   329

   330

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

   331

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

   332

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

   333

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

   334

              id=ID_EDITINGPANELPARTLIST)

   335

   336

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

   337

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

   338

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

   339

        self.SecondSplitter.SetMinimumPaneSize(1)

   340

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

   341

              110)

   342

   343

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

   344

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

   345

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

   346

   347

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

   348

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

   349

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

   350

        self.SecondSplitter.SplitVertically(self.IndexListPanel,

   351

              self.SubindexGridPanel, 280)

   352

   353

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

   354

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

   355

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

   356

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

   357

              'Sans'))

   358

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

   359

              False, 'Sans'))

   360

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

   361

              self.OnSubindexGridCellChange)

   362

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

   363

              self.OnSubindexGridRightClick)

   364

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

   365

              self.OnSubindexGridSelectCell)

   366

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

   367

   368

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

   369

              label='Have Callbacks', name='CallbackCheck',

   370

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

   371

              24), style=0)

   372

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

   373

              id=ID_EDITINGPANELCALLBACKCHECK)

   374

   375

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

   376

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

   377

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

   378

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

   379

              id=ID_EDITINGPANELINDEXLIST)

   380

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

   381

   382

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

   383

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

   384

              size=wx.Size(50, 30), style=0)

   385

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

   386

              id=ID_EDITINGPANELADDBUTTON)

   387

   388

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

   389

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

   390

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

   391

   392

        self._init_sizers()

   393

   394

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

   395

        self._init_ctrls(parent.GetNoteBook())

   396

        self.ParentWindow = parent

   397

        self.Manager = manager

   398

        self.ListIndex = []

   399

        self.ChoiceIndex = []

   400

        self.FirstCall = False

   401

        self.Editable = editable

   402

        self.Index = None

   403

   404

        for values in DictionaryOrganisation:

   405

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

   406

            self.PartList.Append(text)

   407

        self.Table = SubindexTable(self, [], [], ["subindex", "name", "type", "value", "access", "save", "comment"])

   408

        self.SubindexGrid.SetTable(self.Table)

   409

        self.SubindexGrid.SetRowLabelSize(0)

   410

        self.CallbackCheck.Disable()

   411

        self.Table.ResetView(self.SubindexGrid)

   412

   413

        if not self.Editable:

   414

            self.AddButton.Disable()

   415

            self.IndexChoice.Disable()

   416

            self.CallbackCheck.Disable()

   417

            self.Table.Disable()

   418

   419

    def GetIndex(self):

   420

        return self.Index

   421

   422

    def SetIndex(self, index):

   423

        self.Index = index

   424

   425

    def GetSelection(self):

   426

        selected = self.IndexList.GetSelection()

   427

        if selected != wx.NOT_FOUND:

   428

            index = self.ListIndex[selected]

   429

            subIndex = self.SubindexGrid.GetGridCursorRow()

   430

            return index, subIndex

   431

        return None

   432

   433

    def OnSubindexGridCellLeftClick(self, event):

   434

        wx.CallAfter(self.BeginDrag)

   435

        event.Skip()

   436

   437

    def OnAddButtonClick(self, event):

   438

        if self.Editable:

   439

            self.SubindexGrid.SetGridCursor(0, 0)

   440

            selected = self.IndexChoice.GetStringSelection()

   441

            if selected != "":

   442

                if selected == "User Type":

   443

                    self.ParentWindow.AddUserType()

   444

                elif selected == "SDO Server":

   445

                    self.Manager.AddSDOServerToCurrent()

   446

                elif selected == "SDO Client":

   447

                    self.Manager.AddSDOClientToCurrent()

   448

                elif selected == "PDO Receive":

   449

                    self.Manager.AddPDOReceiveToCurrent()

   450

                elif selected == "PDO Transmit":

   451

                    self.Manager.AddPDOTransmitToCurrent()

   452

                elif selected == "Map Variable":

   453

                    self.ParentWindow.AddMapVariable()

   454

                elif selected in [menu for menu, indexes in self.Manager.GetCurrentSpecificMenu()]:

   455

                    self.Manager.AddSpecificEntryToCurrent(selected)

   456

                else:

   457

                    index = self.ChoiceIndex[self.IndexChoice.GetSelection()]

   458

                    self.Manager.ManageEntriesOfCurrent([index], [])

   459

                self.ParentWindow.RefreshBufferState()

   460

                self.RefreshIndexList()

   461

        event.Skip()

   462

   463

    def OnPartListBoxClick(self, event):

   464

        self.SubindexGrid.SetGridCursor(0, 0)

   465

        self.RefreshIndexList()

   466

        event.Skip()

   467

   468

    def OnIndexListClick(self, event):

   469

        self.SubindexGrid.SetGridCursor(0, 0)

   470

        self.RefreshTable()

   471

        event.Skip()

   472

   473

    def OnSubindexGridSelectCell(self, event):

   474

        wx.CallAfter(self.BeginDrag)

   475

        wx.CallAfter(self.ParentWindow.RefreshStatusBar)

   476

        event.Skip()

   477

   478

    def BeginDrag(self):

   479

        if not self.ParentWindow.ModeSolo:

   480

            row = self.SubindexGrid.GetGridCursorRow()

   481

            col = self.SubindexGrid.GetGridCursorCol()

   482

            if not self.Editable and col == 0:

   483

                selected = self.IndexList.GetSelection()

   484

                if selected != wx.NOT_FOUND:

   485

                    index = self.ListIndex[selected]

   486

                    subindex = self.SubindexGrid.GetGridCursorRow()

   487

                    entry_infos = self.Manager.GetEntryInfos(index)

   488

                    if not entry_infos["struct"] & OD_MultipleSubindexes or row != 0:

   489

                        subentry_infos = self.Manager.GetSubentryInfos(index, subindex)

   490

                        typeinfos = self.Manager.GetEntryInfos(subentry_infos["type"])

   491

                        if subentry_infos["pdo"] and typeinfos:

   492

                            bus_id = '.'.join(map(str,self.ParentWindow.GetBusId()))

   493

                            node_id = self.ParentWindow.GetCurrentNodeId()

   494

                            size = typeinfos["size"]

   495

                            data = wx.TextDataObject(str(("%s%s.%d.%d.%d"%(SizeConversion[size], bus_id, node_id, index, subindex), "location")))

   496

                            dragSource = wx.DropSource(self.SubindexGrid)

   497

                            dragSource.SetData(data)

   498

                            dragSource.DoDragDrop()

   499

   500

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

   501

#                             Refresh Functions

   502

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

   503

   504

    def RefreshIndexList(self):

   505

        selected = self.IndexList.GetSelection()

   506

        choice = self.IndexChoice.GetStringSelection()

   507

        choiceindex = self.IndexChoice.GetSelection()

   508

        if selected != wx.NOT_FOUND:

   509

            selectedindex = self.ListIndex[selected]

   510

        self.IndexList.Clear()

   511

        self.IndexChoice.Clear()

   512

        i = self.PartList.GetSelection()

   513