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()

   231

            self.ParentWindow.RefreshEditMenu()

   232

   233

    def StartBuffering(self):

   234

        self.Controler.StartBuffering()

   235

        if self.ParentWindow:

   236

            self.ParentWindow.RefreshTitle()

   238

            self.ParentWindow.RefreshEditMenu()

   239

   240

    def ResetBuffer(self):

   241

        if self.CurrentAction != None:

   242

            self.Controler.EndBuffering()

   243

            self.CurrentAction = None

   244

   245

    def RefreshView(self):

   246

        self.ResetBuffer()

   247

        self.DisableEvents = True

   248

        old_cursor_pos = self.GetCurrentPos()

   249

        old_text = self.GetText()

   250

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

   251

        self.SetText(new_text)

   252

        new_cursor_pos = GetCursorPos(old_text, new_text)

   253

        if new_cursor_pos != None:

   254

            self.GotoPos(new_cursor_pos)

   255

        else:

   256

            self.GotoPos(old_cursor_pos)

   257

        self.ScrollToColumn(0)

   258

        self.EmptyUndoBuffer()

   259

        self.DisableEvents = False

   260

   261

        self.Colourise(0, -1)

   262

   263

    def RefreshModel(self):

   264

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

   265

   266

    def OnKeyPressed(self, event):

   267

        if self.CallTipActive():

   268

            self.CallTipCancel()

   269

        key = event.GetKeyCode()

   270

   271

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

   272

            pos = self.GetCurrentPos()

   273

   274

            # Tips

   275

            if event.ShiftDown():

   276

                pass

   277

##                self.CallTipSetBackground("yellow")

   278

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

   279

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

   280

##                                 'fubar(param1, param2)')

   281

            # Code completion

   282

            else:

   283

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

   284

   285

                # Images are specified with a appended "?type"

   286

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

   287

        else:

   288

            wx.CallAfter(self.RefreshModel)

   289

            event.Skip()

   290

   291

    def OnKillFocus(self, event):

   292

        self.AutoCompCancel()

   293

        event.Skip()

   294

   295

    def OnUpdateUI(self, evt):

   296

        # check for matching braces

   297

        braceAtCaret = -1

   298

        braceOpposite = -1

   299

        charBefore = None

   300

        caretPos = self.GetCurrentPos()

   301

   302

        if caretPos > 0:

   303

            charBefore = self.GetCharAt(caretPos - 1)

   304

            styleBefore = self.GetStyleAt(caretPos - 1)

   305

   306

        # check before

   307

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

   308

            braceAtCaret = caretPos - 1

   309

   310

        # check after

   311

        if braceAtCaret < 0:

   312

            charAfter = self.GetCharAt(caretPos)

   313

            styleAfter = self.GetStyleAt(caretPos)

   314

   315

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

   316

                braceAtCaret = caretPos

   317

   318

        if braceAtCaret >= 0:

   319

            braceOpposite = self.BraceMatch(braceAtCaret)

   320

   321

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

   322

            self.BraceBadLight(braceAtCaret)

   323

        else:

   324

            self.BraceHighlight(braceAtCaret, braceOpposite)

   325

            #pt = self.PointFromPosition(braceOpposite)

   326

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

   327

            #print pt

   328

            #self.Refresh(False)

   329

   330

   331

    def OnMarginClick(self, evt):

   332

        # fold and unfold as needed

   333

        if evt.GetMargin() == 2:

   334

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

   335

                self.FoldAll()

   336

            else:

   337

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

   338

   339

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

   340

                    if evt.GetShift():

   341

                        self.SetFoldExpanded(lineClicked, True)

   342

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

   343

                    elif evt.GetControl():

   344

                        if self.GetFoldExpanded(lineClicked):

   345

                            self.SetFoldExpanded(lineClicked, False)

   346

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

   347

                        else:

   348

                            self.SetFoldExpanded(lineClicked, True)

   349

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

   350

                    else:

   351

                        self.ToggleFold(lineClicked)

   352

   353

   354

    def FoldAll(self):

   355

        lineCount = self.GetLineCount()

   356

        expanding = True

   357

   358

        # find out if we are folding or unfolding

   359

        for lineNum in range(lineCount):

   360

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

   361

                expanding = not self.GetFoldExpanded(lineNum)

   362

                break

   363

   364

        lineNum = 0

   365

   366

        while lineNum < lineCount:

   367

            level = self.GetFoldLevel(lineNum)

   368

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   369

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

   370

   371

                if expanding:

   372

                    self.SetFoldExpanded(lineNum, True)

   373

                    lineNum = self.Expand(lineNum, True)

   374

                    lineNum = lineNum - 1

   375

                else:

   376

                    lastChild = self.GetLastChild(lineNum, -1)

   377

                    self.SetFoldExpanded(lineNum, False)

   378

   379

                    if lastChild > lineNum:

   380

                        self.HideLines(lineNum+1, lastChild)

   381

   382

            lineNum = lineNum + 1

   383

   384

   385

   386

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

   387

        lastChild = self.GetLastChild(line, level)

   388

        line = line + 1

   389

   390

        while line <= lastChild:

   391

            if force:

   392

                if visLevels > 0:

   393

                    self.ShowLines(line, line)

   394

                else:

   395

                    self.HideLines(line, line)

   396

            else:

   397

                if doExpand:

   398

                    self.ShowLines(line, line)

   399

   400

            if level == -1:

   401

                level = self.GetFoldLevel(line)

   402

   403

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   404

                if force:

   405

                    if visLevels > 1:

   406

                        self.SetFoldExpanded(line, True)

   407

                    else:

   408

                        self.SetFoldExpanded(line, False)

   409

   410

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

   411

   412

                else:

   413

                    if doExpand and self.GetFoldExpanded(line):

   414

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

   415

                    else:

   416

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

   417

            else:

   418

                line = line + 1

   419

   420

        return line

   421

   422

   423

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

   424

