2

     3

import wx

     4

import wx.grid

     5

import wx.stc as stc

     6

import wx.lib.buttons

     7

     8

from controls import CustomGrid, CustomTable

    10

from util.BitmapLibrary import GetBitmap

    11

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl, faces, GetCursorPos

    12

    23

                 wx.Size(-1, 300), 0)

    24

    25

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    26

        self.SetMarginWidth(1, 25)

    27

    28

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

    29

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

    30

    31

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

    32

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

    33

        self.SetMargins(0,0)

    34

    35

        self.SetViewWhiteSpace(False)

    36

    37

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    38

        self.SetEdgeColumn(78)

    39

    40

        # Setup a margin to hold fold markers

    41

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    42

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    43

        self.SetMarginSensitive(2, True)

    44

        self.SetMarginWidth(2, 12)

    45

    55

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

    56

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

    57

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

    58

    59

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

    60

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

    61

        # Scintilla sample property files.

    62

    63

        # Global default styles for all languages

    64

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

    65

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

    66

    67

        # Global default styles for all languages

    68

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

    69

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

    70

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

    71

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

    72

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

    73

    74

        # register some images for use in the AutoComplete box.

    75

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

    76

        self.RegisterImage(1, 

    77

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

    78

        self.RegisterImage(2, 

    79

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

    80

        self.RegisterImage(3, 

    81

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

    82

    83

        # Indentation size

    84

        self.SetTabWidth(2)

    85

        self.SetUseTabs(0)

    90

        self.Controler = controler

    91

        self.ParentWindow = window

    92

    93

        self.DisableEvents = True

    94

        self.CurrentAction = None

    95

   109

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

   110

   112

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

   117

   118

    def OnModification(self, event):

   119

        if not self.DisableEvents:

   120

            mod_type = event.GetModificationType()

   121

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

   122

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   123

                    if self.CurrentAction == None:

   124

                        self.StartBuffering()

   125

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

   126

                        self.Controler.EndBuffering()

   127

                        self.StartBuffering()

   128

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

   129

                    wx.CallAfter(self.RefreshModel)

   130

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   131

                    if self.CurrentAction == None:

   132

                        self.StartBuffering()

   133

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

   134

                        self.Controler.EndBuffering()

   135

                        self.StartBuffering()

   136

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

   137

                    wx.CallAfter(self.RefreshModel)

   138

        event.Skip()

   139

   140

    def OnDoDrop(self, event):

   141

        self.ResetBuffer()

   142

        wx.CallAfter(self.RefreshModel)

   143

        event.Skip()

   144

   145

    # Buffer the last model state

   146

    def RefreshBuffer(self):

   148

        if self.ParentWindow is not None:

   149

            self.ParentWindow.RefreshTitle()

   150

            self.ParentWindow.RefreshFileMenu()

   151

            self.ParentWindow.RefreshEditMenu()

   152

            self.ParentWindow.RefreshPageTitles()

   153

   154

    def StartBuffering(self):

   155

        self.Controler.StartBuffering()

   156

        if self.ParentWindow is not None:

   157

            self.ParentWindow.RefreshTitle()

   158

            self.ParentWindow.RefreshFileMenu()

   159

            self.ParentWindow.RefreshEditMenu()

   160

            self.ParentWindow.RefreshPageTitles()

   161

   162

    def ResetBuffer(self):

   163

        if self.CurrentAction != None:

   164

            self.Controler.EndBuffering()

   165

            self.CurrentAction = None

   166

   177

    def RefreshView(self):

   178

        self.ResetBuffer()

   179

        self.DisableEvents = True

   180

        old_cursor_pos = self.GetCurrentPos()

   181

        line = self.GetFirstVisibleLine()

   182

        column = self.GetXOffset()

   183

        old_text = self.GetText()

   185

        self.SetText(new_text)

   186

        if old_text != new_text:

   187

            new_cursor_pos = GetCursorPos(old_text, new_text)

   188

            self.LineScroll(column, line)

   189

            if new_cursor_pos != None:

   190

                self.GotoPos(new_cursor_pos)

   191

            else:

   192

                self.GotoPos(old_cursor_pos)

   193

            self.EmptyUndoBuffer()

   194

        self.DisableEvents = False

   195

   196

        self.Colourise(0, -1)

   197

   198

    def DoGetBestSize(self):

   199

        return self.ParentWindow.GetPanelBestSize()

   200

   201

    def RefreshModel(self):

   212

   213

    def OnKeyPressed(self, event):

   214

        if self.CallTipActive():

   215

            self.CallTipCancel()

   216

        key = event.GetKeyCode()

   217

   218

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

   219

            pos = self.GetCurrentPos()

   220

   221

            # Tips

   222

            if event.ShiftDown():

   223

                pass

   224

            # Code completion

   225

            else:

   226

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

   227

   228

                # Images are specified with a appended "?type"

   230

        else:

   231

            event.Skip()

   232

   233

    def OnKillFocus(self, event):

   234

        self.AutoCompCancel()

   235

        event.Skip()

   236

   237

    def OnUpdateUI(self, evt):

   238

        # check for matching braces

   239

        braceAtCaret = -1

   240

        braceOpposite = -1

   241

        charBefore = None

   242

        caretPos = self.GetCurrentPos()

   243

   244

        if caretPos > 0:

   245

            charBefore = self.GetCharAt(caretPos - 1)

   246

            styleBefore = self.GetStyleAt(caretPos - 1)

   247

   248

        # check before

   249

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

   250

            braceAtCaret = caretPos - 1

   251

   252

        # check after

   253

        if braceAtCaret < 0:

   254

            charAfter = self.GetCharAt(caretPos)

   255

            styleAfter = self.GetStyleAt(caretPos)

   256

   257

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

   258

                braceAtCaret = caretPos

   259

   260

        if braceAtCaret >= 0:

   261

            braceOpposite = self.BraceMatch(braceAtCaret)

   262

   263

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

   264

            self.BraceBadLight(braceAtCaret)

   265

        else:

   266

            self.BraceHighlight(braceAtCaret, braceOpposite)

   267

   268

    def OnMarginClick(self, evt):

   269

        # fold and unfold as needed

   270

        if evt.GetMargin() == 2:

   271

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

   272

                self.FoldAll()

   273

            else:

   274

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

   275

   276

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

   277

                    if evt.GetShift():

   278

                        self.SetFoldExpanded(lineClicked, True)

   279

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

   280

                    elif evt.GetControl():

   281

                        if self.GetFoldExpanded(lineClicked):

   282

                            self.SetFoldExpanded(lineClicked, False)

   283

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

   284

                        else:

   285

                            self.SetFoldExpanded(lineClicked, True)

   286

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

   287

                    else:

   288

                        self.ToggleFold(lineClicked)

   289

   290

   291

    def FoldAll(self):

   292

        lineCount = self.GetLineCount()

   293

        expanding = True

   294

   295

        # find out if we are folding or unfolding

   296

        for lineNum in range(lineCount):

   297

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

   298

                expanding = not self.GetFoldExpanded(lineNum)

   299

                break

   300

   301

        lineNum = 0

   302

   303

        while lineNum < lineCount:

   304

            level = self.GetFoldLevel(lineNum)

   305

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   306

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

   307

   308

                if expanding:

   309

                    self.SetFoldExpanded(lineNum, True)

   310

                    lineNum = self.Expand(lineNum, True)

   311

                    lineNum = lineNum - 1

   312

                else:

   313

                    lastChild = self.GetLastChild(lineNum, -1)

   314

                    self.SetFoldExpanded(lineNum, False)

   315

   316

                    if lastChild > lineNum:

   317

                        self.HideLines(lineNum+1, lastChild)

   318

   319

            lineNum = lineNum + 1

   320

   321

   322

   323

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

   324

        lastChild = self.GetLastChild(line, level)

   325

        line = line + 1

   326

   327

        while line <= lastChild:

   328

            if force:

   329

                if visLevels > 0:

   330

                    self.ShowLines(line, line)

   331

                else:

   332

                    self.HideLines(line, line)

   333

            else:

   334

                if doExpand:

   335

                    self.ShowLines(line, line)

   336

   337

            if level == -1:

   338

                level = self.GetFoldLevel(line)

   339

   340

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   341

                if force:

   342

                    if visLevels > 1:

   343

                        self.SetFoldExpanded(line, True)

   344

                    else:

   345

                        self.SetFoldExpanded(line, False)

   346

   347

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

   348

   349

                else:

   350

                    if doExpand and self.GetFoldExpanded(line):

   351

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

   352

                    else:

   353

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

   354

            else:

   355

                line = line + 1

   356

   357

        return line

   358

   359

    def Cut(self):

   360

        self.ResetBuffer()

   361

        self.DisableEvents = True

   362

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   363

        self.DisableEvents = False

   364

        self.RefreshModel()

   365

        self.RefreshBuffer()

   366

   367

    def Copy(self):

   368

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   369

   370

    def Paste(self):

   371

        self.ResetBuffer()

   372

        self.DisableEvents = True

   373

        self.CmdKeyExecute(wx.stc.STC_CMD_PASTE)

   374

        self.DisableEvents = False

   375

        self.RefreshModel()

   376

        self.RefreshBuffer()

   377

   378

   379

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

   380

#                         Helper for VariablesGrid values

   381

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

   382

   383

class VariablesTable(CustomTable):

   384

   385

    def GetValue(self, row, col):

   386

        if row < self.GetNumberRows():

   387

            if col == 0:

   388

                return row + 1

   389

            else:

   390

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

   391

   392

    def _updateColAttrs(self, grid):

   393

        """

   394

        wxGrid -> update the column attributes to add the

   395

        appropriate renderer given the column name.

   396

   397

        Otherwise default to the default renderer.

   398

        """

   399

   400

        typelist = None

   401

        accesslist = None

   402

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

   403

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

   404

                editor = None

   405

                renderer = None

   406

                colname = self.GetColLabelValue(col, False)

   407

   409

                    editor = wx.grid.GridCellTextEditor()

   410

                elif colname == "Class":

   411

                    editor = wx.grid.GridCellChoiceEditor()

   412

                    editor.SetParameters("input,memory,output")

   413

                elif colname == "Type":

   414

                    pass

   415

                else:

   416

                    grid.SetReadOnly(row, col, True)

   417

   418

                grid.SetCellEditor(row, col, editor)

   419

                grid.SetCellRenderer(row, col, renderer)

   420

   421

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

   422

            self.ResizeRow(grid, row)

   423

   424

   425

class VariablesEditor(wx.Panel):

   426

   427

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

   428

        wx.Panel.__init__(self, parent, style=wx.TAB_TRAVERSAL)

   429

   430

        main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=4)

   431

        main_sizer.AddGrowableCol(0)

   432

        main_sizer.AddGrowableRow(0)

   433

   434

        self.VariablesGrid = CustomGrid(self, size=wx.Size(-1, 300), style=wx.VSCROLL)

   435

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnVariablesGridCellChange)

   436

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnVariablesGridCellLeftClick)

   437

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_EDITOR_SHOWN, self.OnVariablesGridEditorShown)

   438

        main_sizer.AddWindow(self.VariablesGrid, flag=wx.GROW)

   439

   440

        controls_sizer = wx.BoxSizer(wx.HORIZONTAL)

   441

        main_sizer.AddSizer(controls_sizer, border=5, flag=wx.TOP|wx.ALIGN_RIGHT)

   442

   443

        for name, bitmap, help in [

   444

                ("AddVariableButton", "add_element", _("Add variable")),

   445

                ("DeleteVariableButton", "remove_element", _("Remove variable")),

   446

                ("UpVariableButton", "up", _("Move variable up")),

   447

                ("DownVariableButton", "down", _("Move variable down"))]:

   448

            button = wx.lib.buttons.GenBitmapButton(self, bitmap=GetBitmap(bitmap), 

   449

                  size=wx.Size(28, 28), style=wx.NO_BORDER)

   450

            button.SetToolTipString(help)

   451

            setattr(self, name, button)

   452

            controls_sizer.AddWindow(button, border=5, flag=wx.LEFT)

   453

   454

        self.SetSizer(main_sizer)

   455

   456

        self.ParentWindow = window

   457

        self.Controler = controler

   458

   461

        self.ColAlignements = [wx.ALIGN_RIGHT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]

   462

        self.ColSizes = [40, 200, 150, 150]

   463

        self.VariablesGrid.SetTable(self.Table)

   464

        self.VariablesGrid.SetButtons({"Add": self.AddVariableButton,

   465

                                       "Delete": self.DeleteVariableButton,

   466

                                       "Up": self.UpVariableButton,

   467

                                       "Down": self.DownVariableButton})

   468

   469

        def _AddVariable(new_row):

   470

            self.Table.InsertRow(new_row, self.VariablesDefaultValue.copy())

   471

            self.RefreshModel()

   472

            self.RefreshView()

   473

            return new_row

   474

        setattr(self.VariablesGrid, "_AddRow", _AddVariable)

   475

   476

        def _DeleteVariable(row):

   477

            self.Table.RemoveRow(row)

   478

            self.RefreshModel()

   479

            self.RefreshView()

   480

        setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

   481

   482

        def _MoveVariable(row, move):

   483

            new_row = self.Table.MoveRow(row, move)

   484

            if new_row != row:

   485

                self.RefreshModel()

   486

                self.RefreshView()

   487

            return new_row

   488

        setattr(self.VariablesGrid, "_MoveRow", _MoveVariable)

   489

   490

        self.VariablesGrid.SetRowLabelSize(0)

   491

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

   492

            attr = wx.grid.GridCellAttr()

   493

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

   494

            self.VariablesGrid.SetColAttr(col, attr)

   495

            self.VariablesGrid.SetColSize(col, self.ColSizes[col])

   496

        self.Table.ResetView(self.VariablesGrid)

   497

   498

    def RefreshModel(self):

   499

        self.Controler.SetVariables(self.Table.GetData())

   500

        self.RefreshBuffer()

   501

   502

    # Buffer the last model state

   503

    def RefreshBuffer(self):

   505

        self.ParentWindow.RefreshTitle()

   506

        self.ParentWindow.RefreshFileMenu()

   507

        self.ParentWindow.RefreshEditMenu()

   508

        self.ParentWindow.RefreshPageTitles()

   509

   510

    def RefreshView(self):

   511

        self.Table.SetData(self.Controler.GetVariables())

   512

        self.Table.ResetView(self.VariablesGrid)