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

                    elif editortype == "dcf":

   213

                        editor = wx.grid.GridCellTextEditor()

   214

                        renderer = wx.grid.GridCellStringRenderer()

   215

                else:

   216

                    grid.SetReadOnly(row, col, True)

   217

   218

                grid.SetCellEditor(row, col, editor)

   219

                grid.SetCellRenderer(row, col, renderer)

   220

   221

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

   222

   223

    def SetData(self, data):

   224

        self.data = data

   225

   226

    def SetEditors(self, editors):

   227

        self.editors = editors

   228

   229

    def GetCurrentIndex(self):

   230

        return self.CurrentIndex

   231

   232

    def SetCurrentIndex(self, index):

   233

        self.CurrentIndex = index

   234

   235

    def AppendRow(self, row_content):

   236

        self.data.append(row_content)

   237

   238

    def Empty(self):

   239

        self.data = []

   240

        self.editors = []

   241

   242

[ID_EDITINGPANEL, ID_EDITINGPANELADDBUTTON, ID_EDITINGPANELINDEXCHOICE, 

   243

 ID_EDITINGPANELINDEXLIST, ID_EDITINGPANELINDEXLISTPANEL, ID_EDITINGPANELPARTLIST, 

   244

 ID_EDITINGPANELSECONDSPLITTER, ID_EDITINGPANELSUBINDEXGRID,

   245

 ID_EDITINGPANELSUBINDEXGRIDPANEL, ID_EDITINGPANELCALLBACKCHECK,

   246

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

   247

   248

[ID_EDITINGPANELINDEXLISTMENUITEMS0, ID_EDITINGPANELINDEXLISTMENUITEMS1, 

   249

 ID_EDITINGPANELINDEXLISTMENUITEMS2, 

   250

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

   251

   252

[ID_EDITINGPANELMENU1ITEMS0, ID_EDITINGPANELMENU1ITEMS1, 

   253

 ID_EDITINGPANELMENU1ITEMS3, ID_EDITINGPANELMENU1ITEMS4, 

   254

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

   255

   256

class EditingPanel(wx.SplitterWindow):

   257

    def _init_coll_AddToListSizer_Items(self, parent):

   258

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

   259

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

   260

   261

    def _init_coll_SubindexGridSizer_Items(self, parent):

   262

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

   263

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

   264

   265

    def _init_coll_IndexListSizer_Items(self, parent):

   266

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

   267

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

   268

   269

    def _init_coll_AddToListSizer_Growables(self, parent):

   270

        parent.AddGrowableCol(1)

   271

   272

    def _init_coll_SubindexGridSizer_Growables(self, parent):

   273

        parent.AddGrowableCol(0)

   274

        parent.AddGrowableRow(1)

   275

   276

    def _init_coll_IndexListSizer_Growables(self, parent):

   277

        parent.AddGrowableCol(0)

   278

        parent.AddGrowableRow(0)

   279

   280

    def _init_coll_SubindexGridMenu_Items(self, parent):

   281

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

   282

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

   283

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

   284

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

   285

        parent.AppendSeparator()

   286

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

   287

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

   288

        if not self.Editable:

   289

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

   290

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

   291

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

   292

              id=ID_EDITINGPANELMENU1ITEMS0)

   293

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

   294

              id=ID_EDITINGPANELMENU1ITEMS1)

   295

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

   296

              id=ID_EDITINGPANELMENU1ITEMS3)

   297

        if not self.Editable:

   298

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

   299

                  id=ID_EDITINGPANELMENU1ITEMS4)

   300

   301

    def _init_coll_IndexListMenu_Items(self, parent):

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

              id=ID_EDITINGPANELINDEXLISTMENUITEMS0)

   310

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

   311

              id=ID_EDITINGPANELINDEXLISTMENUITEMS1)

   312

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

   313

              id=ID_EDITINGPANELINDEXLISTMENUITEMS2)

   314

   315

    def _init_utils(self):

   316

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

   317

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

   318

   319

        self._init_coll_IndexListMenu_Items(self.IndexListMenu)

   320

        self._init_coll_SubindexGridMenu_Items(self.SubindexGridMenu)

   321

   322

    def _init_sizers(self):

   323

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

   324

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

   325

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

   326

   327

        self._init_coll_IndexListSizer_Growables(self.IndexListSizer)

   328

        self._init_coll_IndexListSizer_Items(self.IndexListSizer)

   329

        self._init_coll_SubindexGridSizer_Growables(self.SubindexGridSizer)

   330

        self._init_coll_SubindexGridSizer_Items(self.SubindexGridSizer)

   331

        self._init_coll_AddToListSizer_Growables(self.AddToListSizer)

   332

        self._init_coll_AddToListSizer_Items(self.AddToListSizer)

   333

   334

        self.SubindexGridPanel.SetSizer(self.SubindexGridSizer)

   335

        self.IndexListPanel.SetSizer(self.IndexListSizer)

   336

   337

    def _init_ctrls(self, prnt):

   338

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

   339

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

   340

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

   341

        self._init_utils()

   342

        self.SetNeedUpdating(True)

   343

        self.SetMinimumPaneSize(1)

   344

   345

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

   346

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

   347

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

   348

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

   349

              id=ID_EDITINGPANELPARTLIST)

   350

   351

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

   352

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

   353

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

   354

        self.SecondSplitter.SetMinimumPaneSize(1)

   355

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

   356

              110)

   357

   358

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

   359

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

   360

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

   361

   362

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

   363

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

   364

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

   365

        self.SecondSplitter.SplitVertically(self.IndexListPanel,

   366

              self.SubindexGridPanel, 280)

   367

   368

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

   369

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

   370

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

   371

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

   372

              'Sans'))

   373

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

   374

              False, 'Sans'))

   375

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

   376

              self.OnSubindexGridCellChange)

   377

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

   378

              self.OnSubindexGridRightClick)

   379

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

   380

              self.OnSubindexGridSelectCell)

   381

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

   382

              self.OnSubindexGridCellLeftClick)

   383

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

   384

              self.OnSubindexGridEditorShown)

   385

   386

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

   387

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

   388

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

   389

              24), style=0)

   390

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

   391

              id=ID_EDITINGPANELCALLBACKCHECK)

   392

   393

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

   394

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

   395

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

   396

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

   397

              id=ID_EDITINGPANELINDEXLIST)

   398

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

   399

   400

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

   401

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

   402

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

   403

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

   404

              id=ID_EDITINGPANELADDBUTTON)

   405

   406

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

   407

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

   408

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

   409

   410

        self._init_sizers()

   411

   412

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

   413

        self.Editable = editable

   414

        self._init_ctrls(parent)

   415

        self.ParentWindow = window

   416

        self.Manager = manager

   417

        self.ListIndex = []

   418

        self.ChoiceIndex = []

   419

        self.FirstCall = False

   420

        self.Index = None

   421

   422

        for values in DictionaryOrganisation:

   423

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

   424

            self.PartList.Append(text)

   425

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

   426

        self.SubindexGrid.SetTable(self.Table)

   427

        self.SubindexGrid.SetRowLabelSize(0)

   428

        self.CallbackCheck.Disable()

   429

        self.Table.ResetView(self.SubindexGrid)

   430

   431

        if not self.Editable:

   432

            self.AddButton.Disable()

   433

            self.IndexChoice.Disable()

   434

            self.CallbackCheck.Disable()

   435

            self.Table.Disable()

   436

   437

    def GetIndex(self):

   438

        return self.Index

   439

   440

    def SetIndex(self, index):

   441

        self.Index = index

   442

   443

    def GetSelection(self):

   444

        selected = self.IndexList.GetSelection()

   445

        if selected != wx.NOT_FOUND:

   446

            index = self.ListIndex[selected]

   447

            subIndex = self.SubindexGrid.GetGridCursorRow()

   448

            return index, subIndex

   449

        return None

   450

   451

    def OnSubindexGridCellLeftClick(self, event):

   452

        if not self.ParentWindow.ModeSolo:

   453

            col = event.GetCol()

   454

            if not self.Editable and col == 0:

   455

                selected = self.IndexList.GetSelection()

   456

                if selected != wx.NOT_FOUND:

   457

                    index = self.ListIndex[selected]

   458

                    subindex = event.GetRow()

   459

                    entry_infos = self.Manager.GetEntryInfos(index)

   460

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

   461

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

   462

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

   463

                        if subentry_infos["pdo"] and typeinfos:

   464

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

   465

                            node_id = self.ParentWindow.GetCurrentNodeId()

   466

                            size = typeinfos["size"]

   467

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

   468

                            dragSource = wx.DropSource(self.SubindexGrid)

   469

                            dragSource.SetData(data)

   470

                            dragSource.DoDragDrop()

   471

        event.Skip()

   472

   473

    def OnAddButtonClick(self, event):

   474

        if self.Editable:

   475

            self.SubindexGrid.SetGridCursor(0, 0)

   476

            selected = self.IndexChoice.GetStringSelection()

   477

            if selected != "":

   478

                if selected == "User Type":

   479

                    self.ParentWindow.AddUserType()

   480

                elif selected == "SDO Server":

   481

                    self.Manager.AddSDOServerToCurrent()

   482

                elif selected == "SDO Client":

   483

                    self.Manager.AddSDOClientToCurrent()

   484

                elif selected == "PDO Receive":

   485

                    self.Manager.AddPDOReceiveToCurrent()

   486

                elif selected == "PDO Transmit":

   487

                    self.Manager.AddPDOTransmitToCurrent()

   488

                elif selected == "Map Variable":

   489

                    self.ParentWindow.AddMapVariable()

   490

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

   491

                    self.Manager.AddSpecificEntryToCurrent(selected)

   492

                else:

   493

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

   494

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

   495

                self.ParentWindow.RefreshBufferState()

   496

                self.RefreshIndexList()

   497

        event.Skip()

   498

   499

    def OnPartListBoxClick(self, event):

   500

        self.SubindexGrid.SetGridCursor(0, 0)

   501

        self.RefreshIndexList()

   502

        event.Skip()

   503

   504

    def OnIndexListClick(self, event):

   505

        self.SubindexGrid.SetGridCursor(0, 0)

   506

        self.RefreshTable()

   507

        event.Skip()

   508

   509

    def OnSubindexGridSelectCell(self, event):

   510

        wx.CallAfter(self.ParentWindow.RefreshStatusBar)

   511

        event.Skip()

   512