#                         Helper for VariablesGrid values

   425

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

   426

   427

class VariablesTable(wx.grid.PyGridTableBase):

   428

   429

    """

   430

    A custom wxGrid Table using user supplied data

   431

    """

   432

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

   433

        # The base class must be initialized *first*

   434

        wx.grid.PyGridTableBase.__init__(self)

   435

        self.data = data

   436

        self.colnames = colnames

   437

        self.Parent = parent

   438

        # XXX

   439

        # we need to store the row length and collength to

   440

        # see if the table has changed size

   441

        self._rows = self.GetNumberRows()

   442

        self._cols = self.GetNumberCols()

   443

   444

    def GetNumberCols(self):

   445

        return len(self.colnames)

   446

   447

    def GetNumberRows(self):

   448

        return len(self.data)

   449

   450

    def GetColLabelValue(self, col):

   451

        if col < len(self.colnames):

   452

            return self.colnames[col]

   453

   454

    def GetRowLabelValues(self, row):

   455

        return row

   456

   457

    def GetValue(self, row, col):

   458

        if row < self.GetNumberRows():

   459

            if col == 0:

   460

                return row + 1

   461

            else:

   462

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

   463

   464

    def GetValueByName(self, row, colname):

   465

        if row < self.GetNumberRows():

   466

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

   467

        return None

   468

   469

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

   470

        if col < len(self.colnames):

   471

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

   472

   473

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

   474

        if row < self.GetNumberRows():

   475

            self.data[row][colname] = value

   476

   477

    def ResetView(self, grid):

   478

        """

   479

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

   480

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

   481

        """

   482

        grid.BeginBatch()

   483

        for current, new, delmsg, addmsg in [

   484

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

   485

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

   486

        ]:

   487

            if new < current:

   488

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

   489

                grid.ProcessTableMessage(msg)

   490

            elif new > current:

   491

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

   492

                grid.ProcessTableMessage(msg)

   493

                self.UpdateValues(grid)

   494

        grid.EndBatch()

   495

   496

        self._rows = self.GetNumberRows()

   497

        self._cols = self.GetNumberCols()

   498

        # update the column rendering scheme

   499

        self._updateColAttrs(grid)

   500

   501

        # update the scrollbars and the displayed part of the grid

   502

        grid.AdjustScrollbars()

   503

        grid.ForceRefresh()

   504

   505

    def UpdateValues(self, grid):

   506

        """Update all displayed values"""

   507

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

   508

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

   509

        grid.ProcessTableMessage(msg)

   510

   511

    def _updateColAttrs(self, grid):

   512

        """

   513

        wxGrid -> update the column attributes to add the

   514

        appropriate renderer given the column name.

   515

   516

        Otherwise default to the default renderer.

   517

        """

   518

   519

        typelist = None

   520

        accesslist = None

   521

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

   522

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

   523

                editor = None

   524

                renderer = None

   525

                colname = self.GetColLabelValue(col)

   526

                grid.SetReadOnly(row, col, False)

   527

   528

                if colname == "Name":

   529

                    editor = wx.grid.GridCellTextEditor()