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, NAVIGATION_KEYS

    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, 

    19

 STC_CODE_SECTION] = range(15, 18)

    20

    21

HIGHLIGHT_TYPES = {

    22

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    23

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    24

}

    25

    26

class CodeEditor(CustomStyledTextCtrl):

    27

    28

    KEYWORDS = []

    29

    COMMENT_HEADER = ""

    30

    31

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

    32

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

    33

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

    34

    35

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    36

        self.SetMarginWidth(1, 25)

    37

    38

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

    39

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

    40

    41

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

    42

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

    43

        self.SetMargins(0,0)

    44

    45

        self.SetViewWhiteSpace(False)

    46

    47

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    48

        self.SetEdgeColumn(78)

    49

    50

        # Setup a margin to hold fold markers

    51

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    52

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    53

        self.SetMarginSensitive(2, True)

    54

        self.SetMarginWidth(2, 12)

    55

    56

        # Like a flattened tree control using square headers

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

    65

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

    66

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

    67

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

    68

    69

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

    70

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

    71

        # Scintilla sample property files.

    72

    73

        # Global default styles for all languages

    74

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

    75

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

    76

    77

        # Global default styles for all languages

    78

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

    79

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

    80

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

    81

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

    82

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

    83

    84

        # Highlighting styles

    85

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

    86

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

    87

    88

        # Section style

    89

        self.StyleSetSpec(STC_CODE_SECTION, 'fore:#808080,size:%(size)d')

    90

        self.StyleSetChangeable(STC_CODE_SECTION, False)

    91

    92

        # register some images for use in the AutoComplete box.

    93

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

    94

        self.RegisterImage(1, 

    95

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

    96

        self.RegisterImage(2, 

    97

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

    98

        self.RegisterImage(3, 

    99

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

   100

   101

        # Indentation size

   102

        self.SetTabWidth(2)

   103

        self.SetUseTabs(0)

   104

   105

        self.SetCodeLexer()

   106

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

   107

   108

        self.Controler = controler

   109

        self.ParentWindow = window

   110

   111

        self.DisableEvents = True

   112

        self.CurrentAction = None

   113

   114

        self.Highlights = []

   115

        self.SearchParams = None

   116

        self.SearchResults = None

   117

        self.CurrentFindHighlight = None

   118

   119

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

   120

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

   121

   122

        self.SectionsComments = {}

   123

        for section in SECTIONS_NAMES:

   124

            section_comment = " %s section " % (section)

   125

            len_headers = 78 - len(section_comment)

   126

            section_comment = self.COMMENT_HEADER * (len_headers / 2) + \

   127

                              section_comment + \

   128

                              self.COMMENT_HEADER * (len_headers - len_headers / 2)

   129

   130

            self.SectionsComments[section] = {

   131

                 "comment": section_comment,

   132

            }

   133

   134

        for i, section in enumerate(SECTIONS_NAMES):

   135

            section_infos = self.SectionsComments[section]

   136

            if i + 1 < len(SECTIONS_NAMES):

   137

                section_end = self.SectionsComments[SECTIONS_NAMES[i + 1]]["comment"]

   138

            else:

   139

                section_end = "$"

   140

            section_infos["pattern"] = re.compile(

   141

                section_infos["comment"] + "(.*)" + 

   142

                section_end, re.DOTALL)

   143

   144

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

   145

   146

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

   147

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

   148

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

   149

   150

    def SetCodeLexer(self):

   151

        pass

   152

   153

    def OnModification(self, event):

   154

        if not self.DisableEvents:

   155

            mod_type = event.GetModificationType()

   156

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

   157

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   158

                    if self.CurrentAction == None:

   159

                        self.StartBuffering()

   160

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

   161

                        self.Controler.EndBuffering()

   162

                        self.StartBuffering()

   163

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

   164

                    wx.CallAfter(self.RefreshModel)

   165

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   166

                    if self.CurrentAction == None:

   167

                        self.StartBuffering()

   168

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

   169

                        self.Controler.EndBuffering()

   170

                        self.StartBuffering()

   171

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

   172

                    wx.CallAfter(self.RefreshModel)

   173

        wx.CallAfter(self.RefreshSectionStyling)

   174

        event.Skip()

   175

   176

    def OnDoDrop(self, event):

   177

        self.ResetBuffer()

   178

        wx.CallAfter(self.RefreshModel)

   179

        event.Skip()

   180

   181

    # Buffer the last model state

   182

    def RefreshBuffer(self):

   183

        self.Controler.BufferCodeFile()

   184

        if self.ParentWindow is not None:

   185

            self.ParentWindow.RefreshTitle()

   186

            self.ParentWindow.RefreshFileMenu()

   187

            self.ParentWindow.RefreshEditMenu()

   188

            self.ParentWindow.RefreshPageTitles()

   189

   190

    def StartBuffering(self):

   191

        self.Controler.StartBuffering()

   192

        if self.ParentWindow is not None:

   193

            self.ParentWindow.RefreshTitle()

   194

            self.ParentWindow.RefreshFileMenu()

   195

            self.ParentWindow.RefreshEditMenu()

   196

            self.ParentWindow.RefreshPageTitles()

   197

   198

    def ResetBuffer(self):

   199

        if self.CurrentAction != None:

   200

            self.Controler.EndBuffering()

   201

            self.CurrentAction = None

   202

   203

    def GetCodeText(self):

   204

        parts = self.Controler.GetTextParts()

   205

        text = ""

   206

        for section in SECTIONS_NAMES:

   207

            section_comments = self.SectionsComments[section]

   208

            text += section_comments["comment"]

   209

            if not parts[section].startswith("\n") or parts[section] == "\n":

   210

                text += "\n"

   211

            text += parts[section]

   212

            if not parts[section].endswith("\n"):

   213

                text += "\n"

   214

        return text

   215

   216

    def RefreshView(self, scroll_to_highlight=False):

   217

        self.ResetBuffer()

   218

        self.DisableEvents = True

   219

        old_cursor_pos = self.GetCurrentPos()

   220

        line = self.GetFirstVisibleLine()

   221

        column = self.GetXOffset()

   222

        old_text = self.GetText()

   223

        new_text = self.GetCodeText()

   224

        if old_text != new_text:

   225

            self.SetText(new_text)

   226

            new_cursor_pos = GetCursorPos(old_text, new_text)

   227

            self.LineScroll(column, line)

   228

            if new_cursor_pos != None:

   229

                self.GotoPos(new_cursor_pos)

   230

            else:

   231

                self.GotoPos(old_cursor_pos)

   232

            self.EmptyUndoBuffer()

   233

        self.DisableEvents = False

   234

   235

        self.RefreshSectionStyling()

   236

   237

        self.ShowHighlights()

   238

   239

    def RefreshSectionStyling(self):

   240

        self.Colourise(0, -1)

   241

   242

        text = self.GetText()

   243

        for line in xrange(self.GetLineCount()):

   244

            self.SetLineState(line, 0)

   245

   246

        for section in SECTIONS_NAMES:

   247

            section_comments = self.SectionsComments[section]

   248

            start_pos = text.find(section_comments["comment"])

   249

            end_pos = start_pos + len(section_comments["comment"])

   250

            self.StartStyling(start_pos, 0xff)

   251

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   252

            self.SetLineState(self.LineFromPosition(start_pos), 1)

   253

   254

        self.StartStyling(end_pos, 0x00)

   255

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

   256

   257

    def DoGetBestSize(self):

   258

        return self.ParentWindow.GetPanelBestSize()

   259

   260

    def RefreshModel(self):

   261

        text = self.GetText()

   262

        parts = {}

   263

        for section in SECTIONS_NAMES:

   264

            section_comments = self.SectionsComments[section]

   265

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

   266

            if result is not None:

   267

                parts[section] = result.group(1)

   268

            else:

   269

                parts[section] = ""

   270

        self.Controler.SetTextParts(parts)

   271

   272

    def OnKeyPressed(self, event):

   273

        if self.CallTipActive():

   274

            self.CallTipCancel()

   275

        key = event.GetKeyCode()

   276

   277

        if (self.GetLineState(self.LineFromPosition(self.GetSelection()[0])) and

   278

            key not in NAVIGATION_KEYS):

   279

            return

   280

   281

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

   282

            pos = self.GetCurrentPos()

   283

   284

            # Tips

   285

            if event.ShiftDown():

   286

                pass

   287

            # Code completion

   288

            else:

   289

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

   290

   291

                # Images are specified with a appended "?type"

   292

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

   293

        else:

   294

            event.Skip()

   295

   296

    def OnKillFocus(self, event):

   297

        self.AutoCompCancel()

   298

        event.Skip()

   299

   300

    def OnUpdateUI(self, evt):

   301

        # check for matching braces

   302

        braceAtCaret = -1

   303

        braceOpposite = -1

   304

        charBefore = None

   305

        caretPos = self.GetCurrentPos()

   306

   307

        if caretPos > 0:

   308

            charBefore = self.GetCharAt(caretPos - 1)

   309

            styleBefore = self.GetStyleAt(caretPos - 1)

   310

   311

        # check before

   312

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

   313

            braceAtCaret = caretPos - 1

   314

   315

        # check after

   316

        if braceAtCaret < 0:

   317

            charAfter = self.GetCharAt(caretPos)

   318

            styleAfter = self.GetStyleAt(caretPos)

   319

   320

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

   321

                braceAtCaret = caretPos

   322

   323

        if braceAtCaret >= 0:

   324

            braceOpposite = self.BraceMatch(braceAtCaret)

   325

   326

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

   327

            self.BraceBadLight(braceAtCaret)

   328

        else:

   329

            self.BraceHighlight(braceAtCaret, braceOpposite)

   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

    def Cut(self):

   423

        self.ResetBuffer()

   424

        self.DisableEvents = True

   425

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   426

        self.DisableEvents = False

   427

        self.RefreshModel()

   428

        self.RefreshBuffer()

   429

   430

    def Copy(self):

   431

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   432

   433

    def Paste(self):

   434

        self.ResetBuffer()

   435

        self.DisableEvents = True

   436

        self.CmdKeyExecute(wx.stc.STC_CMD_PASTE)

   437

        self.DisableEvents = False

   438

        self.RefreshModel()

   439

        self.RefreshBuffer()

   440

   441

    def Find(self, direction, search_params):

   442

        if self.SearchParams != search_params:

   443

            self.ClearHighlights(SEARCH_RESULT_HIGHLIGHT)

   444

   445

            self.SearchParams = search_params

   446

            criteria = {

   447

                "raw_pattern": search_params["find_pattern"], 

   448

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

   449

                "case_sensitive": search_params["case_sensitive"],

   450

                "regular_expression": search_params["regular_expression"],

   451

                "filter": "all"}

   452

   453

            self.SearchResults = [

   454

                (start, end, SEARCH_RESULT_HIGHLIGHT)

   455

                for start, end, text in 

   456

                TestTextElement(self.GetText(), criteria)]

   457

            self.CurrentFindHighlight = None

   458

   459

        if len(self.SearchResults) > 0:

   460

            if self.CurrentFindHighlight is not None:

   461

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

   462

                if self.SearchParams["wrap"]:

   463

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

   464

                else:

   465

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

   466

                if idx != old_idx:

   467

                    self.RemoveHighlight(*self.CurrentFindHighlight)

   468

                    self.CurrentFindHighlight = self.SearchResults[idx]

   469

                    self.AddHighlight(*self.CurrentFindHighlight)

   470

            else:

   471

                self.CurrentFindHighlight = self.SearchResults[0]

   472

                self.AddHighlight(*self.CurrentFindHighlight)

   473

   474

            self.ScrollToLine(self.CurrentFindHighlight[0][0])

   475

   476

        else:

   477

            if self.CurrentFindHighlight is not None:

   478

                self.RemoveHighlight(*self.CurrentFindHighlight)

   479

            self.CurrentFindHighlight = None

   480

   481

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

   482

#                        Highlights showing functions

   483

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

   484

   485

    def OnRefreshHighlightsTimer(self, event):

   486

        self.RefreshView(True)

   487

        event.Skip()

   488

   489

    def ClearHighlights(self, highlight_type=None):

   490

        if highlight_type is None:

   491

            self.Highlights = []

   492

        else:

   493

            highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)

   494

            if highlight_type is not None:

   495

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

   496

        self.RefreshView()

   497

   498

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

   499

        highlight_type = HIGHLIGHT_TYPES.get(highlight_type, None)

   500

        if highlight_type is not None:

   501

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

   502

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

   503

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

   504

            self.RefreshView()

   505

   506

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

   507