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

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT, 

    16

 STC_CODE_SECTION] = range(15, 18)

    17

    18

HIGHLIGHT_TYPES = {

    19

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    20

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    21

}

    22

    23

class CodeEditor(CustomStyledTextCtrl):

    24

    25

    KEYWORDS = []

    26

    COMMENT_HEADER = ""

    27

    28

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

    29

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

    30

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

    31

    32

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    33

        self.SetMarginWidth(1, 25)

    34

    35

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

    36

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

    37

    38

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

    39

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

    40

        self.SetMargins(0,0)

    41

    42

        self.SetViewWhiteSpace(False)

    43

    44

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    45

        self.SetEdgeColumn(78)

    46

    47

        # Setup a margin to hold fold markers

    48

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    49

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    50

        self.SetMarginSensitive(2, True)

    51

        self.SetMarginWidth(2, 12)

    52

    53

        # Like a flattened tree control using square headers

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

    62

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

    63

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

    64

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

    65

    66

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

    67

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

    68

        # Scintilla sample property files.

    69

    70

        # Global default styles for all languages

    71

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

    72

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

    73

    74

        # Global default styles for all languages

    75

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

    76

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

    77

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

    78

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

    79

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

    80

    81

        # Highlighting styles

    82

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

    83

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

    84

    85

        # Section style

    86

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

    87

        self.StyleSetChangeable(STC_CODE_SECTION, False)

    88

    89

        # register some images for use in the AutoComplete box.

    90

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

    91

        self.RegisterImage(1, 

    92

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

    93

        self.RegisterImage(2, 

    94

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

    95

        self.RegisterImage(3, 

    96

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

    97

    98

        # Indentation size

    99

        self.SetTabWidth(2)

   100

        self.SetUseTabs(0)

   101

   102

        self.SetCodeLexer()

   103

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

   104

   105

        self.Controler = controler

   106

        self.ParentWindow = window

   107

   108

        self.DisableEvents = True

   109

        self.CurrentAction = None

   110

   111

        self.Highlights = []

   112

        self.SearchParams = None

   113

        self.SearchResults = None

   114

        self.CurrentFindHighlight = None

   115

   116

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

   117

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

   118

   119

        self.SectionsComments = {}

   120

        for section in self.Controler.SECTIONS_NAMES:

   121

            section_comment = " %s section " % (section)

   122

            len_headers = 78 - len(section_comment)

   123

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

   124

                              section_comment + \

   125

                              self.COMMENT_HEADER * (len_headers - len_headers / 2)

   126

   127

            self.SectionsComments[section] = {

   128

                 "comment": section_comment,

   129

            }

   130

   131

        for i, section in enumerate(self.Controler.SECTIONS_NAMES):

   132

            section_infos = self.SectionsComments[section]

   133

            if i + 1 < len(self.Controler.SECTIONS_NAMES):

   134

                section_end = self.SectionsComments[

   135

                    self.Controler.SECTIONS_NAMES[i + 1]]["comment"]

   136

            else:

   137

                section_end = "$"

   138

            section_infos["pattern"] = re.compile(

   139

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

   140

                section_end, re.DOTALL)

   141

   142

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

   143

   144

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

   145

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

   146

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

   147

   148

    def SetCodeLexer(self):

   149

        pass

   150

   151

    def OnModification(self, event):

   152

        if not self.DisableEvents:

   153

            mod_type = event.GetModificationType()

   154

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

   155

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   156

                    if self.CurrentAction == None:

   157

                        self.StartBuffering()

   158

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

   159

                        self.Controler.EndBuffering()

   160

                        self.StartBuffering()

   161

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

   162

                    wx.CallAfter(self.RefreshModel)

   163

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   164

                    if self.CurrentAction == None:

   165

                        self.StartBuffering()

   166

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

   167

                        self.Controler.EndBuffering()

   168

                        self.StartBuffering()

   169

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

   170

                    wx.CallAfter(self.RefreshModel)

   171

        wx.CallAfter(self.RefreshSectionStyling)

   172

        event.Skip()

   173

   174

    def OnDoDrop(self, event):

   175

        try:

   176

            values = eval(event.GetDragText())

   177

        except:

   178

            values = event.GetDragText()

   179

        if isinstance(values, tuple):

   180

            message = None

   181

            if values[3] == self.Controler.GetCurrentLocation():

   182

                self.ResetBuffer()

   183

                event.SetDragText(values[0])

   184

                wx.CallAfter(self.RefreshModel)

   185

            else:

   186

                event.SetDragText("")

   187

        else:

   188

            self.ResetBuffer()

   189

            wx.CallAfter(self.RefreshModel)

   190

        event.Skip()

   191

   192

    # Buffer the last model state

   193

    def RefreshBuffer(self):

   194

        self.Controler.BufferCodeFile()

   195

        if self.ParentWindow is not None:

   196

            self.ParentWindow.RefreshTitle()

   197

            self.ParentWindow.RefreshFileMenu()

   198

            self.ParentWindow.RefreshEditMenu()

   199

            self.ParentWindow.RefreshPageTitles()

   200

   201

    def StartBuffering(self):

   202

        self.Controler.StartBuffering()

   203

        if self.ParentWindow is not None:

   204

            self.ParentWindow.RefreshTitle()

   205

            self.ParentWindow.RefreshFileMenu()

   206

            self.ParentWindow.RefreshEditMenu()

   207

            self.ParentWindow.RefreshPageTitles()

   208

   209

    def ResetBuffer(self):

   210

        if self.CurrentAction != None:

   211

            self.Controler.EndBuffering()

   212

            self.CurrentAction = None

   213

   214

    def GetCodeText(self):

   215

        parts = self.Controler.GetTextParts()

   216

        text = ""

   217

        for section in self.Controler.SECTIONS_NAMES:

   218

            section_comments = self.SectionsComments[section]

   219

            text += section_comments["comment"]

   220

            if parts[section] == "":

   221

                text += "\n"

   222

            else:

   223

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

   224

                    text += "\n"

   225

                text += parts[section]

   226

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

   227

                    text += "\n"

   228

        return text

   229

   230

    def RefreshView(self, scroll_to_highlight=False):

   231

        self.ResetBuffer()

   232

        self.DisableEvents = True

   233

        old_cursor_pos = self.GetCurrentPos()

   234

        line = self.GetFirstVisibleLine()

   235

        column = self.GetXOffset()

   236

        old_text = self.GetText()

   237

        new_text = self.GetCodeText()

   238

        if old_text != new_text:

   239

            self.SetText(new_text)

   240

            new_cursor_pos = GetCursorPos(old_text, new_text)

   241

            self.LineScroll(column, line)

   242

            if new_cursor_pos != None:

   243

                self.GotoPos(new_cursor_pos)

   244

            else:

   245

                self.GotoPos(old_cursor_pos)

   246

            self.EmptyUndoBuffer()

   247

        self.DisableEvents = False

   248

   249

        self.RefreshSectionStyling()

   250

   251

        self.ShowHighlights()

   252

   253

    def RefreshSectionStyling(self):

   254

        self.Colourise(0, -1)

   255

   256

        text = self.GetText()

   257

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

   258

            self.SetLineState(line, 0)

   259

   260

        for section in self.Controler.SECTIONS_NAMES:

   261

            section_comments = self.SectionsComments[section]

   262

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

   263

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

   264

            self.StartStyling(start_pos, 0xff)

   265

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   266

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

   267

   268

        self.StartStyling(end_pos, 0x00)

   269

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

   270

   271

    def DoGetBestSize(self):

   272

        return self.ParentWindow.GetPanelBestSize()

   273

   274

    def RefreshModel(self):

   275

        text = self.GetText()

   276

        parts = {}

   277

        for section in self.Controler.SECTIONS_NAMES:

   278

            section_comments = self.SectionsComments[section]

   279

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

   280

            if result is not None:

   281

                parts[section] = result.group(1)

   282

            else:

   283

                parts[section] = ""

   284

        self.Controler.SetTextParts(parts)

   285

   286

    def OnKeyPressed(self, event):

   287

        if self.CallTipActive():

   288

            self.CallTipCancel()

   289

        key = event.GetKeyCode()

   290

        current_pos = self.GetCurrentPos()

   291

        selected = self.GetSelection()

   292

        text_selected = selected[0] != selected[1]

   293

   294

        # Test if caret is before Windows like new line

   295

        text = self.GetText()

   296

        if ord(text[current_pos]) == 13:

   297

            newline_size = 2

   298

        else:

   299

            newline_size = 1

   300

   301

        # Disable to type any character in section header lines

   302

        if (self.GetLineState(self.LineFromPosition(current_pos)) and

   303

            not text_selected and

   304

            key not in NAVIGATION_KEYS + [

   305

                wx.WXK_RETURN,

   306

                wx.WXK_NUMPAD_ENTER]):

   307

            return

   308

   309

        # Disable to delete line between code and header lines

   310

        elif (self.GetCurLine()[0].strip() != "" and not text_selected and

   311

              (key == wx.WXK_BACK and

   312

               self.GetLineState(self.LineFromPosition(max(0, current_pos - 1))) or

   313

               key in [wx.WXK_DELETE, wx.WXK_NUMPAD_DELETE] and

   314

               self.GetLineState(self.LineFromPosition(min(len(text), current_pos + newline_size))))):

   315

            return

   316

   317

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

   318

            pos = self.GetCurrentPos()

   319

   320

            # Tips

   321

            if event.ShiftDown():

   322

                pass

   323

            # Code completion

   324

            else:

   325

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

   326

   327

                keywords = self.KEYWORDS + [var["Name"]

   328

                                            for var in self.Controler.GetVariables()]

   329

                keywords.sort()

   330

                self.AutoCompShow(0, " ".join(keywords))

   331

        else:

   332

            event.Skip()

   333

   334

    def OnKillFocus(self, event):

   335

        self.AutoCompCancel()

   336

        event.Skip()

   337

   338

    def OnUpdateUI(self, event):

   339

        # check for matching braces

   340

        braceAtCaret = -1

   341

        braceOpposite = -1

   342

        charBefore = None

   343

        caretPos = self.GetCurrentPos()

   344

   345

        if caretPos > 0:

   346

            charBefore = self.GetCharAt(caretPos - 1)

   347

            styleBefore = self.GetStyleAt(caretPos - 1)

   348

   349

        # check before

   350

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

   351

            braceAtCaret = caretPos - 1

   352

   353

        # check after

   354

        if braceAtCaret < 0:

   355

            charAfter = self.GetCharAt(caretPos)

   356

            styleAfter = self.GetStyleAt(caretPos)

   357

   358

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

   359

                braceAtCaret = caretPos

   360

   361

        if braceAtCaret >= 0:

   362

            braceOpposite = self.BraceMatch(braceAtCaret)

   363

   364

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

   365

            self.BraceBadLight(braceAtCaret)

   366

        else:

   367

            self.BraceHighlight(braceAtCaret, braceOpposite)

   368

   369

        self.ParentWindow.SetCopyBuffer(self.GetSelectedText(), True)

   370

        event.Skip()

   371

   372

    def OnMarginClick(self, event):

   373

        # fold and unfold as needed

   374

        if evt.GetMargin() == 2:

   375

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

   376

                self.FoldAll()

   377

            else:

   378

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

   379

   380

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

   381

                    if evt.GetShift():

   382

                        self.SetFoldExpanded(lineClicked, True)

   383

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

   384

                    elif evt.GetControl():

   385

                        if self.GetFoldExpanded(lineClicked):

   386

                            self.SetFoldExpanded(lineClicked, False)

   387

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

   388

                        else:

   389

                            self.SetFoldExpanded(lineClicked, True)

   390

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

   391

                    else:

   392

                        self.ToggleFold(lineClicked)

   393

        event.Skip()

   394

   395

    def FoldAll(self):

   396

        lineCount = self.GetLineCount()

   397

        expanding = True

   398

   399

        # find out if we are folding or unfolding

   400

        for lineNum in range(lineCount):

   401

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

   402

                expanding = not self.GetFoldExpanded(lineNum)

   403

                break

   404

   405

        lineNum = 0

   406

   407

        while lineNum < lineCount:

   408

            level = self.GetFoldLevel(lineNum)

   409

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   410

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

   411

   412

                if expanding:

   413

                    self.SetFoldExpanded(lineNum, True)

   414

                    lineNum = self.Expand(lineNum, True)

   415

                    lineNum = lineNum - 1

   416

                else:

   417

                    lastChild = self.GetLastChild(lineNum, -1)

   418

                    self.SetFoldExpanded(lineNum, False)

   419

   420

                    if lastChild > lineNum:

   421

                        self.HideLines(lineNum+1, lastChild)

   422

   423

            lineNum = lineNum + 1

   424

   425

   426

   427

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

   428

        lastChild = self.GetLastChild(line, level)

   429

        line = line + 1

   430

   431

        while line <= lastChild:

   432

            if force:

   433

                if visLevels > 0:

   434

                    self.ShowLines(line, line)

   435

                else:

   436

                    self.HideLines(line, line)

   437

            else:

   438

                if doExpand:

   439

                    self.ShowLines(line, line)

   440

   441

            if level == -1:

   442

                level = self.GetFoldLevel(line)

   443

   444

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   445

                if force:

   446

                    if visLevels > 1:

   447

                        self.SetFoldExpanded(line, True)

   448

                    else:

   449

                        self.SetFoldExpanded(line, False)

   450

   451

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

   452

   453

                else:

   454

                    if doExpand and self.GetFoldExpanded(line):

   455

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

   456

                    else:

   457

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

   458

            else:

   459

                line = line + 1

   460

   461

        return line

   462

   463

    def Cut(self):

   464

        self.ResetBuffer()

   465

        self.DisableEvents = True

   466

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   467

        self.DisableEvents = False

   468

        self.RefreshModel()

   469

        self.RefreshBuffer()

   470

   471

    def Copy(self):

   472

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   473

        self.ParentWindow.RefreshEditMenu()

   474

   475

    def Paste(self):

   476

        self.ResetBuffer()

   477

        self.DisableEvents = True

   478

        self.CmdKeyExecute(wx.stc.STC_CMD_PASTE)

   479

        self.DisableEvents = False

   480

        self.RefreshModel()

   481

        self.RefreshBuffer()

   482

   483

    def Find(self, direction, search_params):

   484

        if self.SearchParams != search_params:

   485

            self.ClearHighlights(SEARCH_RESULT_HIGHLIGHT)

   486

   487

            self.SearchParams = search_params

   488

            criteria = {

   489

                "raw_pattern": search_params["find_pattern"], 

   490

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

   491

                "case_sensitive": search_params["case_sensitive"],

   492

                "regular_expression": search_params["regular_expression"],

   493

                "filter": "all"}

   494

   495

            self.SearchResults = [

   496

                (start, end, SEARCH_RESULT_HIGHLIGHT)

   497

                for start, end, text in 

   498

                TestTextElement(self.GetText(), criteria)]

   499

            self.CurrentFindHighlight = None

   500

   501

        if len(self.SearchResults) > 0:

   502

            if self.CurrentFindHighlight is not None:

   503

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

   504

                if self.SearchParams["wrap"]:

   505