1

import  wx, wx.grid

     2

import  wx.stc  as  stc

     3

import keyword

     4

     5

if wx.Platform == '__WXMSW__':

     6

    faces = { 'times': 'Times New Roman',

     7

              'mono' : 'Courier New',

     8

              'helv' : 'Arial',

     9

              'other': 'Comic Sans MS',

    10

              'size' : 10,

    11

              'size2': 8,

    12

             }

    13

else:

    14

    faces = { 'times': 'Times',

    15

              'mono' : 'Courier',

    16

              'helv' : 'Helvetica',

    17

              'other': 'new century schoolbook',

    18

              'size' : 12,

    19

              'size2': 10,

    20

             }

    21

    22

    23

def AppendMenu(parent, help, id, kind, text):

    24

    if wx.VERSION >= (2, 6, 0):

    25

        parent.Append(help=help, id=id, kind=kind, text=text)

    26

    else:

    27

        parent.Append(helpString=help, id=id, kind=kind, item=text)

    28

    29

    30

[ID_CPPEDITOR,

    31

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

    32

    33

CPP_KEYWORDS = ["asm", "auto", "bool", "break", "case", "catch", "char", "class", 

    34

    "const", "const_cast", "continue", "default", "delete", "do", "double", 

    35

    "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", 

    36

    "float", "for", "friend", "goto", "if", "inline", "int", "long", "mutable", 

    37

    "namespace", "new", "operator", "private", "protected", "public", "register", 

    38

    "reinterpret_cast", "return", "short", "signed", "sizeof", "static", 

    39

    "static_cast", "struct", "switch", "template", "this", "throw", "true", "try",

    40

    "typedef", "typeid", "typename", "union", "unsigned", "using", "virtual", 

    41

    "void", "volatile", "wchar_t", "while"]

    42

    43

def GetCursorPos(old, new):

    44

    old_length = len(old)

    45

    new_length = len(new)

    46

    common_length = min(old_length, new_length)

    47

    i = 0

    48

    for i in xrange(common_length):

    49

        if old[i] != new[i]:

    50

            break

    51

    if old_length < new_length:

    52

        if common_length > 0 and old[i] != new[i]:

    53

            return i + new_length - old_length

    54

        else:

    55

            return i + new_length - old_length + 1

    56

    elif old_length > new_length or i < min(old_length, new_length) - 1:

    57

        if common_length > 0 and old[i] != new[i]:

    58

            return i

    59

        else:

    60

            return i + 1

    61

    else:

    62

        return None

    63

    64

class CppEditor(stc.StyledTextCtrl):

    65

    66

    fold_symbols = 3

    67

    68

    def __init__(self, parent, name, window, controler):

    69

        stc.StyledTextCtrl.__init__(self, parent, ID_CPPEDITOR, wx.DefaultPosition, 

    70

                 wx.DefaultSize, 0)

    71

    72

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    73

        self.SetMarginWidth(1, 25)

    74

    75

        self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)

    76

        self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)

    77

    78

        self.SetLexer(stc.STC_LEX_CPP)

    79

        self.SetKeyWords(0, " ".join(CPP_KEYWORDS))

    80

    81

        self.SetProperty("fold", "1")

    82

        self.SetProperty("tab.timmy.whinge.level", "1")

    83

        self.SetMargins(0,0)

    84

    85

        self.SetViewWhiteSpace(False)

    86

        #self.SetBufferedDraw(False)

    87

        #self.SetViewEOL(True)

    88

        #self.SetEOLMode(stc.STC_EOL_CRLF)

    89

        #self.SetUseAntiAliasing(True)

    90

    91

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    92

        self.SetEdgeColumn(78)

    93

    94

        # Setup a margin to hold fold markers

    95

        #self.SetFoldFlags(16)  ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?

    96

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    97

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    98

        self.SetMarginSensitive(2, True)

    99

        self.SetMarginWidth(2, 12)

   100

   101

        if self.fold_symbols == 0:

   102

            # Arrow pointing right for contracted folders, arrow pointing down for expanded

   103

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_ARROWDOWN, "black", "black")

   104

            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_ARROW, "black", "black")

   105

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "black", "black")

   106

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "black", "black")

   107

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY,     "white", "black")

   108

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY,     "white", "black")

   109

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY,     "white", "black")

   110

   111

        elif self.fold_symbols == 1:

   112

            # Plus for contracted folders, minus for expanded

   113

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_MINUS, "white", "black")

   114

            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_PLUS,  "white", "black")

   115

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "white", "black")

   116

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "white", "black")

   117

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY, "white", "black")

   118

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")

   119

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")

   120

   121

        elif self.fold_symbols == 2:

   122

            # Like a flattened tree control using circular headers and curved joins

   123

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_CIRCLEMINUS,          "white", "#404040")

   124

            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_CIRCLEPLUS,           "white", "#404040")

   125

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,                "white", "#404040")

   126

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNERCURVE,         "white", "#404040")

   127

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_CIRCLEPLUSCONNECTED,  "white", "#404040")

   128

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")

   129

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNERCURVE,         "white", "#404040")

   130

   131

        elif self.fold_symbols == 3:

   132

            # Like a flattened tree control using square headers

   133

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS,          "white", "#808080")

   134

            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,           "white", "#808080")

   135

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,             "white", "#808080")

   136

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,           "white", "#808080")

   137

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")

   138

            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")

   139

            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,           "white", "#808080")

   140

   141

   142

        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)

   143

        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)

   144

        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)

   145

   146

        # Make some styles,  The lexer defines what each style is used for, we

   147

        # just have to define what each style looks like.  This set is adapted from

   148

        # Scintilla sample property files.

   149

   150

        # Global default styles for all languages

   151

        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(mono)s,size:%(size)d" % faces)

   152

        self.StyleClearAll()  # Reset all to be like the default

   153

   154

        # Global default styles for all languages

   155

        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(mono)s,size:%(size)d" % faces)

   156

        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)

   157

        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)

   158

        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")

   159

        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")

   160

   161

        self.StyleSetSpec(stc.STC_C_COMMENT, 'fore:#408060')

   162

        self.StyleSetSpec(stc.STC_C_COMMENTLINE, 'fore:#408060')

   163

        self.StyleSetSpec(stc.STC_C_COMMENTDOC, 'fore:#408060')

   164

        self.StyleSetSpec(stc.STC_C_NUMBER, 'fore:#0076AE')

   165

        self.StyleSetSpec(stc.STC_C_WORD, 'bold,fore:#800056')

   166

        self.StyleSetSpec(stc.STC_C_STRING, 'fore:#2a00ff')

   167

        self.StyleSetSpec(stc.STC_C_PREPROCESSOR, 'bold,fore:#800056')

   168

        self.StyleSetSpec(stc.STC_C_OPERATOR, 'bold')

   169

        self.StyleSetSpec(stc.STC_C_STRINGEOL, 'back:#FFD5FF')

   170

   171

        # register some images for use in the AutoComplete box.

   172

        #self.RegisterImage(1, images.getSmilesBitmap())

   173

        self.RegisterImage(1, 

   174

            wx.ArtProvider.GetBitmap(wx.ART_DELETE, size=(16,16)))

   175

        self.RegisterImage(2, 

   176

            wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))

   177

        self.RegisterImage(3, 

   178

            wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))

   179

   180

        # Indentation size

   181

        self.SetTabWidth(2)

   182

        self.SetUseTabs(0)

   183

   184

        self.Controler = controler

   185

        self.ParentWindow = window

   186

   187

        self.DisableEvents = True

   188

        self.Name = name

   189

        self.CurrentAction = None

   190

   191

        self.SetModEventMask(wx.stc.STC_MOD_BEFOREINSERT|wx.stc.STC_MOD_BEFOREDELETE)

   192

   193

        self.Bind(wx.stc.EVT_STC_DO_DROP, self.OnDoDrop, id=ID_CPPEDITOR)

   194

        self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)

   195

        self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModification, id=ID_CPPEDITOR)

   196

   197

    def OnModification(self, event):

   198

        if not self.DisableEvents:

   199

            mod_type = event.GetModificationType()

   200

            if not (mod_type&wx.stc.STC_PERFORMED_UNDO or mod_type&wx.stc.STC_PERFORMED_REDO):

   201

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   202

                    if self.CurrentAction == None:

   203

                        self.StartBuffering()

   204

                    elif self.CurrentAction[0] != "Add" or self.CurrentAction[1] != event.GetPosition() - 1:

   205

                        self.Controler.EndBuffering()

   206

                        self.StartBuffering()

   207

                    self.CurrentAction = ("Add", event.GetPosition())

   208

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   209

                    if self.CurrentAction == None:

   210

                        self.StartBuffering()

   211

                    elif self.CurrentAction[0] != "Delete" or self.CurrentAction[1] != event.GetPosition() + 1:

   212

                        self.Controler.EndBuffering()

   213

                        self.StartBuffering()

   214

                    self.CurrentAction = ("Delete", event.GetPosition())

   215

        event.Skip()

   216

   217

    def OnDoDrop(self, event):

   218

        self.ResetBuffer()

   219

        wx.CallAfter(self.RefreshModel)

   220

        event.Skip()

   221

   222

    def IsViewing(self, name):

   223

        return self.Name == name

   224

   225

    # Buffer the last model state

   226

    def RefreshBuffer(self):

   227

        self.Controler.BufferCFile()

   228

        if self.ParentWindow:

   229

            self.ParentWindow.RefreshTitle()

   230

            self.ParentWindow.RefreshEditMenu()

   231

   232

    def StartBuffering(self):

   233

        self.Controler.StartBuffering()

   234

        if self.ParentWindow:

   235

            self.ParentWindow.RefreshTitle()

   236

            self.ParentWindow.RefreshEditMenu()

   237

   238

    def ResetBuffer(self):

   239

        if self.CurrentAction != None:

   240

            self.Controler.EndBuffering()

   241

            self.CurrentAction = None

   242

   243

    def RefreshView(self):

   244

        self.ResetBuffer()

   245

        self.DisableEvents = True

   246

        old_cursor_pos = self.GetCurrentPos()

   247

        old_text = self.GetText()

   248

        new_text = self.Controler.GetPartText(self.Name)

   249

        self.SetText(new_text)

   250

        new_cursor_pos = GetCursorPos(old_text, new_text)

   251

        if new_cursor_pos != None:

   252

            self.GotoPos(new_cursor_pos)

   253

        else:

   254

            self.GotoPos(old_cursor_pos)

   255

        self.ScrollToColumn(0)

   256

        self.EmptyUndoBuffer()

   257

        self.DisableEvents = False

   258

   259

        self.Colourise(0, -1)

   260

   261

    def RefreshModel(self):

   262

        self.Controler.SetPartText(self.Name, self.GetText())

   263

   264

    def OnKeyPressed(self, event):

   265

        if self.CallTipActive():

   266

            self.CallTipCancel()

   267

        key = event.GetKeyCode()

   268

   269

        if key == 32 and event.ControlDown():

   270

            pos = self.GetCurrentPos()

   271

   272

            # Tips

   273

            if event.ShiftDown():

   274

                pass

   275

