1

import re

     2

     3

import wx

     4

import wx.grid

     5

import wx.stc as stc

     6

import wx.lib.buttons

     7

     8

from plcopen.plcopen import TestTextElement

     9

from controls import CustomGrid, CustomTable

    10

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    11

from util.BitmapLibrary import GetBitmap

    12

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl, faces, GetCursorPos

    13

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    14

    15

SECTIONS_NAMES = ["Includes", "Globals", "Init",

    16

                  "CleanUp", "Retrieve", "Publish"]

    17

    18

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT] = range(15, 17)

    19

    20

HIGHLIGHT_TYPES = {

    21

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    22

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    23

}

    24

    25

class CodeEditor(CustomStyledTextCtrl):

    26

    27

    KEYWORDS = []

    28

    COMMENT_HEADER = ""

    29

    30

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

    31

        CustomStyledTextCtrl.__init__(self, parent, -1, wx.DefaultPosition, 

    32

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

    33

    34

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    35

        self.SetMarginWidth(1, 25)

    36

    37

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

    38

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

    39

    40

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

    41

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

    42

        self.SetMargins(0,0)

    43

    44

        self.SetViewWhiteSpace(False)

    45

    46

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    47

        self.SetEdgeColumn(78)

    48

    49

        # Setup a margin to hold fold markers

    50

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    51

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    52

        self.SetMarginSensitive(2, True)

    53

        self.SetMarginWidth(2, 12)

    54

    55

        # Like a flattened tree control using square headers

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

    64

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

    65

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

    66

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

    67

    68

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

    69

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

    70

        # Scintilla sample property files.

    71

    72

        # Global default styles for all languages

    73

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

    74

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

    75

    76

        # Global default styles for all languages

    77

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

    78

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

    79

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

    80

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

    81

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

    82

    83

        # Highlighting styles

    84

        self.StyleSetSpec(STC_CODE_ERROR, 'fore:#FF0000,back:#FFFF00,size:%(size)d' % faces)

    85

        self.StyleSetSpec(STC_CODE_SEARCH_RESULT, 'fore:#FFFFFF,back:#FFA500,size:%(size)d' % faces)

    86

    87

        # register some images for use in the AutoComplete box.

    88

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

    89

        self.RegisterImage(1, 

    90

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

    91

        self.RegisterImage(2, 

    92

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

    93

        self.RegisterImage(3, 

    94

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

    95

    96

        # Indentation size

    97

        self.SetTabWidth(2)

    98

        self.SetUseTabs(0)

    99

   100

        self.SetCodeLexer()

   101

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

   102

   103

        self.Controler = controler

   104

        self.ParentWindow = window

   105

   106

        self.DisableEvents = True

   107

        self.CurrentAction = None

   108

   109

        self.Highlights = []

   110

        self.SearchParams = None

   111

        self.SearchResults = None

   112

        self.CurrentFindHighlight = None

   113

   114

        self.RefreshHighlightsTimer = wx.Timer(self, -1)

   115

        self.Bind(wx.EVT_TIMER, self.OnRefreshHighlightsTimer, self.RefreshHighlightsTimer)

   116

   117

        self.SectionsComments = {}

   118

        for section in SECTIONS_NAMES:

   119

            section_start_comment = "%s %s section\n" % (self.COMMENT_HEADER, section)

   120

            section_end_comment = "\n%s End %s section\n\n" % (self.COMMENT_HEADER, section)

   121

            self.SectionsComments[section] = {

   122

                 "start": section_start_comment,

   123

                 "end": section_end_comment,

   124

                 "pattern": re.compile(section_start_comment + 

   125

                                       "(.*)" + 

   126

                                       section_end_comment,

   127

                                       re.DOTALL)

   128

            }

   129

   130

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

   131

   132

        self.Bind(wx.stc.EVT_STC_DO_DROP, self.OnDoDrop)

   133

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

   134

        self.Bind(wx.stc.EVT_STC_MODIFIED, self.OnModification)

   135

   136

    def SetCodeLexer(self):

   137

        pass

   138

   139

    def OnModification(self, event):

   140

        if not self.DisableEvents:

   141

            mod_type = event.GetModificationType()

   142

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

   143

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   144

                    if self.CurrentAction == None:

   145

                        self.StartBuffering()

   146

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

   147

                        self.Controler.EndBuffering()

   148

                        self.StartBuffering()

   149

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

   150

                    wx.CallAfter(self.RefreshModel)

   151

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   152

                    if self.CurrentAction == None:

   153

                        self.StartBuffering()

   154

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

   155

                        self.Controler.EndBuffering()

   156

                        self.StartBuffering()

   157

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

   158

                    wx.CallAfter(self.RefreshModel)

   159

        event.Skip()

   160

   161

    def OnDoDrop(self, event):

   162

        self.ResetBuffer()

   163

        wx.CallAfter(self.RefreshModel)

   164

        event.Skip()

   165

   166

    # Buffer the last model state

   167

    def RefreshBuffer(self):

   168

        self.Controler.BufferCodeFile()

   169

        if self.ParentWindow is not None:

   170

            self.ParentWindow.RefreshTitle()

   171

            self.ParentWindow.RefreshFileMenu()

   172

            self.ParentWindow.RefreshEditMenu()

   173

            self.ParentWindow.RefreshPageTitles()

   174

   175

    def StartBuffering(self):

   176

        self.Controler.StartBuffering()

   177

        if self.ParentWindow is not None:

   178

            self.ParentWindow.RefreshTitle()

   179

            self.ParentWindow.RefreshFileMenu()

   180

            self.ParentWindow.RefreshEditMenu()

   181

            self.ParentWindow.RefreshPageTitles()

   182

   183

    def ResetBuffer(self):

   184

        if self.CurrentAction != None:

   185

            self.Controler.EndBuffering()

   186

            self.CurrentAction = None

   187

   188

    def GetCodeText(self):

   189

        parts = self.Controler.GetTextParts()

   190

        text = ""

   191

        for section in SECTIONS_NAMES:

   192

            section_comments = self.SectionsComments[section]

   193

            text += section_comments["start"]

   194

            text += parts[section]

   195

            text += section_comments["end"]

   196

        return text

   197

   199

        self.ResetBuffer()

   200

        self.DisableEvents = True

   201

        old_cursor_pos = self.GetCurrentPos()

   202

        line = self.GetFirstVisibleLine()

   203

        column = self.GetXOffset()

   204

        old_text = self.GetText()

   205

        new_text = self.GetCodeText()

   206

        if old_text != new_text:

   208

            new_cursor_pos = GetCursorPos(old_text, new_text)

   209

            self.LineScroll(column, line)

   210

            if new_cursor_pos != None:

   211

                self.GotoPos(new_cursor_pos)

   212

            else:

   213

                self.GotoPos(old_cursor_pos)

   214

            self.EmptyUndoBuffer()

   215

        self.DisableEvents = False

   216

   217

        self.Colourise(0, -1)

   218

   219

        self.ShowHighlights()

   220

   221

    def DoGetBestSize(self):

   222

        return self.ParentWindow.GetPanelBestSize()

   223

   224

    def RefreshModel(self):

   225

        text = self.GetText()

   226

        parts = {}

   227

        for section in SECTIONS_NAMES:

   228

            section_comments = self.SectionsComments[section]

   229

            result = section_comments["pattern"].search(text)

   230

            if result is not None:

   231

                parts[section] = result.group(1)

   232

            else:

   233

                parts[section] = ""

   234

        self.Controler.SetTextParts(parts)

   235

   236

    def OnKeyPressed(self, event):

   237

        if self.CallTipActive():

   238

            self.CallTipCancel()

   239

        key = event.GetKeyCode()

   240

   241

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

   242

            pos = self.GetCurrentPos()

   243

   244

            # Tips

   245

            if event.ShiftDown():

   246

                pass

   247

            # Code completion

   248

            else:

   249

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

   250

   251

                # Images are specified with a appended "?type"

   252

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

   253

        else:

   254

            event.Skip()

   255

   256

    def OnKillFocus(self, event):

   257

        self.AutoCompCancel()

   258

        event.Skip()

   259

   260

    def OnUpdateUI(self, evt):

   261

        # check for matching braces

   262

        braceAtCaret = -1

   263

        braceOpposite = -1

   264

        charBefore = None

   265

        caretPos = self.GetCurrentPos()

   266

   267

        if caretPos > 0:

   268

            charBefore = self.GetCharAt(caretPos - 1)

   269

            styleBefore = self.GetStyleAt(caretPos - 1)

   270

   271

        # check before

   272

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

   273

            braceAtCaret = caretPos - 1

   274

   275

        # check after

   276

        if braceAtCaret < 0:

   277

            charAfter = self.GetCharAt(caretPos)

   278

            styleAfter = self.GetStyleAt(caretPos)

   279

   280

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

   281

                braceAtCaret = caretPos

   282

   283

        if braceAtCaret >= 0:

   284

            braceOpposite = self.BraceMatch(braceAtCaret)

   285

   286

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

   287

            self.BraceBadLight(braceAtCaret)

   288

        else:

   289

            self.BraceHighlight(braceAtCaret, braceOpposite)

   290

   291

    def OnMarginClick(self, evt):

   292

        # fold and unfold as needed

   293

        if evt.GetMargin() == 2:

   294

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

   295

                self.FoldAll()

   296

            else:

   297

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

   298

   299

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

   300

                    if evt.GetShift():

   301

                        self.SetFoldExpanded(lineClicked, True)

   302

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

   303

                    elif evt.GetControl():

   304

                        if self.GetFoldExpanded(lineClicked):

   305

                            self.SetFoldExpanded(lineClicked, False)

   306

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

   307

                        else:

   308

                            self.SetFoldExpanded(lineClicked, True)

   309

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

   310

                    else:

   311

                        self.ToggleFold(lineClicked)

   312

   313

   314

    def FoldAll(self):

   315

        lineCount = self.GetLineCount()

   316

        expanding = True

   317

   318

        # find out if we are folding or unfolding

   319

        for lineNum in range(lineCount):

   320

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

   321

                expanding = not self.GetFoldExpanded(lineNum)

   322

                break

   323

   324

        lineNum = 0

   325

   326

        while lineNum < lineCount:

   327

            level = self.GetFoldLevel(lineNum)

   328

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   329

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

   330

   331

                if expanding:

   332

                    self.SetFoldExpanded(lineNum, True)

   333

                    lineNum = self.Expand(lineNum, True)

   334

                    lineNum = lineNum - 1

   335

                else:

   336

                    lastChild = self.GetLastChild(lineNum, -1)

   337

                    self.SetFoldExpanded(lineNum, False)

   338

   339

                    if lastChild > lineNum:

   340

                        self.HideLines(lineNum+1, lastChild)

   341

   342

            lineNum = lineNum + 1

   343

   344

   345

   346

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

   347

        lastChild = self.GetLastChild(line, level)

   348

        line = line + 1

   349

   350

        while line <= lastChild:

   351

            if force:

   352

                if visLevels > 0:

   353

                    self.ShowLines(line, line)

   354

                else:

   355

                    self.HideLines(line, line)

   356

            else:

   357

                if doExpand:

   358

                    self.ShowLines(line, line)

   359

   360

            if level == -1:

   361

                level = self.GetFoldLevel(line)

   362

   363

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   364

                if force:

   365

                    if visLevels > 1:

   366

                        self.SetFoldExpanded(line, True)

   367

                    else:

   368

                        self.SetFoldExpanded(line, False)

   369

   370

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

   371

   372

                else:

   373

                    if doExpand and self.GetFoldExpanded(line):

   374

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

   375

                    else:

   376

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

   377

            else:

   378

                line = line + 1

   379

   380

        return line

   381

   382

    def Cut(self):

   383

        self.ResetBuffer()

   384

        self.DisableEvents = True

   385

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   386

        self.DisableEvents = False

   387

        self.RefreshModel()

   388

        self.RefreshBuffer()

   389

   390

    def Copy(self):

   391

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   392

   393

    def Paste(self):

   394

        self.ResetBuffer()

   395

        self.DisableEvents = True

   396

        self.CmdKeyExecute(wx.stc.STC_CMD_PASTE)

   397

        self.DisableEvents = False

   398

        self.RefreshModel()

   399

        self.RefreshBuffer()

   400

   401

    def Find(self, direction, search_params):

   402

        if self.SearchParams != search_params:

   403

            self.ClearHighlights(SEARCH_RESULT_HIGHLIGHT)

   404

   405

            self.SearchParams = search_params

   406

            criteria = {

   407

                "raw_pattern": search_params["find_pattern"], 

   408

                "pattern": re.compile(search_params["find_pattern"]),

   409

                "case_sensitive": search_params["case_sensitive"],

   410

                "regular_expression": search_params["regular_expression"],

   411

                "filter": "all"}

   412

   413

            self.SearchResults = [

   414

                (start, end, SEARCH_RESULT_HIGHLIGHT)

   415

                for start, end, text in 

   416

                TestTextElement(self.GetText(), criteria)]

   417

            self.CurrentFindHighlight = None

   418

   419

        if len(self.SearchResults) > 0:

   420

            if self.CurrentFindHighlight is not None:

   421

                old_idx = self.SearchResults.index(self.CurrentFindHighlight)

   422

                if self.SearchParams["wrap"]:

   423

                    idx = (old_idx + direction) % len(self.SearchResults)

   424

                else:

   425

                    idx = max(0, min(old_idx + direction, len(self.SearchResults) - 1))

   426

                if idx != old_idx:

   427

                    self.RemoveHighlight(*self.CurrentFindHighlight)

   428

                    self.CurrentFindHighlight = self.SearchResults[idx]

   429

                    self.AddHighlight(*self.CurrentFindHighlight)

   430

            else:

   431

                self.CurrentFindHighlight = self.SearchResults[0]

   432

                self.AddHighlight(*self.CurrentFindHighlight)

   433

   436

        else:

   437

            if self.CurrentFindHighlight is not None:

   438

                self.RemoveHighlight(*self.CurrentFindHighlight)

   439

            self.CurrentFindHighlight = None

   440

   441

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

   442

#                        Highlights showing functions

   443

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

   444

   445

    def OnRefreshHighlightsTimer(self, event):

   447

        event.Skip()

   448

   449

    def ClearHighlights(self, highlight_type=None):

   450

        if highlight_type is None:

   451

            self.Highlights = []

   452

        else:

   453

            highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)

   454

            if highlight_type is not None:

   455

                self.Highlights = [(start, end, highlight) for (start, end, highlight) in self.Highlights if highlight != highlight_type]

   456

        self.RefreshView()

   457

   458

    def AddHighlight(self, start, end, highlight_type):

   459

        highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)

   460

        if highlight_type is not None:

   461

            self.Highlights.append((start, end, highlight_type))

   462

            self.GotoPos(self.PositionFromLine(start[0]) + start[1])

   463

            self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)

   464

            self.RefreshView()

   465

   466

    def RemoveHighlight(self, start, end, highlight_type):

   467

        highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)

   468

        if (highlight_type is not None and 

   469

            (start, end, highlight_type) in self.Highlights):

   470

            self.Highlights.remove((start, end, highlight_type))

   471

            self.RefreshHighlightsTimer.Start(int(REFRESH_HIGHLIGHT_PERIOD * 1000), oneShot=True)

   472

   473

    def ShowHighlights(self):

   474

        for start, end, highlight_type in self.Highlights:

   475

            if start[0] == 0:

   476

                highlight_start_pos = start[1]

   477

            else:

   478

                highlight_start_pos = self.GetLineEndPosition(start[0] - 1) + start[1] + 1

   479

            if end[0] == 0:

   480

                highlight_end_pos = end[1] - indent + 1

   481

            else:

   482

                highlight_end_pos = self.GetLineEndPosition(end[0] - 1) + end[1] + 2

   483

            self.StartStyling(highlight_start_pos, 0xff)

   484

            self.SetStyling(highlight_end_pos - highlight_start_pos, highlight_type)

   485

            self.StartStyling(highlight_start_pos, 0x00)

   486

            self.SetStyling(len(self.GetText()) - highlight_end_pos, stc.STC_STYLE_DEFAULT)

   487

   488

   489

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

   490

#                         Helper for VariablesGrid values

   491

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

   492

   493

class VariablesTable(CustomTable):

   494

   495

    def GetValue(self, row, col):

   496

        if row < self.GetNumberRows():

   497

            if col == 0:

   498

                return row + 1

   499

            else:

   500

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

   501

   502

    def _updateColAttrs(self, grid):

   503

        """

   504

        wxGrid -> update the column attributes to add the

   505

        appropriate renderer given the column name.

   506

   507

        Otherwise default to the default renderer.

   508

        """

   509