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

    26

import re

    27

    28

import wx

    29

import wx.grid

    30

import wx.stc as stc

    31

import wx.lib.buttons

    32

    33

    34

from plcopen.plcopen import TestTextElement

    35

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    36

from controls import CustomGrid, CustomTable

    37

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

    38

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    39

from util.BitmapLibrary import GetBitmap

    40

from util.TranslationCatalogs import NoTranslate

    41

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    42

    43

    44

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    45

 STC_CODE_SECTION] = list(range(15, 18))

    46

    47

HIGHLIGHT_TYPES = {

    48

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    49

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    50

}

    51

    52

EDGE_COLUMN = 80

    53

    54

    55

def GetSectionsText(controler, sections_headers):

    56

    parts = controler.GetTextParts()

    57

    text = ""

    58

    for section in controler.SECTIONS_NAMES:

    59

        text += sections_headers(section)

    60

        if parts[section] == "":

    61

            text += "\n"

    62

        else:

    63

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

    64

                text += "\n"

    65

            text += parts[section]

    66

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

    67

                text += "\n"

    68

    return text

    69

    70

    71

class CodeEditor(CustomStyledTextCtrl):

    72

    73

    KEYWORDS = []

    74

    COMMENT_HEADER = ""

    75

    76

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

    77

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

    78

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

    79

    80

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    81

        self.SetMarginWidth(1, 25)

    82

    83

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

    84

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

    85

        self.SetMargins(0, 0)

    86

    87

        self.SetViewWhiteSpace(False)

    88

    89

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    90

        self.SetEdgeColumn(EDGE_COLUMN)

    91

    92

        # Setup a margin to hold fold markers

    93

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    94

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    95

        self.SetMarginSensitive(2, True)

    96

        self.SetMarginWidth(2, 12)

    97

    98

        # Like a flattened tree control using square headers

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

   107

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

   108

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

   109

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

   110

   111

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

   112

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

   113

        # Scintilla sample property files.

   114

   115

        # Global default styles for all languages

   116

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

   117

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

   118

   119

        # Global default styles for all languages

   120

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

   121

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

   122

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

   123

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

   124

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

   125

   126

        # Highlighting styles

   127

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

   128

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

   129

   130

        # Section style

   131

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

   132

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   133

   134

        # Indentation size

   135

        self.SetTabWidth(4)

   136

        self.SetUseTabs(0)

   137

   138

        self.SetCodeLexer()

   139

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

   140

   141

        self.Controler = controler

   142

        self.ParentWindow = window

   143

   144

        self.DisableEvents = True

   145

        self.CurrentAction = None

   146

   147

        self.ResetSearchResults()

   148

   149

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

   150

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

   151

   152

        self.SectionsComments = {}

   153

        for section in self.Controler.SECTIONS_NAMES:

   154

            section_comment = " %s section " % (section)

   155

            len_headers = EDGE_COLUMN - len(section_comment)

   156

            section_comment = \

   157

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

   158

                section_comment + \

   159

                self.COMMENT_HEADER * (len_headers - len_headers // 2)

   160

   161

            self.SectionsComments[section] = {

   162

                "comment": section_comment,

   163

            }

   164

   165

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

   166

            section_infos = self.SectionsComments[section]

   167

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

   168

                section_end = self.SectionsComments[

   169

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

   170

            else:

   171

                section_end = "$"

   172

            section_infos["pattern"] = re.compile(

   173

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

   174

                section_end, re.DOTALL)

   175

   176

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

   177

   178

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

   179

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

   180

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

   181

   182

    def SetCodeLexer(self):

   183

        pass

   184

   185

    def ResetSearchResults(self):

   186

        self.Highlights = []

   187

        self.SearchParams = None

   188

        self.SearchResults = None

   189

        self.CurrentFindHighlight = None

   190

   191

    def OnModification(self, event):

   192

        if not self.DisableEvents:

   193

            mod_type = event.GetModificationType()

   194

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

   195

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   196

                    if self.CurrentAction is None:

   197

                        self.StartBuffering()

   198

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

   199

                        self.Controler.EndBuffering()

   200

                        self.StartBuffering()

   201

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

   202

                    wx.CallAfter(self.RefreshModel)

   203

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   204

                    if self.CurrentAction is None:

   205

                        self.StartBuffering()

   206

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

   207

                        self.Controler.EndBuffering()

   208

                        self.StartBuffering()

   209

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

   210

                    wx.CallAfter(self.RefreshModel)

   211

        wx.CallAfter(self.RefreshSectionStyling)

   212

        event.Skip()

   213

   214

    def OnDoDrop(self, event):

   215

        try:

   216

            values = eval(event.GetDragText())

   217

        except Exception:

   218

            values = event.GetDragText()

   219

        if isinstance(values, tuple):

   220

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

   221

                self.ResetBuffer()

   222

                event.SetDragText(values[0])

   223

                wx.CallAfter(self.RefreshModel)

   224

            else:

   225

                event.SetDragText("")

   226

        else:

   227

            self.ResetBuffer()

   228

            wx.CallAfter(self.RefreshModel)

   229

        event.Skip()

   230

   231

    # Buffer the last model state

   232

    def RefreshBuffer(self):

   233

        self.Controler.BufferCodeFile()

   234

        if self.ParentWindow is not None:

   235

            self.ParentWindow.RefreshTitle()

   236

            self.ParentWindow.RefreshFileMenu()

   237

            self.ParentWindow.RefreshEditMenu()

   238

            self.ParentWindow.RefreshPageTitles()

   239

   240

    def StartBuffering(self):

   241

        self.Controler.StartBuffering()

   242

        if self.ParentWindow is not None:

   243

            self.ParentWindow.RefreshTitle()

   244

            self.ParentWindow.RefreshFileMenu()

   245

            self.ParentWindow.RefreshEditMenu()

   246

            self.ParentWindow.RefreshPageTitles()

   247

   248

    def ResetBuffer(self):

   249

        if self.CurrentAction is not None:

   250

            self.Controler.EndBuffering()

   251

            self.CurrentAction = None

   252

   253

    def GetCodeText(self):

   254

        return GetSectionsText(

   255

            self.Controler,

   256

            lambda section: self.SectionsComments[section]["comment"])

   257

   258

    def RefreshView(self, scroll_to_highlight=False):

   259

        self.ResetBuffer()

   260

        self.DisableEvents = True

   261

        old_cursor_pos = self.GetCurrentPos()

   262

        line = self.GetFirstVisibleLine()

   263

        column = self.GetXOffset()

   264

        old_text = self.GetText()

   265

        new_text = self.GetCodeText()

   266

        if old_text != new_text:

   267

            self.SetText(new_text)

   268

            new_cursor_pos = GetCursorPos(old_text, new_text)

   269

            self.LineScroll(column, line)

   270

            if new_cursor_pos is not None:

   271

                self.GotoPos(new_cursor_pos)

   272

            else:

   273

                self.GotoPos(old_cursor_pos)

   274

            self.EmptyUndoBuffer()

   275

        self.DisableEvents = False

   276

   277

        self.RefreshSectionStyling()

   278

   279

        self.ShowHighlights()

   280

   281

    def RefreshSectionStyling(self):

   282

        self.Colourise(0, -1)

   283

   284

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

   285

            self.SetLineState(line, 0)

   286

   287

        doc_end_pos = self.GetLength()

   288

        for section in self.Controler.SECTIONS_NAMES:

   289

            section_comments = self.SectionsComments[section]

   290

            txttofind = section_comments["comment"]

   291

            results = self.FindText(0, doc_end_pos, txttofind)

   292

            if wx.VERSION < (4, 1, 0):

   293

                start_pos = results

   294

                end_pos = start_pos+len(txttofind)

   295

            else:

   296

                start_pos, end_pos = results

   297

            self.StartStyling(start_pos)

   298

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   299

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

   300

   301

        self.StartStyling(end_pos)

   302

        self.SetStyling(doc_end_pos - end_pos, stc.STC_STYLE_DEFAULT)

   303

   304

    def DoGetBestSize(self):

   305

        return self.ParentWindow.GetBestSize()

   306

   307

    def RefreshModel(self):

   308

        text = self.GetText()

   309

        parts = {}

   310

        for section in self.Controler.SECTIONS_NAMES:

   311

            section_comments = self.SectionsComments[section]

   312

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

   313

            if result is not None:

   314

                parts[section] = result.group(1)

   315

            else:

   316

                parts[section] = ""

   317

        self.Controler.SetTextParts(parts)

   318

        self.ResetSearchResults()

   319

   320

    def OnKeyPressed(self, event):

   321

        if self.CallTipActive():

   322

            self.CallTipCancel()

   323

        key = event.GetKeyCode()

   324

        current_pos = self.GetCurrentPos()

   325

        selected = self.GetSelection()

   326

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

   327

   328

        # Test if caret is before Windows like new line

   329

        text = self.GetText()

   330

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

   331

            newline_size = 2

   332

        else:

   333

            newline_size = 1

   334

   335

        # Disable to type any character in section header lines

   336

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

   337

           not text_selected and \

   338

           key not in NAVIGATION_KEYS + [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:

   339

            return

   340

   341

        # Disable to delete line between code and header lines

   342

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

   343

              (key == wx.WXK_BACK and

   344

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

   345

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

   346

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

   347

            return

   348

   349

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

   350

            # Tips

   351

            if event.ShiftDown():

   352

                pass

   353

            # Code completion

   354

            else:

   355

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

   356

   357

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

   358

                                            for var in self.Controler.GetVariables()]

   359

                keywords.sort()

   360

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

   361

        else:

   362

            event.Skip()

   363

   364

    def OnKillFocus(self, event):

   365

        self.AutoCompCancel()

   366

        event.Skip()

   367

   368

    def OnUpdateUI(self, event):

   369

        # check for matching braces

   370

        braceAtCaret = -1

   371

        braceOpposite = -1

   372

        charBefore = None

   373

        caretPos = self.GetCurrentPos()

   374

   375

        if caretPos > 0:

   376

            charBefore = self.GetCharAt(caretPos - 1)

   377

            styleBefore = self.GetStyleAt(caretPos - 1)

   378

   379

        # check before

   380

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

   381

            braceAtCaret = caretPos - 1

   382

   383

        # check after

   384

        if braceAtCaret < 0:

   385

            charAfter = self.GetCharAt(caretPos)

   386

            styleAfter = self.GetStyleAt(caretPos)

   387

   388

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

   389

                braceAtCaret = caretPos

   390

   391

        if braceAtCaret >= 0:

   392

            braceOpposite = self.BraceMatch(braceAtCaret)

   393

   394

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

   395

            self.BraceBadLight(braceAtCaret)

   396

        else:

   397

            self.BraceHighlight(braceAtCaret, braceOpposite)

   398

   399

        selected_text = self.GetSelectedText()

   400

        if selected_text:

   401

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   402

   403

    def OnMarginClick(self, event):

   404

        # fold and unfold as needed

   405

        if event.GetMargin() == 2:

   406

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

   407

                self.FoldAll()

   408

            else:

   409

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

   410

   411

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

   412

                    if event.GetShift():

   413

                        self.SetFoldExpanded(lineClicked, True)

   414

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

   415

                    elif event.GetControl():

   416

                        if self.GetFoldExpanded(lineClicked):

   417

                            self.SetFoldExpanded(lineClicked, False)

   418

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

   419

                        else:

   420

                            self.SetFoldExpanded(lineClicked, True)

   421

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

   422

                    else:

   423

                        self.ToggleFold(lineClicked)

   424

        event.Skip()

   425

   426

    def FoldAll(self):

   427

        lineCount = self.GetLineCount()

   428

        expanding = True

   429

   430

        # find out if we are folding or unfolding

   431

        for lineNum in range(lineCount):

   432

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

   433

                expanding = not self.GetFoldExpanded(lineNum)

   434

                break

   435

   436

        lineNum = 0

   437

   438

        while lineNum < lineCount:

   439

            level = self.GetFoldLevel(lineNum)

   440

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   441

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

   442

   443

                if expanding:

   444

                    self.SetFoldExpanded(lineNum, True)

   445

                    lineNum = self.Expand(lineNum, True)

   446

                    lineNum = lineNum - 1

   447

                else:

   448

                    lastChild = self.GetLastChild(lineNum, -1)

   449

                    self.SetFoldExpanded(lineNum, False)

   450

   451

                    if lastChild > lineNum:

   452

                        self.HideLines(lineNum+1, lastChild)

   453

   454

            lineNum = lineNum + 1

   455

   456

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

   457

        lastChild = self.GetLastChild(line, level)

   458

        line = line + 1

   459

   460

        while line <= lastChild:

   461

            if force:

   462

                if visLevels > 0:

   463

                    self.ShowLines(line, line)

   464

                else:

   465

                    self.HideLines(line, line)

   466

            else:

   467

                if doExpand:

   468

                    self.ShowLines(line, line)

   469

   470

            if level == -1:

   471

                level = self.GetFoldLevel(line)

   472

   473

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   474

                if force:

   475

                    if visLevels > 1:

   476

                        self.SetFoldExpanded(line, True)

   477

                    else:

   478

                        self.SetFoldExpanded(line, False)

   479

   480

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

   481

   482

                else:

   483

                    if doExpand and self.GetFoldExpanded(line):

   484

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

   485

                    else:

   486

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

   487

            else:

   488

                line = line + 1

   489

   490

        return line

   491

   492

    def Cut(self):

   493

        self.ResetBuffer()

   494

        self.DisableEvents = True

   495

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   496

        self.DisableEvents = False