##                self.CallTipSetBackground("yellow")

   276

##                self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'

   277

##                                 'show some suff, maybe parameters..\n\n'

   278

##                                 'fubar(param1, param2)')

   279

            # Code completion

   280

            else:

   281

                self.AutoCompSetIgnoreCase(False)  # so this needs to match

   282

   283

                # Images are specified with a appended "?type"

   284

                self.AutoCompShow(0, " ".join([word + "?1" for word in CPP_KEYWORDS]))

   285

        else:

   286

            wx.CallAfter(self.RefreshModel)

   287

            event.Skip()

   288

   289

    def OnKillFocus(self, event):

   290

        self.AutoCompCancel()

   291

        event.Skip()

   292

   293

    def OnUpdateUI(self, evt):

   294

        # check for matching braces

   295

        braceAtCaret = -1

   296

        braceOpposite = -1

   297

        charBefore = None

   298

        caretPos = self.GetCurrentPos()

   299

   300

        if caretPos > 0:

   301

            charBefore = self.GetCharAt(caretPos - 1)

   302

            styleBefore = self.GetStyleAt(caretPos - 1)

   303

   304

        # check before

   305

        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:

   306

            braceAtCaret = caretPos - 1

   307

   308

        # check after

   309

        if braceAtCaret < 0:

   310

            charAfter = self.GetCharAt(caretPos)

   311

            styleAfter = self.GetStyleAt(caretPos)

   312

   313

            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:

   314

                braceAtCaret = caretPos

   315

   316

        if braceAtCaret >= 0:

   317

            braceOpposite = self.BraceMatch(braceAtCaret)

   318

   319

        if braceAtCaret != -1  and braceOpposite == -1:

   320

            self.BraceBadLight(braceAtCaret)

   321

        else:

   322

            self.BraceHighlight(braceAtCaret, braceOpposite)

   323

            #pt = self.PointFromPosition(braceOpposite)

   324

            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))

   325

            #print pt

   326

            #self.Refresh(False)

   327

   328

   329

    def OnMarginClick(self, evt):

   330

        # fold and unfold as needed

   331

        if evt.GetMargin() == 2:

   332

            if evt.GetShift() and evt.GetControl():

   333

                self.FoldAll()

   334

            else:

   335

                lineClicked = self.LineFromPosition(evt.GetPosition())

   336

   337

                if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:

   338

                    if evt.GetShift():

   339

                        self.SetFoldExpanded(lineClicked, True)

   340

                        self.Expand(lineClicked, True, True, 1)

   341

                    elif evt.GetControl():

   342

                        if self.GetFoldExpanded(lineClicked):

   343

                            self.SetFoldExpanded(lineClicked, False)

   344

                            self.Expand(lineClicked, False, True, 0)

   345

                        else:

   346

                            self.SetFoldExpanded(lineClicked, True)

   347

                            self.Expand(lineClicked, True, True, 100)

   348

                    else:

   349

                        self.ToggleFold(lineClicked)

   350

   351

   352

    def FoldAll(self):

   353

        lineCount = self.GetLineCount()

   354

        expanding = True

   355

   356

        # find out if we are folding or unfolding

   357

        for lineNum in range(lineCount):

   358

            if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:

   359

                expanding = not self.GetFoldExpanded(lineNum)

   360

                break

   361

   362

        lineNum = 0

   363

   364

        while lineNum < lineCount:

   365

            level = self.GetFoldLevel(lineNum)

   366

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   367

               (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:

   368

   369

                if expanding:

   370

                    self.SetFoldExpanded(lineNum, True)

   371

                    lineNum = self.Expand(lineNum, True)

   372

                    lineNum = lineNum - 1

   373

                else:

   374

                    lastChild = self.GetLastChild(lineNum, -1)

   375

                    self.SetFoldExpanded(lineNum, False)

   376

   377

                    if lastChild > lineNum:

   378

                        self.HideLines(lineNum+1, lastChild)

   379

   380

            lineNum = lineNum + 1

   381

   382

   383

   384

    def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):

   385

        lastChild = self.GetLastChild(line, level)

   386

        line = line + 1

   387

   388

        while line <= lastChild:

   389

            if force:

   390

                if visLevels > 0:

   391

                    self.ShowLines(line, line)

   392

                else:

   393

                    self.HideLines(line, line)

   394

            else:

   395

                if doExpand:

   396

                    self.ShowLines(line, line)

   397

   398

            if level == -1:

   399

                level = self.GetFoldLevel(line)

   400

   401

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   402

                if force:

   403

                    if visLevels > 1:

   404

                        self.SetFoldExpanded(line, True)

   405

                    else:

   406

                        self.SetFoldExpanded(line, False)

   407

   408

                    line = self.Expand(line, doExpand, force, visLevels-1)

   409

   410

                else:

   411

                    if doExpand and self.GetFoldExpanded(line):

   412

                        line = self.Expand(line, True, force, visLevels-1)

   413

                    else:

   414

                        line = self.Expand(line, False, force, visLevels-1)

   415

            else:

   416

                line = line + 1

   417

   418

        return line

   419

   420

   421

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

   422

