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

import re

    28

from builtins import str as text

    29

    30

import wx

    31

import wx.grid

    32

import wx.stc as stc

    33

import wx.lib.buttons

    34

from six.moves import xrange

    35

    36

    37

from plcopen.plcopen import TestTextElement

    38

from plcopen.structures import TestIdentifier, IEC_KEYWORDS, DefaultType

    39

from controls import CustomGrid, CustomTable

    40

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

    41

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    42

from util.BitmapLibrary import GetBitmap

    43

from util.TranslationCatalogs import NoTranslate

    44

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

    45

    46

    47

[STC_CODE_ERROR, STC_CODE_SEARCH_RESULT,

    48

 STC_CODE_SECTION] = range(15, 18)

    49

    50

HIGHLIGHT_TYPES = {

    51

    ERROR_HIGHLIGHT: STC_CODE_ERROR,

    52

    SEARCH_RESULT_HIGHLIGHT: STC_CODE_SEARCH_RESULT,

    53

}

    54

    55

EDGE_COLUMN = 80

    56

    57

    58

class CodeEditor(CustomStyledTextCtrl):

    59

    60

    KEYWORDS = []

    61

    COMMENT_HEADER = ""

    62

    63

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

    64

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

    65

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

    66

    67

        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)

    68

        self.SetMarginWidth(1, 25)

    69

    70

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

    71

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

    72

        self.SetMargins(0, 0)

    73

    74

        self.SetViewWhiteSpace(False)

    75

    76

        self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)

    77

        self.SetEdgeColumn(EDGE_COLUMN)

    78

    79

        # Setup a margin to hold fold markers

    80

        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)

    81

        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)

    82

        self.SetMarginSensitive(2, True)

    83

        self.SetMarginWidth(2, 12)

    84

    85

        # Like a flattened tree control using square headers

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

    94

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

    95

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

    96

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

    97

    98

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

    99

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

   100

        # Scintilla sample property files.

   101

   102

        # Global default styles for all languages

   103

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

   104

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

   105

   106

        # Global default styles for all languages

   107

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

   108

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

   109

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

   110

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

   111

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

   112

   113

        # Highlighting styles

   114

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

   115

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

   116

   117

        # Section style

   118

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

   119

        self.StyleSetChangeable(STC_CODE_SECTION, False)

   120

   121

        # Indentation size

   122

        self.SetTabWidth(4)

   123

        self.SetUseTabs(0)

   124

   125

        self.SetCodeLexer()

   126

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

   127

   128

        self.Controler = controler

   129

        self.ParentWindow = window

   130

   131

        self.DisableEvents = True

   132

        self.CurrentAction = None

   133

   134

        self.ResetSearchResults()

   135

   136

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

   137

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

   138

   139

        self.SectionsComments = {}

   140

        for section in self.Controler.SECTIONS_NAMES:

   141

            section_comment = " %s section " % (section)

   142

            len_headers = EDGE_COLUMN - len(section_comment)

   143

            section_comment = \

   144

                self.COMMENT_HEADER * (len_headers / 2) + \

   145

                section_comment + \

   146

                self.COMMENT_HEADER * (len_headers - len_headers / 2)

   147

   148

            self.SectionsComments[section] = {

   149

                "comment": section_comment,

   150

            }

   151

   152

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

   153

            section_infos = self.SectionsComments[section]

   154

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

   155

                section_end = self.SectionsComments[

   156

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

   157

            else:

   158

                section_end = "$"

   159

            section_infos["pattern"] = re.compile(

   160

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

   161

                section_end, re.DOTALL)

   162

   163

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

   164

   165

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

   166

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

   167

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

   168

   169

    def SetCodeLexer(self):

   170

        pass

   171

   172

    def ResetSearchResults(self):

   173

        self.Highlights = []

   174

        self.SearchParams = None

   175

        self.SearchResults = None

   176

        self.CurrentFindHighlight = None

   177

   178

    def OnModification(self, event):

   179

        if not self.DisableEvents:

   180

            mod_type = event.GetModificationType()

   181

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

   182

                if mod_type & wx.stc.STC_MOD_BEFOREINSERT:

   183

                    if self.CurrentAction is None:

   184

                        self.StartBuffering()

   185

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

   186

                        self.Controler.EndBuffering()

   187

                        self.StartBuffering()

   188

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

   189

                    wx.CallAfter(self.RefreshModel)

   190

                elif mod_type & wx.stc.STC_MOD_BEFOREDELETE:

   191

                    if self.CurrentAction is None:

   192

                        self.StartBuffering()

   193

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

   194

                        self.Controler.EndBuffering()

   195

                        self.StartBuffering()

   196

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

   197

                    wx.CallAfter(self.RefreshModel)

   198

        wx.CallAfter(self.RefreshSectionStyling)

   199

        event.Skip()

   200

   201

    def OnDoDrop(self, event):

   202

        try:

   203

            values = eval(event.GetDragText())

   204

        except Exception:

   205

            values = event.GetDragText()

   206

        if isinstance(values, tuple):

   207

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

   208

                self.ResetBuffer()

   209

                event.SetDragText(values[0])

   210

                wx.CallAfter(self.RefreshModel)

   211

            else:

   212

                event.SetDragText("")

   213

        else:

   214

            self.ResetBuffer()

   215

            wx.CallAfter(self.RefreshModel)

   216

        event.Skip()

   217

   218

    # Buffer the last model state

   219

    def RefreshBuffer(self):

   220

        self.Controler.BufferCodeFile()

   221

        if self.ParentWindow is not None:

   222

            self.ParentWindow.RefreshTitle()

   223

            self.ParentWindow.RefreshFileMenu()

   224

            self.ParentWindow.RefreshEditMenu()

   225

            self.ParentWindow.RefreshPageTitles()

   226

   227

    def StartBuffering(self):

   228

        self.Controler.StartBuffering()

   229

        if self.ParentWindow is not None:

   230

            self.ParentWindow.RefreshTitle()

   231

            self.ParentWindow.RefreshFileMenu()

   232

            self.ParentWindow.RefreshEditMenu()

   233

            self.ParentWindow.RefreshPageTitles()

   234

   235

    def ResetBuffer(self):

   236

        if self.CurrentAction is not None:

   237

            self.Controler.EndBuffering()

   238

            self.CurrentAction = None

   239

   240

    def GetCodeText(self):

   241

        parts = self.Controler.GetTextParts()

   242

        text = ""

   243

        for section in self.Controler.SECTIONS_NAMES:

   244

            section_comments = self.SectionsComments[section]

   245

            text += section_comments["comment"]

   246

            if parts[section] == "":

   247

                text += "\n"

   248

            else:

   249

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

   250

                    text += "\n"

   251

                text += parts[section]

   252

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

   253

                    text += "\n"

   254

        return text

   255

   256

    def RefreshView(self, scroll_to_highlight=False):

   257

        self.ResetBuffer()

   258

        self.DisableEvents = True

   259

        old_cursor_pos = self.GetCurrentPos()

   260

        line = self.GetFirstVisibleLine()

   261

        column = self.GetXOffset()

   262

        old_text = self.GetText()

   263

        new_text = self.GetCodeText()

   264

        if old_text != new_text:

   265

            self.SetText(new_text)

   266

            new_cursor_pos = GetCursorPos(old_text, new_text)

   267

            self.LineScroll(column, line)

   268

            if new_cursor_pos is not None:

   269

                self.GotoPos(new_cursor_pos)

   270

            else:

   271

                self.GotoPos(old_cursor_pos)

   272

            self.EmptyUndoBuffer()

   273

        self.DisableEvents = False

   274

   275

        self.RefreshSectionStyling()

   276

   277

        self.ShowHighlights()

   278

   279

    def RefreshSectionStyling(self):

   280

        self.Colourise(0, -1)

   281

   282

        text = self.GetText()

   283

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

   284

            self.SetLineState(line, 0)

   285

   286

        for section in self.Controler.SECTIONS_NAMES:

   287

            section_comments = self.SectionsComments[section]

   288

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

   289

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

   290

            self.StartStyling(start_pos, 0xff)

   291

            self.SetStyling(end_pos - start_pos, STC_CODE_SECTION)

   292

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

   293

   294

        self.StartStyling(end_pos, 0x00)

   295

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

   296

   297

    def DoGetBestSize(self):

   298

        return self.ParentWindow.GetPanelBestSize()

   299

   300

    def RefreshModel(self):

   301

        text = self.GetText()

   302

        parts = {}

   303

        for section in self.Controler.SECTIONS_NAMES:

   304

            section_comments = self.SectionsComments[section]

   305

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

   306

            if result is not None:

   307

                parts[section] = result.group(1)

   308

            else:

   309

                parts[section] = ""

   310

        self.Controler.SetTextParts(parts)

   311

        self.ResetSearchResults()

   312

   313

    def OnKeyPressed(self, event):

   314

        if self.CallTipActive():

   315

            self.CallTipCancel()

   316

        key = event.GetKeyCode()

   317

        current_pos = self.GetCurrentPos()

   318

        selected = self.GetSelection()

   319

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

   320

   321

        # Test if caret is before Windows like new line

   322

        text = self.GetText()

   323

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

   324

            newline_size = 2

   325

        else:

   326

            newline_size = 1

   327

   328

        # Disable to type any character in section header lines

   329

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

   330

           not text_selected and \

   331

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

   332

            return

   333

   334

        # Disable to delete line between code and header lines

   335

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

   336

              (key == wx.WXK_BACK and

   337

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

   338

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

   339

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

   340

            return

   341

   342

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

   343

            # Tips

   344

            if event.ShiftDown():

   345

                pass

   346

            # Code completion

   347

            else:

   348

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

   349

   350

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

   351

                                            for var in self.Controler.GetVariables()]

   352

                keywords.sort()

   353

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

   354

        else:

   355

            event.Skip()

   356

   357

    def OnKillFocus(self, event):

   358

        self.AutoCompCancel()

   359

        event.Skip()

   360

   361

    def OnUpdateUI(self, event):

   362

        # check for matching braces

   363

        braceAtCaret = -1

   364

        braceOpposite = -1

   365

        charBefore = None

   366

        caretPos = self.GetCurrentPos()

   367

   368

        if caretPos > 0:

   369

            charBefore = self.GetCharAt(caretPos - 1)

   370

            styleBefore = self.GetStyleAt(caretPos - 1)

   371

   372

        # check before

   373

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

   374

            braceAtCaret = caretPos - 1

   375

   376

        # check after

   377

        if braceAtCaret < 0:

   378

            charAfter = self.GetCharAt(caretPos)

   379

            styleAfter = self.GetStyleAt(caretPos)

   380

   381

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

   382

                braceAtCaret = caretPos

   383

   384

        if braceAtCaret >= 0:

   385

            braceOpposite = self.BraceMatch(braceAtCaret)

   386

   387

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

   388

            self.BraceBadLight(braceAtCaret)

   389

        else:

   390

            self.BraceHighlight(braceAtCaret, braceOpposite)

   391

   392

        selected_text = self.GetSelectedText()

   393

        if selected_text:

   394

            self.ParentWindow.SetCopyBuffer(selected_text, True)

   395

   396

    def OnMarginClick(self, event):

   397

        # fold and unfold as needed

   398

        if event.GetMargin() == 2:

   399

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

   400

                self.FoldAll()

   401

            else:

   402

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

   403

   404

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

   405

                    if event.GetShift():

   406

                        self.SetFoldExpanded(lineClicked, True)

   407

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

   408

                    elif event.GetControl():

   409

                        if self.GetFoldExpanded(lineClicked):

   410

                            self.SetFoldExpanded(lineClicked, False)

   411

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

   412

                        else:

   413

                            self.SetFoldExpanded(lineClicked, True)

   414

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

   415

                    else:

   416

                        self.ToggleFold(lineClicked)

   417

        event.Skip()

   418

   419

    def FoldAll(self):

   420

        lineCount = self.GetLineCount()

   421

        expanding = True

   422

   423

        # find out if we are folding or unfolding

   424

        for lineNum in range(lineCount):

   425

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

   426

                expanding = not self.GetFoldExpanded(lineNum)

   427

                break

   428

   429

        lineNum = 0

   430

   431

        while lineNum < lineCount:

   432

            level = self.GetFoldLevel(lineNum)

   433

            if level & stc.STC_FOLDLEVELHEADERFLAG and \

   434

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

   435

   436

                if expanding:

   437

                    self.SetFoldExpanded(lineNum, True)

   438

                    lineNum = self.Expand(lineNum, True)

   439

                    lineNum = lineNum - 1

   440

                else:

   441

                    lastChild = self.GetLastChild(lineNum, -1)

   442

                    self.SetFoldExpanded(lineNum, False)

   443

   444

                    if lastChild > lineNum:

   445

                        self.HideLines(lineNum+1, lastChild)

   446

   447

            lineNum = lineNum + 1

   448

   449

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

   450

        lastChild = self.GetLastChild(line, level)

   451

        line = line + 1

   452

   453

        while line <= lastChild:

   454

            if force:

   455

                if visLevels > 0:

   456

                    self.ShowLines(line, line)

   457

                else:

   458

                    self.HideLines(line, line)

   459

            else:

   460

                if doExpand:

   461

                    self.ShowLines(line, line)

   462

   463

            if level == -1:

   464

                level = self.GetFoldLevel(line)

   465

   466

            if level & stc.STC_FOLDLEVELHEADERFLAG:

   467

                if force:

   468

                    if visLevels > 1:

   469

                        self.SetFoldExpanded(line, True)

   470

                    else:

   471

                        self.SetFoldExpanded(line, False)

   472

   473

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

   474

   475

                else:

   476

                    if doExpand and self.GetFoldExpanded(line):

   477

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

   478

                    else:

   479

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

   480

            else:

   481

                line = line + 1

   482

   483

        return line

   484

   485

    def Cut(self):

   486

        self.ResetBuffer()

   487

        self.DisableEvents = True

   488

        self.CmdKeyExecute(wx.stc.STC_CMD_CUT)

   489

        self.DisableEvents = False

   490

        self.RefreshModel()

   491

        self.RefreshBuffer()

   492

   493

    def Copy(self):

   494

        self.CmdKeyExecute(wx.stc.STC_CMD_COPY)

   495

        self.ParentWindow.RefreshEditMenu()