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

class CodeEditor(CustomStyledTextCtrl):

    60

    61

    KEYWORDS = []

    62

    COMMENT_HEADER = ""

    63

    64

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

    65

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

    66

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

    67

    68

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    69

        self.SetMarginWidth(1, 25)

    70

    71

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

    72

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

    73

        self.SetMargins(0, 0)

    74

    75

        self.SetViewWhiteSpace(False)

    76

    77

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    78

        self.SetEdgeColumn(EDGE_COLUMN)

    79

    80

        # Setup a margin to hold fold markers

    81

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    82

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    83

        self.SetMarginSensitive(2, True)

    84

        self.SetMarginWidth(2, 12)

    85

    86

        # Like a flattened tree control using square headers

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

    95

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

    96

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

    97

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

    98

    99

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

   100

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

   101

        # Scintilla sample property files.

   102

   103

        # Global default styles for all languages

   104

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

   105

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

   106

   107

        # Global default styles for all languages

   108

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

   109

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

   110

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

   111

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

   112

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

   113

   114

        # Highlighting styles

   115

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

   116

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

   117

   118

        # Section style

   119

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

   120

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   121

   122

        # Indentation size

   123

        self.SetTabWidth(4)

   124

        self.SetUseTabs(0)

   125

   126

        self.SetCodeLexer()

   127

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

   128

   129

        self.Controler = controler

   130

        self.ParentWindow = window

   131

   132

        self.DisableEvents = True

   133

        self.CurrentAction = None

   134

   135

        self.ResetSearchResults()

   136

   137

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

   138

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

   139

   140

        self.SectionsComments = {}

   141

        for section in self.Controler.SECTIONS_NAMES:

   142

            section_comment = " %s section " % (section)

   143

            len_headers = EDGE_COLUMN - len(section_comment)

   144

            section_comment = \

   145

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

   146

                section_comment + \

   147

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

   148

   149

            self.SectionsComments[section] = {

   150

                "comment": section_comment,

   151

            }

   152

   153

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

   154

            section_infos = self.SectionsComments[section]

   155

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

   156

                section_end = self.SectionsComments[

   157

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

   158

            else:

   159

                section_end = "$"

   160

            section_infos["pattern"] = re.compile(

   161

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

   162

                section_end, re.DOTALL)

   163

   164

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

   165

   166

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

   167

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

   168

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

   169

   170

    def SetCodeLexer(self):

   171

        pass

   172

   173

    def ResetSearchResults(self):

   174

        self.Highlights = []

   175

        self.SearchParams = None

   176

        self.SearchResults = None

   177

        self.CurrentFindHighlight = None

   178

   179

    def OnModification(self, event):

   180

        if not self.DisableEvents:

   181

            mod_type = event.GetModificationType()

   182

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

   183

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   184

                    if self.CurrentAction is None:

   185

                        self.StartBuffering()

   186

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

   187

                        self.Controler.EndBuffering()

   188

                        self.StartBuffering()

   189

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

   190

                    wx.CallAfter(self.RefreshModel)

   191

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   192

                    if self.CurrentAction is None:

   193

                        self.StartBuffering()

   194

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

   195

                        self.Controler.EndBuffering()

   196

                        self.StartBuffering()

   197

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

   198

                    wx.CallAfter(self.RefreshModel)

   199

        wx.CallAfter(self.RefreshSectionStyling)

   200

        event.Skip()

   201

   202

    def OnDoDrop(self, event):

   203

        try:

   204

            values = eval(event.GetDragText())

   205

        except Exception:

   206

            values = event.GetDragText()

   207

        if isinstance(values, tuple):

   208

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

   209

                self.ResetBuffer()

   210

                event.SetDragText(values[0])

   211

                wx.CallAfter(self.RefreshModel)

   212

            else:

   213

                event.SetDragText("")

   214

        else:

   215

            self.ResetBuffer()

   216

            wx.CallAfter(self.RefreshModel)

   217

        event.Skip()

   218

   219

    # Buffer the last model state

   220

    def RefreshBuffer(self):

   221

        self.Controler.BufferCodeFile()

   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 StartBuffering(self):

   229

        self.Controler.StartBuffering()

   230

        if self.ParentWindow is not None:

   231

            self.ParentWindow.RefreshTitle()

   232

            self.ParentWindow.RefreshFileMenu()

   233

            self.ParentWindow.RefreshEditMenu()

   234

            self.ParentWindow.RefreshPageTitles()

   235

   236

    def ResetBuffer(self):

   237

        if self.CurrentAction is not None:

   238

            self.Controler.EndBuffering()

   239

            self.CurrentAction = None

   240

   241

    def GetCodeText(self):

   242

        parts = self.Controler.GetTextParts()

   243

        text = ""

   244

        for section in self.Controler.SECTIONS_NAMES:

   245

            section_comments = self.SectionsComments[section]

   246

            text += section_comments["comment"]

   247

            if parts[section] == "":

   248

                text += "\n"

   249

            else:

   250

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

   251

                    text += "\n"

   252

                text += parts[section]

   253

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

   254

                    text += "\n"

   255

        return text

   256

   257

    def RefreshView(self, scroll_to_highlight=False):

   258

        self.ResetBuffer()

   259

        self.DisableEvents = True

   260

        old_cursor_pos = self.GetCurrentPos()

   261

        line = self.GetFirstVisibleLine()

   262

        column = self.GetXOffset()

   263

        old_text = self.GetText()

   264

        new_text = self.GetCodeText()

   265

        if old_text != new_text:

   266

            self.SetText(new_text)

   267

            new_cursor_pos = GetCursorPos(old_text, new_text)

   268

            self.LineScroll(column, line)

   269

            if new_cursor_pos is not None:

   270

                self.GotoPos(new_cursor_pos)

   271

            else:

   272

                self.GotoPos(old_cursor_pos)

   273

            self.EmptyUndoBuffer()

   274

        self.DisableEvents = False

   275

   276

        self.RefreshSectionStyling()

   277

   278

        self.ShowHighlights()

   279

   280

    def RefreshSectionStyling(self):

   281

        self.Colourise(0, -1)

   282

   283

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

   284

            self.SetLineState(line, 0)

   285

   286

        doc_end_pos = self.GetLength()

   287

        for section in self.Controler.SECTIONS_NAMES:

   288

            section_comments = self.SectionsComments[section]

   289

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

   290

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

   291

            self.StartStyling(start_pos, 0xff)

   292

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   293

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

   294

   295

        self.StartStyling(end_pos, 0x00)

   296

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

   297

   298

    def DoGetBestSize(self):

   299

        return self.ParentWindow.GetPanelBestSize()

   300

   301

    def RefreshModel(self):

   302

        text = self.GetText()

   303

        parts = {}

   304

        for section in self.Controler.SECTIONS_NAMES:

   305

            section_comments = self.SectionsComments[section]

   306

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

   307

            if result is not None:

   308

                parts[section] = result.group(1)

   309

            else:

   310

                parts[section] = ""

   311

        self.Controler.SetTextParts(parts)

   312

        self.ResetSearchResults()

   313

   314

    def OnKeyPressed(self, event):

   315

        if self.CallTipActive():

   316

            self.CallTipCancel()

   317

        key = event.GetKeyCode()

   318

        current_pos = self.GetCurrentPos()

   319

        selected = self.GetSelection()

   320

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

   321

   322

        # Test if caret is before Windows like new line

   323

        text = self.GetText()

   324

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

   325

            newline_size = 2

   326

        else:

   327

            newline_size = 1

   328

   329

        # Disable to type any character in section header lines

   330

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

   331

           not text_selected and \

   332

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

   333

            return

   334

   335

        # Disable to delete line between code and header lines

   336

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

   337

              (key == wx.WXK_BACK and

   338

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

   339

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

   340

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

   341

            return

   342

   343

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

   344

            # Tips

   345

            if event.ShiftDown():

   346

                pass

   347

            # Code completion

   348

            else:

   349

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

   350

   351

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

   352

                                            for var in self.Controler.GetVariables()]

   353

                keywords.sort()

   354

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

   355

        else:

   356

            event.Skip()

   357

   358

    def OnKillFocus(self, event):

   359

        self.AutoCompCancel()

   360

        event.Skip()

   361

   362

    def OnUpdateUI(self, event):

   363

        # check for matching braces

   364

        braceAtCaret = -1

   365

        braceOpposite = -1

   366

        charBefore = None

   367

        caretPos = self.GetCurrentPos()

   368

   369

        if caretPos > 0:

   370

            charBefore = self.GetCharAt(caretPos - 1)

   371

            styleBefore = self.GetStyleAt(caretPos - 1)

   372

   373

        # check before

   374

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

   375

            braceAtCaret = caretPos - 1

   376

   377

        # check after

   378

        if braceAtCaret < 0:

   379

            charAfter = self.GetCharAt(caretPos)

   380

            styleAfter = self.GetStyleAt(caretPos)

   381

   382

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

   383

                braceAtCaret = caretPos

   384

   385

        if braceAtCaret >= 0:

   386

            braceOpposite = self.BraceMatch(braceAtCaret)

   387

   388

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

   389

            self.BraceBadLight(braceAtCaret)

   390

        else:

   391

            self.BraceHighlight(braceAtCaret, braceOpposite)

   392

   393

        selected_text = self.GetSelectedText()

   394

        if selected_text:

   395

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   396

   397

    def OnMarginClick(self, event):

   398

        # fold and unfold as needed

   399

        if event.GetMargin() == 2:

   400

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

   401

                self.FoldAll()

   402

            else:

   403

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

   404

   405

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

   406

                    if event.GetShift():

   407

                        self.SetFoldExpanded(lineClicked, True)

   408

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

   409

                    elif event.GetControl():

   410

                        if self.GetFoldExpanded(lineClicked):

   411

                            self.SetFoldExpanded(lineClicked, False)

   412

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

   413

                        else:

   414

                            self.SetFoldExpanded(lineClicked, True)

   415

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

   416

                    else:

   417

                        self.ToggleFold(lineClicked)

   418

        event.Skip()

   419

   420

    def FoldAll(self):

   421

        lineCount = self.GetLineCount()

   422

        expanding = True

   423

   424

        # find out if we are folding or unfolding

   425

        for lineNum in range(lineCount):

   426

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

   427

                expanding = not self.GetFoldExpanded(lineNum)

   428

                break

   429

   430

        lineNum = 0

   431

   432

        while lineNum < lineCount:

   433

            level = self.GetFoldLevel(lineNum)

   434

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   435

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

   436

   437

                if expanding:

   438

                    self.SetFoldExpanded(lineNum, True)

   439

                    lineNum = self.Expand(lineNum, True)

   440

                    lineNum = lineNum - 1

   441

                else:

   442

                    lastChild = self.GetLastChild(lineNum, -1)

   443

                    self.SetFoldExpanded(lineNum, False)

   444

   445

                    if lastChild > lineNum:

   446

                        self.HideLines(lineNum+1, lastChild)

   447

   448

            lineNum = lineNum + 1

   449

   450

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

   451

        lastChild = self.GetLastChild(line, level)

   452

        line = line + 1

   453

   454

        while line <= lastChild:

   455

            if force:

   456

                if visLevels > 0:

   457

                    self.ShowLines(line, line)

   458

                else:

   459

                    self.HideLines(line, line)

   460

            else:

   461

                if doExpand:

   462

                    self.ShowLines(line, line)

   463

   464

            if level == -1:

   465

                level = self.GetFoldLevel(line)

   466

   467

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   468

                if force:

   469

                    if visLevels > 1:

   470

                        self.SetFoldExpanded(line, True)

   471

                    else:

   472

                        self.SetFoldExpanded(line, False)

   473

   474

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

   475

   476

                else:

   477

                    if doExpand and self.GetFoldExpanded(line):

   478

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

   479

                    else:

   480

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

   481

            else:

   482

                line = line + 1

   483

   484

        return line

   485

   486

    def Cut(self):

   487

        self.ResetBuffer()

   488

        self.DisableEvents = True

   489

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   490

        self.DisableEvents = False

   491

        self.RefreshModel()

   492

        self.RefreshBuffer()

   493

   494

    def Copy(self):

   495

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)