1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import re

    26

    27

import wx

    28

import wx.grid

    29

import wx.stc as stc

    30

import wx.lib.buttons

    31

    32

from plcopen.plcopen import TestTextElement

    33

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    34

from controls import CustomGrid, CustomTable

    35

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    36

from util.BitmapLibrary import GetBitmap

    37

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl, faces, GetCursorPos, NAVIGATION_KEYS

    38

from controls.VariablePanel import VARIABLE_NAME_SUFFIX_MODEL

    39

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    40

    41

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    42

 STC_CODE_SECTION] = range(15, 18)

    43

    44

HIGHLIGHT_TYPES = {

    45

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    46

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    47

}

    48

    49

EDGE_COLUMN = 80

    50

    51

class CodeEditor(CustomStyledTextCtrl):

    52

    53

    KEYWORDS = []

    54

    COMMENT_HEADER = ""

    55

    56

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

    57

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

    58

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

    59

    60

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    61

        self.SetMarginWidth(1, 25)

    62

    63

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

    64

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

    65

        self.SetMargins(0,0)

    66

    67

        self.SetViewWhiteSpace(False)

    68

    69

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    70

        self.SetEdgeColumn(EDGE_COLUMN)

    71

    72

        # Setup a margin to hold fold markers

    73

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    74

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    75

        self.SetMarginSensitive(2, True)

    76

        self.SetMarginWidth(2, 12)

    77

    78

        # Like a flattened tree control using square headers

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

    87

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

    88

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

    89

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

    90

    91

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

    92

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

    93

        # Scintilla sample property files.

    94

    95

        # Global default styles for all languages

    96

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

    97

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

    98

    99

        # Global default styles for all languages

   100

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

   101

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

   102

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

   103

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

   104

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

   105

   106

        # Highlighting styles

   107

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

   108

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

   109

   110

        # Section style

   111

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

   112

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   113

   114

        # Indentation size

   115

        self.SetTabWidth(4)

   116

        self.SetUseTabs(0)

   117

   118

        self.SetCodeLexer()

   119

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

   120

   121

        self.Controler = controler

   122

        self.ParentWindow = window

   123

   124

        self.DisableEvents = True

   125

        self.CurrentAction = None

   126

   127

        self.ResetSearchResults()

   128

   129

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

   130

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

   131

   132

        self.SectionsComments = {}

   133

        for section in self.Controler.SECTIONS_NAMES:

   134

            section_comment = " %s section " % (section)

   135

            len_headers = EDGE_COLUMN - len(section_comment)

   136

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

   137

                              section_comment + \

   138

                              self.COMMENT_HEADER * (len_headers - len_headers / 2)

   139

   140

            self.SectionsComments[section] = {

   141

                 "comment": section_comment,

   142

            }

   143

   144

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

   145

            section_infos = self.SectionsComments[section]

   146

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

   147

                section_end = self.SectionsComments[

   148

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

   149

            else:

   150

                section_end = "$"

   151

            section_infos["pattern"] = re.compile(

   152

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

   153

                section_end, re.DOTALL)

   154

   155

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

   156

   157

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

   158

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

   159

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

   160

   161

    def SetCodeLexer(self):

   162

        pass

   163

   164

    def ResetSearchResults(self):

   165

        self.Highlights = []

   166

        self.SearchParams = None

   167

        self.SearchResults = None

   168

        self.CurrentFindHighlight = None

   169

   170

    def OnModification(self, event):

   171

        if not self.DisableEvents:

   172

            mod_type = event.GetModificationType()

   173

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

   174

                if mod_type&wx.stc.STC_MOD_BEFOREINSERT:

   175

                    if self.CurrentAction == None:

   176

                        self.StartBuffering()

   177

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

   178

                        self.Controler.EndBuffering()

   179

                        self.StartBuffering()

   180

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

   181

                    wx.CallAfter(self.RefreshModel)

   182

                elif mod_type&wx.stc.STC_MOD_BEFOREDELETE:

   183

                    if self.CurrentAction == None:

   184

                        self.StartBuffering()

   185

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

   186

                        self.Controler.EndBuffering()

   187

                        self.StartBuffering()

   188

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

   189

                    wx.CallAfter(self.RefreshModel)

   190

        wx.CallAfter(self.RefreshSectionStyling)

   191

        event.Skip()

   192

   193

    def OnDoDrop(self, event):

   194

        try:

   195

            values = eval(event.GetDragText())

   196

        except:

   197

            values = event.GetDragText()

   198

        if isinstance(values, tuple):

   199

            message = None

   200

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

   201

                self.ResetBuffer()

   202

                event.SetDragText(values[0])

   203

                wx.CallAfter(self.RefreshModel)

   204

            else:

   205

                event.SetDragText("")

   206

        else:

   207

            self.ResetBuffer()

   208

            wx.CallAfter(self.RefreshModel)

   209

        event.Skip()

   210

   211

    # Buffer the last model state

   212

    def RefreshBuffer(self):

   213

        self.Controler.BufferCodeFile()

   214

        if self.ParentWindow is not None:

   215

            self.ParentWindow.RefreshTitle()

   216

            self.ParentWindow.RefreshFileMenu()

   217

            self.ParentWindow.RefreshEditMenu()

   218

            self.ParentWindow.RefreshPageTitles()

   219

   220

    def StartBuffering(self):

   221

        self.Controler.StartBuffering()

   222

        if self.ParentWindow is not None:

   223

            self.ParentWindow.RefreshTitle()

   224

            self.ParentWindow.RefreshFileMenu()

   225

            self.ParentWindow.RefreshEditMenu()

   226

            self.ParentWindow.RefreshPageTitles()

   227

   228

    def ResetBuffer(self):

   229

        if self.CurrentAction != None:

   230

            self.Controler.EndBuffering()

   231

            self.CurrentAction = None

   232

   233

    def GetCodeText(self):

   234

        parts = self.Controler.GetTextParts()

   235

        text = ""

   236

        for section in self.Controler.SECTIONS_NAMES:

   237

            section_comments = self.SectionsComments[section]

   238

            text += section_comments["comment"]

   239

            if parts[section] == "":

   240

                text += "\n"

   241

            else:

   242

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

   243

                    text += "\n"

   244

                text += parts[section]

   245

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

   246

                    text += "\n"

   247

        return text

   248

   249

    def RefreshView(self, scroll_to_highlight=False):

   250

        self.ResetBuffer()

   251

        self.DisableEvents = True

   252

        old_cursor_pos = self.GetCurrentPos()

   253

        line = self.GetFirstVisibleLine()

   254

        column = self.GetXOffset()

   255

        old_text = self.GetText()

   256

        new_text = self.GetCodeText()

   257

        if old_text != new_text:

   258

            self.SetText(new_text)

   259

            new_cursor_pos = GetCursorPos(old_text, new_text)

   260

            self.LineScroll(column, line)

   261

            if new_cursor_pos != None:

   262

                self.GotoPos(new_cursor_pos)

   263

            else:

   264

                self.GotoPos(old_cursor_pos)

   265

            self.EmptyUndoBuffer()

   266

        self.DisableEvents = False

   267

   268

        self.RefreshSectionStyling()

   269

   270

        self.ShowHighlights()

   271

   272

    def RefreshSectionStyling(self):

   273

        self.Colourise(0, -1)

   274

   275

        text = self.GetText()

   276

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

   277

            self.SetLineState(line, 0)

   278

   279

        for section in self.Controler.SECTIONS_NAMES:

   280

            section_comments = self.SectionsComments[section]

   281

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

   282

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

   283

            self.StartStyling(start_pos, 0xff)

   284

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   285

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

   286

   287

        self.StartStyling(end_pos, 0x00)

   288

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

   289

   290

    def DoGetBestSize(self):

   291

        return self.ParentWindow.GetPanelBestSize()

   292

   293

    def RefreshModel(self):

   294

        text = self.GetText()

   295

        parts = {}

   296

        for section in self.Controler.SECTIONS_NAMES:

   297

            section_comments = self.SectionsComments[section]

   298

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

   299

            if result is not None:

   300

                parts[section] = result.group(1)

   301

            else:

   302

                parts[section] = ""

   303

        self.Controler.SetTextParts(parts)

   304

        self.ResetSearchResults()

   305

   306

    def OnKeyPressed(self, event):

   307

        if self.CallTipActive():

   308

            self.CallTipCancel()

   309

        key = event.GetKeyCode()

   310

        current_pos = self.GetCurrentPos()

   311

        selected = self.GetSelection()

   312

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

   313

   314

        # Test if caret is before Windows like new line

   315

        text = self.GetText()

   316

        if current_pos < len(text) and ord(text[current_pos]) == 13:

   317

            newline_size = 2

   318

        else:

   319

            newline_size = 1

   320

   321

        # Disable to type any character in section header lines

   322

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

   323

            not text_selected and

   324

            key not in NAVIGATION_KEYS + [

   325

                wx.WXK_RETURN,

   326

                wx.WXK_NUMPAD_ENTER]):

   327

            return

   328

   329

        # Disable to delete line between code and header lines

   330

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

   331

              (key == wx.WXK_BACK and

   332

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

   333

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

   334

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

   335

            return

   336

   337

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

   338

            pos = self.GetCurrentPos()

   339

   340

            # Tips

   341

            if event.ShiftDown():

   342

                pass

   343

            # Code completion

   344

            else:

   345

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

   346

   347

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

   348

                                            for var in self.Controler.GetVariables()]

   349

                keywords.sort()

   350

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

   351

        else:

   352

            event.Skip()

   353

   354

    def OnKillFocus(self, event):

   355

        self.AutoCompCancel()

   356

        event.Skip()

   357

   358

    def OnUpdateUI(self, event):

   359

        # check for matching braces

   360

        braceAtCaret = -1

   361

        braceOpposite = -1

   362

        charBefore = None

   363

        caretPos = self.GetCurrentPos()

   364

   365

        if caretPos > 0:

   366

            charBefore = self.GetCharAt(caretPos - 1)

   367

            styleBefore = self.GetStyleAt(caretPos - 1)

   368

   369

        # check before

   370

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

   371

            braceAtCaret = caretPos - 1

   372

   373

        # check after

   374

        if braceAtCaret < 0:

   375

            charAfter = self.GetCharAt(caretPos)

   376

            styleAfter = self.GetStyleAt(caretPos)

   377

   378

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

   379

                braceAtCaret = caretPos

   380

   381

        if braceAtCaret >= 0:

   382

            braceOpposite = self.BraceMatch(braceAtCaret)

   383

   384

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

   385

            self.BraceBadLight(braceAtCaret)

   386

        else:

   387

            self.BraceHighlight(braceAtCaret, braceOpposite)

   388

   389

        selected_text = self.GetSelectedText()

   390

        if selected_text:

   391

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   392

   393

    def OnMarginClick(self, event):

   394

        # fold and unfold as needed

   395

        if evt.GetMargin() == 2:

   396

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

   397

                self.FoldAll()

   398

            else:

   399

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

   400

   401

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

   402

                    if evt.GetShift():

   403

                        self.SetFoldExpanded(lineClicked, True)

   404

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

   405

                    elif evt.GetControl():

   406

                        if self.GetFoldExpanded(lineClicked):

   407

                            self.SetFoldExpanded(lineClicked, False)

   408

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

   409

                        else:

   410

                            self.SetFoldExpanded(lineClicked, True)

   411

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

   412

                    else:

   413

                        self.ToggleFold(lineClicked)

   414

        event.Skip()

   415

   416

    def FoldAll(self):

   417

        lineCount = self.GetLineCount()

   418

        expanding = True

   419

   420

        # find out if we are folding or unfolding

   421

        for lineNum in range(lineCount):

   422

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

   423

                expanding = not self.GetFoldExpanded(lineNum)

   424

                break

   425

   426

        lineNum = 0

   427

   428

        while lineNum < lineCount:

   429

            level = self.GetFoldLevel(lineNum)

   430

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   431

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

   432

   433

                if expanding:

   434

                    self.SetFoldExpanded(lineNum, True)

   435

                    lineNum = self.Expand(lineNum, True)

   436

                    lineNum = lineNum - 1

   437

                else:

   438

                    lastChild = self.GetLastChild(lineNum, -1)

   439

                    self.SetFoldExpanded(lineNum, False)

   440

   441

                    if lastChild > lineNum:

   442

                        self.HideLines(lineNum+1, lastChild)

   443

   444

            lineNum = lineNum + 1

   445

   446

   447

   448

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

   449

        lastChild = self.GetLastChild(line, level)

   450

        line = line + 1

   451

   452

        while line <= lastChild:

   453

            if force:

   454

                if visLevels > 0:

   455

                    self.ShowLines(line, line)

   456

                else:

   457

                    self.HideLines(line, line)

   458

            else:

   459

                if doExpand:

   460

                    self.ShowLines(line, line)

   461

   462

            if level == -1:

   463

                level = self.GetFoldLevel(line)

   464

   465

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   466

                if force:

   467

                    if visLevels > 1:

   468

                        self.SetFoldExpanded(line, True)

   469

                    else:

   470

                        self.SetFoldExpanded(line, False)

   471

   472

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

   473

   474

                else:

   475

                    if doExpand and self.GetFoldExpanded(line):

   476

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

   477

                    else:

   478

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

   479

            else:

   480

                line = line + 1

   481

   482

        return line

   483

   484

    def Cut(self):

   485

        self.ResetBuffer()

   486

        self.DisableEvents = True

   487

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   488

        self.DisableEvents = False

   489

        self.RefreshModel()

   490

        self.RefreshBuffer()

   491

   492

    def Copy(self):

   493

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   494

        self.ParentWindow.RefreshEditMenu()

   495

   496

    def Paste(self):

   497

        self.ResetBuffer()

   498

        self.DisableEvents = True

   499

        self.CmdKeyExecute(wx.stc.STC_CMD_PASTE)