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

from __future__ import absolute_import

    27

from __future__ import division

    28

import re

    29

from builtins import str as text

    30

    31

import wx

    32

import wx.grid

    33

import wx.stc as stc

    34

import wx.lib.buttons

    35

from six.moves import xrange

    36

    37

    38

from plcopen.plcopen import TestTextElement

    39

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    40

from controls import CustomGrid, CustomTable

    41

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

    42

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    43

from util.BitmapLibrary import GetBitmap

    44

from util.TranslationCatalogs import NoTranslate

    45

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    46

    47

    48

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    49

 STC_CODE_SECTION] = range(15, 18)

    50

    51

HIGHLIGHT_TYPES = {

    52

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    53

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    54

}

    55

    56

EDGE_COLUMN = 80

    57

    58

    59

def GetSectionsText(controler, sections_headers):

    60

    parts = controler.GetTextParts()

    61

    text = ""

    62

    for section in controler.SECTIONS_NAMES:

    63

        text += sections_headers(section)

    64

        if parts[section] == "":

    65

            text += "\n"

    66

        else:

    67

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

    68

                text += "\n"

    69

            text += parts[section]

    70

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

    71

                text += "\n"

    72

    return text

    73

    74

    75

class CodeEditor(CustomStyledTextCtrl):

    76

    77

    KEYWORDS = []

    78

    COMMENT_HEADER = ""

    79

    80

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

    81

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

    82

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

    83

    84

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    85

        self.SetMarginWidth(1, 25)

    86

    87

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

    88

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

    89

        self.SetMargins(0, 0)

    90

    91

        self.SetViewWhiteSpace(False)

    92

    93

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    94

        self.SetEdgeColumn(EDGE_COLUMN)

    95

    96

        # Setup a margin to hold fold markers

    97

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    98

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    99

        self.SetMarginSensitive(2, True)

   100

        self.SetMarginWidth(2, 12)

   101

   102

        # Like a flattened tree control using square headers

   103

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

   104

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

   105

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

   106

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

   107

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

   108

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

   109

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

   110

   111

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

   112

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

   113

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

   114

   115

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

   116

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

   117

        # Scintilla sample property files.

   118

   119

        # Global default styles for all languages

   120

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

   121

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

   122

   123

        # Global default styles for all languages

   124

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

   125

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

   126

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

   127

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

   128

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

   129

   130

        # Highlighting styles

   131

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

   132

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

   133

   134

        # Section style

   135

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

   136

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   137

   138

        # Indentation size

   139

        self.SetTabWidth(4)

   140

        self.SetUseTabs(0)

   141

   142

        self.SetCodeLexer()

   143

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

   144

   145

        self.Controler = controler

   146

        self.ParentWindow = window

   147

   148

        self.DisableEvents = True

   149

        self.CurrentAction = None

   150

   151

        self.ResetSearchResults()

   152

   153

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

   154

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

   155

   156

        self.SectionsComments = {}

   157

        for section in self.Controler.SECTIONS_NAMES:

   158

            section_comment = " %s section " % (section)

   159

            len_headers = EDGE_COLUMN - len(section_comment)

   160

            section_comment = \

   161

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

   162

                section_comment + \

   163

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

   164

   165

            self.SectionsComments[section] = {

   166

                "comment": section_comment,

   167

            }

   168

   169

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

   170

            section_infos = self.SectionsComments[section]

   171

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

   172

                section_end = self.SectionsComments[

   173

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

   174

            else:

   175

                section_end = "$"

   176

            section_infos["pattern"] = re.compile(

   177

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

   178

                section_end, re.DOTALL)

   179

   180

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

   181

   182

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

   183

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

   184

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

   185

   186

    def SetCodeLexer(self):

   187

        pass

   188

   189

    def ResetSearchResults(self):

   190

        self.Highlights = []

   191

        self.SearchParams = None

   192

        self.SearchResults = None

   193

        self.CurrentFindHighlight = None

   194

   195

    def OnModification(self, event):

   196

        if not self.DisableEvents:

   197

            mod_type = event.GetModificationType()

   198

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

   199

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   200

                    if self.CurrentAction is None:

   201

                        self.StartBuffering()

   202

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

   203

                        self.Controler.EndBuffering()

   204

                        self.StartBuffering()

   205

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

   206

                    wx.CallAfter(self.RefreshModel)

   207

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   208

                    if self.CurrentAction is None:

   209

                        self.StartBuffering()

   210

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

   211

                        self.Controler.EndBuffering()

   212

                        self.StartBuffering()

   213

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

   214

                    wx.CallAfter(self.RefreshModel)

   215

        wx.CallAfter(self.RefreshSectionStyling)

   216

        event.Skip()

   217

   218

    def OnDoDrop(self, event):

   219

        try:

   220

            values = eval(event.GetDragText())

   221

        except Exception:

   222

            values = event.GetDragText()

   223

        if isinstance(values, tuple):

   224

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

   225

                self.ResetBuffer()

   226

                event.SetDragText(values[0])

   227

                wx.CallAfter(self.RefreshModel)

   228

            else:

   229

                event.SetDragText("")

   230

        else:

   231

            self.ResetBuffer()

   232

            wx.CallAfter(self.RefreshModel)

   233

        event.Skip()

   234

   235

    # Buffer the last model state

   236

    def RefreshBuffer(self):

   237

        self.Controler.BufferCodeFile()

   238

        if self.ParentWindow is not None:

   239

            self.ParentWindow.RefreshTitle()

   240

            self.ParentWindow.RefreshFileMenu()

   241

            self.ParentWindow.RefreshEditMenu()

   242

            self.ParentWindow.RefreshPageTitles()

   243

   244

    def StartBuffering(self):

   245

        self.Controler.StartBuffering()

   246

        if self.ParentWindow is not None:

   247

            self.ParentWindow.RefreshTitle()

   248

            self.ParentWindow.RefreshFileMenu()

   249

            self.ParentWindow.RefreshEditMenu()

   250

            self.ParentWindow.RefreshPageTitles()

   251

   252

    def ResetBuffer(self):

   253

        if self.CurrentAction is not None:

   254

            self.Controler.EndBuffering()

   255

            self.CurrentAction = None

   256

   257

    def GetCodeText(self):

   258

        return GetSectionsText(

   259

            self.Controler,

   260

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

   261

   262

    def RefreshView(self, scroll_to_highlight=False):

   263

        self.ResetBuffer()

   264

        self.DisableEvents = True

   265

        old_cursor_pos = self.GetCurrentPos()

   266

        line = self.GetFirstVisibleLine()

   267

        column = self.GetXOffset()

   268

        old_text = self.GetText()

   269

        new_text = self.GetCodeText()

   270

        if old_text != new_text:

   271

            self.SetText(new_text)

   272

            new_cursor_pos = GetCursorPos(old_text, new_text)

   273

            self.LineScroll(column, line)

   274

            if new_cursor_pos is not None:

   275

                self.GotoPos(new_cursor_pos)

   276

            else:

   277

                self.GotoPos(old_cursor_pos)

   278

            self.EmptyUndoBuffer()

   279

        self.DisableEvents = False

   280

   281

        self.RefreshSectionStyling()

   282

   283

        self.ShowHighlights()

   284

   285

    def RefreshSectionStyling(self):

   286

        self.Colourise(0, -1)

   287

   288

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

   289

            self.SetLineState(line, 0)

   290

   291

        doc_end_pos = self.GetLength()

   292

        for section in self.Controler.SECTIONS_NAMES:

   293

            section_comments = self.SectionsComments[section]

   294

            start_pos = self.FindText(0, doc_end_pos, section_comments["comment"])

   295

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

   296

            self.StartStyling(start_pos, 0xff)

   297

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   298

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

   299

   300

        self.StartStyling(end_pos, 0x00)

   301

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

   302

   303

    def DoGetBestSize(self):

   304

        return self.ParentWindow.GetPanelBestSize()

   305

   306

    def RefreshModel(self):

   307

        text = self.GetText()

   308

        parts = {}

   309

        for section in self.Controler.SECTIONS_NAMES:

   310

            section_comments = self.SectionsComments[section]

   311

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

   312

            if result is not None:

   313

                parts[section] = result.group(1)

   314

            else:

   315

                parts[section] = ""

   316

        self.Controler.SetTextParts(parts)

   317

        self.ResetSearchResults()

   318

   319

    def OnKeyPressed(self, event):

   320

        if self.CallTipActive():

   321

            self.CallTipCancel()

   322

        key = event.GetKeyCode()

   323

        current_pos = self.GetCurrentPos()

   324

        selected = self.GetSelection()

   325

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

   326

   327

        # Test if caret is before Windows like new line

   328

        text = self.GetText()

   329

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

   330

            newline_size = 2

   331

        else:

   332

            newline_size = 1

   333

   334

        # Disable to type any character in section header lines

   335

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

   336

           not text_selected and \

   337

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

   338

            return

   339

   340

        # Disable to delete line between code and header lines

   341

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

   342

              (key == wx.WXK_BACK and

   343

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

   344

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

   345

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

   346

            return

   347

   348

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

   349

            # Tips

   350

            if event.ShiftDown():

   351

                pass

   352

            # Code completion

   353

            else:

   354

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

   355

   356

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

   357

                                            for var in self.Controler.GetVariables()]

   358

                keywords.sort()

   359

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

   360

        else:

   361

            event.Skip()

   362

   363

    def OnKillFocus(self, event):

   364

        self.AutoCompCancel()

   365

        event.Skip()

   366

   367

    def OnUpdateUI(self, event):

   368

        # check for matching braces

   369

        braceAtCaret = -1

   370

        braceOpposite = -1

   371

        charBefore = None

   372

        caretPos = self.GetCurrentPos()

   373

   374

        if caretPos > 0:

   375

            charBefore = self.GetCharAt(caretPos - 1)

   376

            styleBefore = self.GetStyleAt(caretPos - 1)

   377

   378

        # check before

   379

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

   380

            braceAtCaret = caretPos - 1

   381

   382

        # check after

   383

        if braceAtCaret < 0:

   384

            charAfter = self.GetCharAt(caretPos)

   385

            styleAfter = self.GetStyleAt(caretPos)

   386

   387

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

   388

                braceAtCaret = caretPos

   389

   390

        if braceAtCaret >= 0:

   391

            braceOpposite = self.BraceMatch(braceAtCaret)

   392

   393

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

   394

            self.BraceBadLight(braceAtCaret)

   395

        else:

   396

            self.BraceHighlight(braceAtCaret, braceOpposite)

   397

   398

        selected_text = self.GetSelectedText()

   399

        if selected_text:

   400

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   401

   402

    def OnMarginClick(self, event):

   403

        # fold and unfold as needed

   404

        if event.GetMargin() == 2:

   405

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

   406

                self.FoldAll()

   407

            else:

   408

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

   409

   410

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

   411

                    if event.GetShift():

   412

                        self.SetFoldExpanded(lineClicked, True)

   413

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

   414

                    elif event.GetControl():

   415

                        if self.GetFoldExpanded(lineClicked):

   416

                            self.SetFoldExpanded(lineClicked, False)

   417

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

   418

                        else:

   419

                            self.SetFoldExpanded(lineClicked, True)

   420

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

   421

                    else:

   422

                        self.ToggleFold(lineClicked)

   423

        event.Skip()

   424

   425

    def FoldAll(self):

   426

        lineCount = self.GetLineCount()

   427

        expanding = True

   428

   429

        # find out if we are folding or unfolding

   430

        for lineNum in range(lineCount):

   431

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

   432

                expanding = not self.GetFoldExpanded(lineNum)

   433

                break

   434

   435

        lineNum = 0

   436

   437

        while lineNum < lineCount:

   438

            level = self.GetFoldLevel(lineNum)

   439

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   440

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

   441

   442

                if expanding:

   443

                    self.SetFoldExpanded(lineNum, True)

   444

                    lineNum = self.Expand(lineNum, True)

   445

                    lineNum = lineNum - 1

   446

                else:

   447

                    lastChild = self.GetLastChild(lineNum, -1)

   448

                    self.SetFoldExpanded(lineNum, False)

   449

   450

                    if lastChild > lineNum:

   451

                        self.HideLines(lineNum+1, lastChild)

   452

   453

            lineNum = lineNum + 1

   454

   455

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

   456

        lastChild = self.GetLastChild(line, level)

   457

        line = line + 1

   458

   459

        while line <= lastChild:

   460

            if force:

   461

                if visLevels > 0:

   462

                    self.ShowLines(line, line)

   463

                else:

   464

                    self.HideLines(line, line)

   465

            else:

   466

                if doExpand:

   467

                    self.ShowLines(line, line)

   468

   469

            if level == -1:

   470

                level = self.GetFoldLevel(line)

   471

   472

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   473

                if force:

   474

                    if visLevels > 1:

   475

                        self.SetFoldExpanded(line, True)

   476

                    else:

   477

                        self.SetFoldExpanded(line, False)

   478

   479

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

   480

   481

                else:

   482

                    if doExpand and self.GetFoldExpanded(line):

   483

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

   484

                    else:

   485

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

   486

            else:

   487

                line = line + 1

   488

   489

        return line

   490

   491

    def Cut(self):

   492

        self.ResetBuffer()

   493

        self.DisableEvents = True

   494

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   495

        self.DisableEvents = False

   496

        self.RefreshModel()