#                         Helper for VariablesGrid values

   423

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

   424

   425

class VariablesTable(wx.grid.PyGridTableBase):

   426

   427

    """

   428

    A custom wxGrid Table using user supplied data

   429

    """

   430

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

   431

        # The base class must be initialized *first*

   432

        wx.grid.PyGridTableBase.__init__(self)

   433

        self.data = data

   434

        self.colnames = colnames

   435

        self.Parent = parent

   436

        # XXX

   437

        # we need to store the row length and collength to

   438

        # see if the table has changed size

   439

        self._rows = self.GetNumberRows()

   440

        self._cols = self.GetNumberCols()

   441

   442

    def GetNumberCols(self):

   443

        return len(self.colnames)

   444

   445

    def GetNumberRows(self):

   446

        return len(self.data)

   447

   448

    def GetColLabelValue(self, col):

   449

        if col < len(self.colnames):

   450

            return self.colnames[col]

   451

   452

    def GetRowLabelValues(self, row):

   453

        return row

   454

   455

    def GetValue(self, row, col):

   456

        if row < self.GetNumberRows():

   457

            if col == 0:

   458

                return row + 1

   459

            else:

   460

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

   461

   462

    def GetValueByName(self, row, colname):

   463

        if row < self.GetNumberRows():

   464

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

   465

        return None

   466

   467

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

   468

        if col < len(self.colnames):

   469

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

   470

   471

    def SetValueByName(self, row, colname, value):

   472

        if row < self.GetNumberRows():

   473

            self.data[row][colname] = value

   474

   475

    def ResetView(self, grid):

   476

        """

   477

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

   478

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

   479

        """

   480

        grid.BeginBatch()

   481

        for current, new, delmsg, addmsg in [

   482

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

   483

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

   484

        ]:

   485

            if new < current:

   486

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

   487

                grid.ProcessTableMessage(msg)

   488

            elif new > current:

   489

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

   490

                grid.ProcessTableMessage(msg)

   491

                self.UpdateValues(grid)

   492

        grid.EndBatch()

   493

   494

        self._rows = self.GetNumberRows()

   495

        self._cols = self.GetNumberCols()

   496

        # update the column rendering scheme

   497

        self._updateColAttrs(grid)

   498

   499

        # update the scrollbars and the displayed part of the grid

   500

        grid.AdjustScrollbars()

   501

        grid.ForceRefresh()

   502

   503

    def UpdateValues(self, grid):

   504

        """Update all displayed values"""

   505

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

   506

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

   507

        grid.ProcessTableMessage(msg)

   508

   509

    def _updateColAttrs(self, grid):

   510

        """

   511

        wxGrid -> update the column attributes to add the

   512

        appropriate renderer given the column name.

   513

   514

        Otherwise default to the default renderer.

   515

        """

   516

   517

        typelist = None

   518

        accesslist = None

   519

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

   520

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

   521

                editor = None

   522

                renderer = None

   523

                colname = self.GetColLabelValue(col)

   524

                grid.SetReadOnly(row, col, False)

   525

   526

                if colname == "Name":

   527

                    editor = wx.grid.GridCellTextEditor()

   528

                elif colname == "Class":

   529

                    editor = wx.grid.GridCellChoiceEditor()